diff --git a/packages/node/meshnet_node/model_backend.py b/packages/node/meshnet_node/model_backend.py
index ef189fa..0fdadba 100644
--- a/packages/node/meshnet_node/model_backend.py
+++ b/packages/node/meshnet_node/model_backend.py
@@ -1,792 +1,827 @@
-"""HuggingFace/PyTorch shard backend for real node inference."""
-
-from __future__ import annotations
-
-import base64
-from dataclasses import dataclass
-import json
-from pathlib import Path
-from typing import Any, Literal
-
-Quantization = Literal["auto", "bfloat16", "int8", "nf4"]
-
-
-class ModelBackendError(RuntimeError):
-    """Base class for real model backend startup and execution failures."""
-
-
-class MissingModelDependencyError(ModelBackendError):
-    """Raised when optional model dependencies are not installed."""
-
-
-class InsufficientVRAMError(ModelBackendError):
-    """Raised when a requested shard cannot fit in available CUDA memory."""
-
-
-class PartialModelLoadUnsupported(ModelBackendError):
-    """Raised when a shard cannot be materialized from a local snapshot subset."""
-
-
-@dataclass(frozen=True)
-class TensorPayload:
-    body: bytes
-    shape: list[int]
-    attention_mask_header: str | None
-    position_ids_header: str | None
-
-
-def validate_quantization(value: str) -> Quantization:
-    if value not in {"auto", "bfloat16", "int8", "nf4"}:
-        raise ValueError("quantization must be one of: auto, bfloat16, int8, nf4")
-    return value  # type: ignore[return-value]
-
-
-def build_quantization_config(quantization: Quantization) -> Any | None:
-    """Return a transformers BitsAndBytesConfig for quantized weights."""
-    if quantization in {"auto", "bfloat16"}:
-        return None
-    try:
-        import torch
-        from transformers import BitsAndBytesConfig
-    except ModuleNotFoundError as exc:
-        raise MissingModelDependencyError(
-            "transformers and torch are required for int8/nf4 quantization"
-        ) from exc
-
-    if quantization == "int8":
-        return BitsAndBytesConfig(load_in_8bit=True)
-    return BitsAndBytesConfig(
-        load_in_4bit=True,
-        bnb_4bit_quant_type="nf4",
-        bnb_4bit_compute_dtype=torch.bfloat16,
-    )
-
-
-class TorchModelShard:
-    """Executable subset of a HuggingFace causal language model."""
-
-    def __init__(
-        self,
-        model_id: str,
-        shard_start: int,
-        shard_end: int,
-        quantization: Quantization = "auto",
-        cache_dir: Path | None = None,
-    ) -> None:
-        if shard_start < 0 or shard_end < 0 or shard_start > shard_end:
-            raise ValueError("shard_start must be <= shard_end and non-negative")
-        self.model_id = model_id
-        self.shard_start = shard_start
-        self.shard_end = shard_end
-        self.quantization = quantization
-
-        try:
-            import torch
-            from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
-        except ModuleNotFoundError as exc:
-            raise MissingModelDependencyError(
-                "real model backend requires torch, transformers, safetensors, accelerate, and bitsandbytes"
-            ) from exc
-
-        self.torch = torch
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        load_source = str(cache_dir) if cache_dir is not None and (cache_dir / "config.json").exists() else model_id
-        quant_config, dtype, uses_quantized_weights = _model_load_plan(
-            AutoConfig,
-            load_source,
-            quantization,
-            torch,
-            None if load_source != model_id else cache_dir,
-        )
-        try:
-            total_layers_hint = _total_layers_for_local_snapshot(AutoConfig, load_source)
-            if _should_partial_materialize_shard(
-                load_source,
-                shard_start,
-                shard_end,
-                total_layers_hint=total_layers_hint,
-                uses_quantized_weights=uses_quantized_weights,
-            ):
-                self.model = _load_partial_model_from_snapshot(
-                    AutoConfig,
-                    AutoModelForCausalLM,
-                    torch,
-                    load_source,
-                    shard_start,
-                    shard_end,
-                    dtype,
-                    self.device,
-                )
-            else:
-                load_kwargs = {
-                    "device_map": "auto" if uses_quantized_weights else None,
-                    "dtype": dtype,
-                    "low_cpu_mem_usage": True,
-                    "cache_dir": str(cache_dir) if cache_dir is not None and load_source == model_id else None,
-                }
-                if quant_config is not None:
-                    load_kwargs["quantization_config"] = quant_config
-                self.model = AutoModelForCausalLM.from_pretrained(
-                    load_source,
-                    **load_kwargs,
-                )
-                if not uses_quantized_weights:
-                    self.model.to(self.device)
-        except Exception as exc:
-            if _looks_like_oom(exc):
-                memory_kind = "VRAM" if self.device.type == "cuda" else "RAM"
-                raise InsufficientVRAMError(
-                    f"insufficient {memory_kind} to load {model_id} layers {shard_start}:{shard_end} "
-                    f"with {quantization} quantization; choose a smaller shard or lower quantization"
-                ) from exc
-            raise
-
-        self.model.eval()
-        self.tokenizer = AutoTokenizer.from_pretrained(
-            load_source,
-            cache_dir=str(cache_dir) if cache_dir is not None and load_source == model_id else None,
-        )
-        self.layers = _model_layers(self.model)
-        self.total_layers = len(self.layers)
-        # shard_end is INCLUSIVE (last layer index, 0-based), matching the CLI convention.
-        if shard_end >= self.total_layers:
-            raise ValueError(
-                f"shard_end {shard_end} exceeds last layer index {self.total_layers - 1}"
-            )
-        self.is_head = shard_start == 0
-        self.is_tail = shard_end >= self.total_layers - 1
-        self.hidden_size = int(
-            getattr(self.model.config, "hidden_size", 0)
-            or getattr(self.model.config, "n_embd", 0)
-        )
-        self._embed_tokens = _embed_tokens(self.model) if self.is_head else None
-        self._position_embeddings = _position_embeddings(self.model)
-        self._norm = _final_norm(self.model) if self.is_tail else None
-        self._lm_head = getattr(self.model, "lm_head", None) if self.is_tail else None
-
-    def encode_prompt(self, prompt: str) -> TensorPayload:
-        if not self.is_head or self._embed_tokens is None:
-            raise ModelBackendError("text prompts can only be accepted by the head shard")
-        encoded = self.tokenizer(prompt, return_tensors="pt")
-        input_ids = encoded["input_ids"].to(self.device)
-        attention_mask = encoded.get("attention_mask")
-        if attention_mask is None:
-            attention_mask = self.torch.ones_like(input_ids)
-        attention_mask = attention_mask.to(self.device)
-        position_ids = _position_ids(attention_mask, self.torch)
-        hidden_states = self._embed_tokens(input_ids)
-        if self._position_embeddings is not None:
-            hidden_states = hidden_states + self._position_embeddings(position_ids)
-        hidden_states = self._run_layers(hidden_states, attention_mask, position_ids)
-        return self._payload(hidden_states, attention_mask, position_ids)
-
-    def forward_bytes(
-        self,
-        body: bytes,
-        shape: list[int],
-        attention_mask_header: str | None,
-        position_ids_header: str | None,
-        start_layer: int | None = None,
-    ) -> TensorPayload | str:
-        hidden_states = _tensor_from_bfloat16_bytes(body, shape, self.torch).to(
-            self.device
-        )
-        attention_mask = _tensor_from_int64_header(
-            attention_mask_header, self.torch, self.device
-        )
-        position_ids = _tensor_from_int64_header(
-            position_ids_header, self.torch, self.device
-        )
-        hidden_states = self._run_layers(
-            hidden_states, attention_mask, position_ids, start_layer=start_layer
-        )
-        if self.is_tail:
-            return self.decode_tail(hidden_states)
-        return self._payload(hidden_states, attention_mask, position_ids)
-
-    def decode_tail(self, hidden_states: Any) -> str:
-        if self._norm is not None:
-            hidden_states = self._norm(hidden_states)
-        if self._lm_head is None:
-            raise ModelBackendError("tail shard has no lm_head")
-        logits = self._lm_head(hidden_states)
-        token_id = int(self.torch.argmax(logits[:, -1, :], dim=-1)[0].item())
-        return self.tokenizer.decode([token_id], skip_special_tokens=True)
-
-    def generate_text(
-        self,
-        messages: list[dict],
-        max_new_tokens: int = 5120,
-        temperature: float = 1.0,
-        top_p: float = 1.0,
-    ) -> str:
-        """Autoregressive generation using HF generate() — single-node (head+tail) mode."""
-        if not self.is_head or not self.is_tail:
-            raise ModelBackendError("local generation requires a full head+tail shard")
-        encoded = self._encode_messages(messages)
-        input_ids = encoded["input_ids"].to(self.device)
-        attention_mask = encoded.get("attention_mask")
-        if attention_mask is not None:
-            attention_mask = attention_mask.to(self.device)
-        pad_token_id = getattr(self.tokenizer, "pad_token_id", None) or getattr(self.tokenizer, "eos_token_id", None)
-        do_sample = temperature != 1.0 or top_p != 1.0
-        with self.torch.inference_mode():
-            generated = self.model.generate(
-                input_ids=input_ids,
-                attention_mask=attention_mask,
-                max_new_tokens=max(1, int(max_new_tokens)),
-                do_sample=do_sample,
-                temperature=temperature if do_sample else None,
-                top_p=top_p if do_sample else None,
-                pad_token_id=pad_token_id,
-            )
-        new_tokens = generated[0, input_ids.shape[-1]:]
-        return self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
-
-    def generate_text_streaming(
-        self,
-        messages: list[dict],
-        max_new_tokens: int = 5000,
-        temperature: float = 1.0,
-        top_p: float = 1.0,
-    ):
-        """Yield decoded token strings one at a time using HF TextIteratorStreamer."""
-        if not self.is_head or not self.is_tail:
-            raise ModelBackendError("streaming generation requires a full head+tail shard")
-        import threading
-        try:
-            from transformers import TextIteratorStreamer  # type: ignore[import]
-        except ImportError:
-            yield self.generate_text(messages, max_new_tokens, temperature, top_p)
-            return
-
-        encoded = self._encode_messages(messages)
-        input_ids = encoded["input_ids"].to(self.device)
-        attention_mask = encoded.get("attention_mask")
-        if attention_mask is not None:
-            attention_mask = attention_mask.to(self.device)
-        pad_token_id = getattr(self.tokenizer, "pad_token_id", None) or getattr(self.tokenizer, "eos_token_id", None)
-        do_sample = temperature != 1.0 or top_p != 1.0
-
-        streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
-        gen_kwargs = dict(
-            input_ids=input_ids,
-            attention_mask=attention_mask,
-            max_new_tokens=max(1, int(max_new_tokens)),
-            do_sample=do_sample,
-            temperature=temperature if do_sample else None,
-            top_p=top_p if do_sample else None,
-            pad_token_id=pad_token_id,
-            streamer=streamer,
-        )
-        t = threading.Thread(target=self.model.generate, kwargs=gen_kwargs, daemon=True)
-        t.start()
-        for token_text in streamer:
-            yield token_text
-        t.join()
-
-    def count_prompt_tokens(self, messages: list[dict]) -> int:
-        """Return tokenizer-backed prompt token count for OpenAI usage metadata."""
-        encoded = self._encode_messages(messages)
-        input_ids = encoded["input_ids"]
-        return int(input_ids.shape[-1])
-
-    def count_text_tokens(self, text: str) -> int:
-        """Return tokenizer-backed completion token count for OpenAI usage metadata."""
-        try:
-            encoded = self.tokenizer(
-                text,
-                return_tensors="pt",
-                add_special_tokens=False,
-            )
-        except TypeError:
-            encoded = self.tokenizer(text, return_tensors="pt")
-        return int(encoded["input_ids"].shape[-1])
-
-    def _encode_messages(self, messages: list[dict]) -> dict:
-        """Format messages with chat template (if available) and tokenize."""
-        if hasattr(self.tokenizer, "apply_chat_template"):
-            try:
-                prompt_str = self.tokenizer.apply_chat_template(
-                    messages,
-                    add_generation_prompt=True,
-                    tokenize=False,
-                )
-                return dict(self.tokenizer(prompt_str, return_tensors="pt"))
-            except Exception:
-                pass
-        prompt = " ".join(
-            str(m.get("content", ""))
-            for m in messages
-            if isinstance(m, dict) and m.get("role") == "user"
-        )
-        return dict(self.tokenizer(prompt, return_tensors="pt"))
-
-    def _run_layers(
-        self,
-        hidden_states: Any,
-        attention_mask: Any,
-        position_ids: Any,
-        start_layer: int | None = None,
-    ) -> Any:
-        # start_layer overrides shard_start for overlapping-shard routing
-        # (X-Meshnet-Start-Layer header). Clamped to shard_start to prevent
-        # indexing outside the loaded weights.
-        effective_start = (
-            max(self.shard_start, start_layer)
-            if start_layer is not None
-            else self.shard_start
-        )
-        position_embeddings = _rotary_position_embeddings(
-            self.model,
-            hidden_states,
-            position_ids,
-        )
-        layer_attention_mask = _decoder_attention_mask(
-            attention_mask,
-            hidden_states,
-            self.torch,
-        )
-        with self.torch.inference_mode():
-            for layer in self.layers[effective_start:self.shard_end + 1]:
-                hidden_states = _call_layer(
-                    layer,
-                    hidden_states,
-                    layer_attention_mask,
-                    position_ids,
-                    position_embeddings,
-                )
-            return hidden_states.to(self.torch.bfloat16)
-
-    def _payload(self, hidden_states: Any, attention_mask: Any, position_ids: Any) -> TensorPayload:
-        hidden_states = hidden_states.to(self.torch.bfloat16).contiguous()
-        return TensorPayload(
-            body=_tensor_to_bytes(hidden_states),
-            shape=list(hidden_states.shape),
-            attention_mask_header=_int_tensor_header(attention_mask)
-            if attention_mask is not None
-            else None,
-            position_ids_header=_int_tensor_header(position_ids)
-            if position_ids is not None
-            else None,
-        )
-
-
-def load_torch_shard(
-    model_id: str,
-    shard_start: int,
-    shard_end: int,
-    quantization: Quantization = "auto",
-    cache_dir: Path | None = None,
-) -> TorchModelShard:
-    return TorchModelShard(model_id, shard_start, shard_end, quantization, cache_dir)
-
-
-def _total_layers_for_local_snapshot(auto_config: Any, load_source: str) -> int | None:
-    snapshot_dir = Path(load_source)
-    if not (snapshot_dir / "config.json").exists():
-        return None
-    from .model_catalog import layers_from_config
-
-    try:
-        cfg = auto_config.from_pretrained(str(snapshot_dir))
-    except Exception:
-        return None
-    return layers_from_config(cfg)
-
-
-def _should_partial_materialize_shard(
-    load_source: str,
-    shard_start: int,
-    shard_end: int,
-    *,
-    total_layers_hint: int | None,
-    uses_quantized_weights: bool,
-) -> bool:
-    if uses_quantized_weights:
-        return False
-    snapshot_dir = Path(load_source)
-    if not snapshot_dir.exists() or not (snapshot_dir / "config.json").exists():
-        return False
-    if not (snapshot_dir / "model.safetensors.index.json").exists():
-        return False
-    if total_layers_hint is None:
-        return False
-    return True
-
-
-def _load_partial_model_from_snapshot(
-    auto_config: Any,
-    auto_model_for_causal_lm: Any,
-    torch: Any,
-    load_source: str,
-    shard_start: int,
-    shard_end: int,
-    dtype: Any,
-    device: Any,
-    *,
-    init_empty_weights_fn: Any | None = None,
-    set_tensor_fn: Any | None = None,
-    safe_open_fn: Any | None = None,
-) -> Any:
-    from .model_catalog import layers_from_config
-    from .safetensors_selection import (
-        INDEX_FILENAME,
-        select_tensor_names_for_layers_from_index,
-    )
-
-    if init_empty_weights_fn is None:
-        from accelerate import init_empty_weights as init_empty_weights_fn
-    if set_tensor_fn is None:
-        from accelerate.utils import set_module_tensor_to_device as set_tensor_fn
-    if safe_open_fn is None:
-        from safetensors import safe_open as safe_open_fn
-
-    snapshot_dir = Path(load_source)
-    cfg = auto_config.from_pretrained(str(snapshot_dir))
-    total_layers = layers_from_config(cfg)
-    if total_layers is None:
-        raise PartialModelLoadUnsupported(
-            f"could not determine num_hidden_layers for local snapshot {snapshot_dir}"
-        )
-    if shard_end >= total_layers:
-        raise ValueError(
-            f"shard_end {shard_end} exceeds last layer index {total_layers - 1}"
-        )
-
-    index_path = snapshot_dir / INDEX_FILENAME
-    try:
-        index = json.loads(index_path.read_text(encoding="utf-8"))
-    except FileNotFoundError as exc:
-        raise PartialModelLoadUnsupported(
-            f"missing SafeTensors index for partial load: {index_path}"
-        ) from exc
-    weight_map = index.get("weight_map")
-    if not isinstance(weight_map, dict):
-        raise PartialModelLoadUnsupported(f"{INDEX_FILENAME} must contain a weight_map object")
-
-    tensor_names = select_tensor_names_for_layers_from_index(
-        weight_map,
-        shard_start,
-        shard_end,
-        total_layers=total_layers,
-    )
-    if not tensor_names:
-        raise PartialModelLoadUnsupported(
-            f"no checkpoint tensors matched layers {shard_start}-{shard_end} in {snapshot_dir}"
-        )
-
-    with init_empty_weights_fn():
-        model = auto_model_for_causal_lm.from_config(_causal_lm_config(cfg), torch_dtype=dtype)
-    tie_weights = getattr(model, "tie_weights", None)
-    if callable(tie_weights):
-        tie_weights()
-
-    tensors_by_file: dict[str, list[str]] = {}
-    for tensor_name in sorted(tensor_names):
-        rel_file = weight_map.get(tensor_name)
-        if not isinstance(rel_file, str):
-            continue
-        tensors_by_file.setdefault(rel_file, []).append(tensor_name)
-
-    for rel_file, names in tensors_by_file.items():
-        checkpoint_file = snapshot_dir / rel_file
-        if not checkpoint_file.exists():
-            raise PartialModelLoadUnsupported(
-                f"checkpoint file advertised in {INDEX_FILENAME} is missing: {checkpoint_file}"
-            )
-        with safe_open_fn(str(checkpoint_file), framework="pt", device="cpu") as handle:
-            for tensor_name in names:
-                set_tensor_fn(
-                    model,
-                    _checkpoint_tensor_name_for_model(model, tensor_name),
-                    device,
-                    value=handle.get_tensor(tensor_name),
-                    dtype=dtype,
-                )
-
-    for module in _active_modules_for_shard(model, shard_start, shard_end):
-        if hasattr(module, "to"):
-            module.to(device)
-    return model
-
-
-def _model_load_plan(
-    auto_config: Any,
-    model_id: str,
-    quantization: Quantization,
-    torch: Any,
-    cache_dir: Path | None = None,
-) -> tuple[Any | None, Any, bool]:
-    """Return (explicit quant config, dtype, uses quantized weights)."""
-    if quantization != "auto":
-        quant_config = build_quantization_config(quantization)
-        return quant_config, torch.bfloat16, quant_config is not None
-
-    cfg = auto_config.from_pretrained(
-        model_id,
-        cache_dir=str(cache_dir) if cache_dir is not None else None,
-    )
-    if _native_quantization_config(cfg) is not None:
-        return None, _native_torch_dtype(cfg, torch), True
-    return None, _native_torch_dtype(cfg, torch), False
-
-
-def _config_candidates(cfg: Any) -> list[Any]:
-    candidates = [cfg]
-    get_text_config = getattr(cfg, "get_text_config", None)
-    if callable(get_text_config):
-        try:
-            candidates.append(get_text_config())
-        except Exception:
-            pass
-    text_config = getattr(cfg, "text_config", None)
-    if text_config is not None:
-        candidates.append(text_config)
-    return candidates
-
-
-def _native_quantization_config(cfg: Any) -> Any | None:
-    for candidate in _config_candidates(cfg):
-        quant_config = getattr(candidate, "quantization_config", None)
-        if quant_config:
-            return quant_config
-    return None
-
-
-def _native_torch_dtype(cfg: Any, torch: Any) -> Any:
-    for candidate in _config_candidates(cfg):
-        for attr in ("dtype", "torch_dtype"):
-            dtype = getattr(candidate, attr, None)
-            if dtype is None:
-                continue
-            if isinstance(dtype, str):
-                dtype_name = dtype.removeprefix("torch.")
-                dtype_value = getattr(torch, dtype_name, None)
-                if dtype_value is not None:
-                    return dtype_value
-            else:
-                return dtype
-    return torch.bfloat16
-
-
-def _causal_lm_config(cfg: Any) -> Any:
-    """Use the text decoder config for composite VLM/MoE presets."""
-    get_text_config = getattr(cfg, "get_text_config", None)
-    if callable(get_text_config):
-        try:
-            return get_text_config()
-        except Exception:
-            pass
-    text_config = getattr(cfg, "text_config", None)
-    if text_config is not None:
-        return text_config
-    return cfg
-
-
-def _checkpoint_tensor_name_for_model(model: Any, tensor_name: str) -> str:
-    """Map multimodal checkpoint keys onto text-only CausalLM modules when needed."""
-    inner = getattr(model, "model", None)
-    if inner is not None and hasattr(inner, "language_model"):
-        return tensor_name
-    if ".language_model." in tensor_name:
-        return tensor_name.replace(".language_model.", ".")
-    return tensor_name
-
-
-def _transformer_backbone(model: Any) -> Any:
-    if hasattr(model, "model"):
-        inner = model.model
-        language_model = getattr(inner, "language_model", None)
-        if language_model is not None:
-            return language_model
-        return inner
-    if hasattr(model, "transformer"):
-        return model.transformer
-    raise ModelBackendError(
-        "unsupported HuggingFace model architecture: no transformer backbone found"
-    )
-
-
-def _model_layers(model: Any) -> Any:
-    backbone = _transformer_backbone(model)
-    for attr in ("layers", "h", "blocks"):
-        layers = getattr(backbone, attr, None)
-        if layers is not None:
-            return layers
-    raise ModelBackendError(
-        "unsupported HuggingFace model architecture: no transformer layers found"
-    )
-
-
-def _embed_tokens(model: Any) -> Any:
-    backbone = _transformer_backbone(model)
-    for attr in ("embed_tokens", "wte"):
-        embed = getattr(backbone, attr, None)
-        if embed is not None:
-            return embed
-    raise ModelBackendError(
-        "unsupported HuggingFace model architecture: no token embeddings found"
-    )
-
-
-def _position_embeddings(model: Any) -> Any | None:
-    backbone = _transformer_backbone(model)
-    return getattr(backbone, "wpe", None)
-
-
-def _rotary_embedding_module(model: Any) -> Any | None:
-    backbone = _transformer_backbone(model)
-    return getattr(backbone, "rotary_emb", None)
-
-
-def _active_modules_for_shard(model: Any, shard_start: int, shard_end: int) -> list[Any]:
-    active: list[Any] = []
-
-    def add(module: Any | None) -> None:
-        if module is None:
-            return
-        if any(existing is module for existing in active):
-            return
-        active.append(module)
-
-    if shard_start == 0:
-        add(_embed_tokens(model))
-        add(_position_embeddings(model))
-    add(_rotary_embedding_module(model))
-    for layer in _model_layers(model)[shard_start:shard_end + 1]:
-        add(layer)
-    total_layers = len(_model_layers(model))
-    if shard_end >= total_layers - 1:
-        add(_final_norm(model))
-        add(getattr(model, "lm_head", None))
-    return active
-
-
-def _final_norm(model: Any) -> Any | None:
-    backbone = _transformer_backbone(model)
-    for attr in ("norm", "ln_f", "final_layer_norm"):
-        norm = getattr(backbone, attr, None)
-        if norm is not None:
-            return norm
-    return None
-
-
-def _position_ids(attention_mask: Any, torch: Any) -> Any:
-    position_ids = attention_mask.long().cumsum(-1) - 1
-    return position_ids.masked_fill(attention_mask == 0, 0).to(torch.long)
-
-
-def _decoder_attention_mask(attention_mask: Any, hidden_states: Any, torch: Any) -> Any:
-    """Build a causal additive mask for decoder layers called outside model.forward."""
-    if attention_mask is None:
-        return None
-    if len(getattr(attention_mask, "shape", ())) != 2:
-        return attention_mask
-    batch_size, seq_len = attention_mask.shape
-    if seq_len <= 1:
-        return None if bool(attention_mask.all()) else attention_mask.to(hidden_states.dtype)
-
-    min_value = torch.finfo(hidden_states.dtype).min
-    causal = torch.full(
-        (seq_len, seq_len),
-        min_value,
-        dtype=hidden_states.dtype,
-        device=hidden_states.device,
-    )
-    causal = torch.triu(causal, diagonal=1)
-    causal = causal[None, None, :, :].expand(batch_size, 1, seq_len, seq_len).clone()
-
-    padding = attention_mask.to(device=hidden_states.device)
-    if not bool(padding.all()):
-        causal = causal.masked_fill(padding[:, None, None, :] == 0, min_value)
-    return causal
-
-
-def _rotary_position_embeddings(model: Any, hidden_states: Any, position_ids: Any) -> Any | None:
-    """Return model-level rotary embeddings required by newer HF decoder layers."""
-    if position_ids is None:
-        return None
-    rotary = _rotary_embedding_module(model)
-    if rotary is None:
-        return None
-    return rotary(hidden_states, position_ids)
-
-
-def _call_layer(
-    layer: Any,
-    hidden_states: Any,
-    attention_mask: Any,
-    position_ids: Any,
-    position_embeddings: Any | None = None,
-) -> Any:
-    attempts = (
-        {
-            "attention_mask": attention_mask,
-            "position_ids": position_ids,
-            "position_embeddings": position_embeddings,
-            "use_cache": False,
-        },
-        {
-            "attention_mask": attention_mask,
-            "position_ids": position_ids,
-            "use_cache": False,
-        },
-        {"attention_mask": attention_mask, "use_cache": False},
-        {"use_cache": False},
-        {},
-    )
-    last_exc: Exception | None = None
-    for kwargs in attempts:
-        filtered = {key: value for key, value in kwargs.items() if value is not None}
-        try:
-            output = layer(hidden_states, **filtered)
-            return output[0] if isinstance(output, tuple) else output
-        except TypeError as exc:
-            last_exc = exc
-    if last_exc is not None:
-        raise last_exc
-    return layer(hidden_states)[0]
-
-
-def _tensor_to_bytes(tensor: Any) -> bytes:
-    import torch
-
-    return tensor.detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()
-
-
-def _tensor_from_bfloat16_bytes(body: bytes, shape: list[int], torch: Any) -> Any:
-    tensor = torch.frombuffer(bytearray(body), dtype=torch.bfloat16)
-    return tensor.reshape(shape)
-
-
-def _int_tensor_header(tensor: Any) -> str:
-    data = tensor.detach().cpu().long().contiguous()
-    raw = data.numpy().tobytes()
-    shape = ",".join(str(dim) for dim in data.shape)
-    encoded = base64.b64encode(raw).decode("ascii")
-    return f"{shape}:{encoded}"
-
-
-def _tensor_from_int64_header(value: str | None, torch: Any, device: Any) -> Any | None:
-    if not value:
-        return None
-    shape_text, encoded = value.split(":", 1)
-    shape = [int(part) for part in shape_text.split(",") if part]
-    raw = base64.b64decode(encoded.encode("ascii"))
-    return torch.frombuffer(bytearray(raw), dtype=torch.int64).reshape(shape).to(device)
-
-
-def _looks_like_oom(exc: BaseException) -> bool:
-    current: BaseException | None = exc
-    while current is not None:
-        text = str(current).lower()
-        if (
-            "out of memory" in text
-            or "cuda error: out of memory" in text
-            or "paging file is too small" in text
-            or "os error 1455" in text
-        ):
-            return True
-        current = current.__cause__ or current.__context__
-    return False
+"""HuggingFace/PyTorch shard backend for real node inference."""
+
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any, Literal
+
+Quantization = Literal["auto", "bfloat16", "int8", "nf4"]
+
+
+class ModelBackendError(RuntimeError):
+    """Base class for real model backend startup and execution failures."""
+
+
+class MissingModelDependencyError(ModelBackendError):
+    """Raised when optional model dependencies are not installed."""
+
+
+class InsufficientVRAMError(ModelBackendError):
+    """Raised when a requested shard cannot fit in available CUDA memory."""
+
+
+class PartialModelLoadUnsupported(ModelBackendError):
+    """Raised when a shard cannot be materialized from a local snapshot subset."""
+
+
+@dataclass(frozen=True)
+class TensorPayload:
+    body: bytes
+    shape: list[int]
+    attention_mask_header: str | None
+    position_ids_header: str | None
+
+
+def validate_quantization(value: str) -> Quantization:
+    if value not in {"auto", "bfloat16", "int8", "nf4"}:
+        raise ValueError("quantization must be one of: auto, bfloat16, int8, nf4")
+    return value  # type: ignore[return-value]
+
+
+def build_quantization_config(quantization: Quantization) -> Any | None:
+    """Return a transformers BitsAndBytesConfig for quantized weights."""
+    if quantization in {"auto", "bfloat16"}:
+        return None
+    try:
+        import torch
+        from transformers import BitsAndBytesConfig
+    except ModuleNotFoundError as exc:
+        raise MissingModelDependencyError(
+            "transformers and torch are required for int8/nf4 quantization"
+        ) from exc
+
+    if quantization == "int8":
+        return BitsAndBytesConfig(load_in_8bit=True)
+    return BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+    )
+
+
+class TorchModelShard:
+    """Executable subset of a HuggingFace causal language model."""
+
+    def __init__(
+        self,
+        model_id: str,
+        shard_start: int,
+        shard_end: int,
+        quantization: Quantization = "auto",
+        cache_dir: Path | None = None,
+    ) -> None:
+        if shard_start < 0 or shard_end < 0 or shard_start > shard_end:
+            raise ValueError("shard_start must be <= shard_end and non-negative")
+        self.model_id = model_id
+        self.shard_start = shard_start
+        self.shard_end = shard_end
+        self.quantization = quantization
+
+        try:
+            import torch
+            from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
+        except ModuleNotFoundError as exc:
+            raise MissingModelDependencyError(
+                "real model backend requires torch, transformers, safetensors, accelerate, and bitsandbytes"
+            ) from exc
+
+        self.torch = torch
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        load_source = str(cache_dir) if cache_dir is not None and (cache_dir / "config.json").exists() else model_id
+        quant_config, dtype, uses_quantized_weights = _model_load_plan(
+            AutoConfig,
+            load_source,
+            quantization,
+            torch,
+            None if load_source != model_id else cache_dir,
+        )
+        try:
+            total_layers_hint = _total_layers_for_local_snapshot(AutoConfig, load_source)
+            if _should_partial_materialize_shard(
+                load_source,
+                shard_start,
+                shard_end,
+                total_layers_hint=total_layers_hint,
+                uses_quantized_weights=uses_quantized_weights,
+            ):
+                self.model = _load_partial_model_from_snapshot(
+                    AutoConfig,
+                    AutoModelForCausalLM,
+                    torch,
+                    load_source,
+                    shard_start,
+                    shard_end,
+                    dtype,
+                    self.device,
+                )
+            else:
+                load_kwargs = {
+                    "device_map": "auto" if uses_quantized_weights else None,
+                    "dtype": dtype,
+                    "low_cpu_mem_usage": True,
+                    "cache_dir": str(cache_dir) if cache_dir is not None and load_source == model_id else None,
+                }
+                if quant_config is not None:
+                    load_kwargs["quantization_config"] = quant_config
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    load_source,
+                    **load_kwargs,
+                )
+                if not uses_quantized_weights:
+                    self.model.to(self.device)
+        except Exception as exc:
+            if _looks_like_oom(exc):
+                memory_kind = "VRAM" if self.device.type == "cuda" else "RAM"
+                raise InsufficientVRAMError(
+                    f"insufficient {memory_kind} to load {model_id} layers {shard_start}:{shard_end} "
+                    f"with {quantization} quantization; choose a smaller shard or lower quantization"
+                ) from exc
+            raise
+
+        self.model.eval()
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            load_source,
+            cache_dir=str(cache_dir) if cache_dir is not None and load_source == model_id else None,
+        )
+        self.layers = _model_layers(self.model)
+        self.total_layers = len(self.layers)
+        # shard_end is INCLUSIVE (last layer index, 0-based), matching the CLI convention.
+        if shard_end >= self.total_layers:
+            raise ValueError(
+                f"shard_end {shard_end} exceeds last layer index {self.total_layers - 1}"
+            )
+        self.is_head = shard_start == 0
+        self.is_tail = shard_end >= self.total_layers - 1
+        self.hidden_size = int(
+            getattr(self.model.config, "hidden_size", 0)
+            or getattr(self.model.config, "n_embd", 0)
+        )
+        self._embed_tokens = _embed_tokens(self.model) if self.is_head else None
+        self._position_embeddings = _position_embeddings(self.model)
+        self._norm = _final_norm(self.model) if self.is_tail else None
+        self._lm_head = getattr(self.model, "lm_head", None) if self.is_tail else None
+
+    def encode_prompt(self, prompt: str) -> TensorPayload:
+        if not self.is_head or self._embed_tokens is None:
+            raise ModelBackendError("text prompts can only be accepted by the head shard")
+        encoded = self.tokenizer(prompt, return_tensors="pt")
+        input_ids = encoded["input_ids"].to(self.device)
+        attention_mask = encoded.get("attention_mask")
+        if attention_mask is None:
+            attention_mask = self.torch.ones_like(input_ids)
+        attention_mask = attention_mask.to(self.device)
+        position_ids = _position_ids(attention_mask, self.torch)
+        hidden_states = self._embed_tokens(input_ids)
+        if self._position_embeddings is not None:
+            hidden_states = hidden_states + self._position_embeddings(position_ids)
+        hidden_states = self._run_layers(hidden_states, attention_mask, position_ids)
+        return self._payload(hidden_states, attention_mask, position_ids)
+
+    def forward_bytes(
+        self,
+        body: bytes,
+        shape: list[int],
+        attention_mask_header: str | None,
+        position_ids_header: str | None,
+        start_layer: int | None = None,
+    ) -> TensorPayload | str:
+        hidden_states = _tensor_from_bfloat16_bytes(body, shape, self.torch).to(
+            self.device
+        )
+        attention_mask = _tensor_from_int64_header(
+            attention_mask_header, self.torch, self.device
+        )
+        position_ids = _tensor_from_int64_header(
+            position_ids_header, self.torch, self.device
+        )
+        hidden_states = self._run_layers(
+            hidden_states, attention_mask, position_ids, start_layer=start_layer
+        )
+        if self.is_tail:
+            return self.decode_tail(hidden_states)
+        return self._payload(hidden_states, attention_mask, position_ids)
+
+    def decode_tail(self, hidden_states: Any) -> str:
+        if self._norm is not None:
+            hidden_states = self._norm(hidden_states)
+        if self._lm_head is None:
+            raise ModelBackendError("tail shard has no lm_head")
+        logits = self._lm_head(hidden_states)
+        token_id = int(self.torch.argmax(logits[:, -1, :], dim=-1)[0].item())
+        return self.tokenizer.decode([token_id], skip_special_tokens=True)
+
+    def generate_text(
+        self,
+        messages: list[dict],
+        max_new_tokens: int = 5120,
+        temperature: float = 1.0,
+        top_p: float = 1.0,
+    ) -> str:
+        """Autoregressive generation using HF generate() — single-node (head+tail) mode."""
+        if not self.is_head or not self.is_tail:
+            raise ModelBackendError("local generation requires a full head+tail shard")
+        encoded = self._encode_messages(messages)
+        input_ids = encoded["input_ids"].to(self.device)
+        attention_mask = encoded.get("attention_mask")
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(self.device)
+        pad_token_id = getattr(self.tokenizer, "pad_token_id", None) or getattr(self.tokenizer, "eos_token_id", None)
+        do_sample = temperature != 1.0 or top_p != 1.0
+        with self.torch.inference_mode():
+            generated = self.model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=max(1, int(max_new_tokens)),
+                do_sample=do_sample,
+                temperature=temperature if do_sample else None,
+                top_p=top_p if do_sample else None,
+                pad_token_id=pad_token_id,
+            )
+        new_tokens = generated[0, input_ids.shape[-1]:]
+        return self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+    def generate_text_streaming(
+        self,
+        messages: list[dict],
+        max_new_tokens: int = 5000,
+        temperature: float = 1.0,
+        top_p: float = 1.0,
+    ):
+        """Yield decoded token strings one at a time using HF TextIteratorStreamer."""
+        if not self.is_head or not self.is_tail:
+            raise ModelBackendError("streaming generation requires a full head+tail shard")
+        import threading
+        try:
+            from transformers import TextIteratorStreamer  # type: ignore[import]
+        except ImportError:
+            yield self.generate_text(messages, max_new_tokens, temperature, top_p)
+            return
+
+        encoded = self._encode_messages(messages)
+        input_ids = encoded["input_ids"].to(self.device)
+        attention_mask = encoded.get("attention_mask")
+        if attention_mask is not None:
+            attention_mask = attention_mask.to(self.device)
+        pad_token_id = getattr(self.tokenizer, "pad_token_id", None) or getattr(self.tokenizer, "eos_token_id", None)
+        do_sample = temperature != 1.0 or top_p != 1.0
+
+        streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+        gen_kwargs = dict(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            max_new_tokens=max(1, int(max_new_tokens)),
+            do_sample=do_sample,
+            temperature=temperature if do_sample else None,
+            top_p=top_p if do_sample else None,
+            pad_token_id=pad_token_id,
+            streamer=streamer,
+        )
+        t = threading.Thread(target=self.model.generate, kwargs=gen_kwargs, daemon=True)
+        t.start()
+        for token_text in streamer:
+            yield token_text
+        t.join()
+
+    def count_prompt_tokens(self, messages: list[dict]) -> int:
+        """Return tokenizer-backed prompt token count for OpenAI usage metadata."""
+        encoded = self._encode_messages(messages)
+        input_ids = encoded["input_ids"]
+        return int(input_ids.shape[-1])
+
+    def count_text_tokens(self, text: str) -> int:
+        """Return tokenizer-backed completion token count for OpenAI usage metadata."""
+        try:
+            encoded = self.tokenizer(
+                text,
+                return_tensors="pt",
+                add_special_tokens=False,
+            )
+        except TypeError:
+            encoded = self.tokenizer(text, return_tensors="pt")
+        return int(encoded["input_ids"].shape[-1])
+
+    def _encode_messages(self, messages: list[dict]) -> dict:
+        """Format messages with chat template (if available) and tokenize."""
+        if hasattr(self.tokenizer, "apply_chat_template"):
+            try:
+                prompt_str = self.tokenizer.apply_chat_template(
+                    messages,
+                    add_generation_prompt=True,
+                    tokenize=False,
+                )
+                return dict(self.tokenizer(prompt_str, return_tensors="pt"))
+            except Exception:
+                pass
+        prompt = " ".join(
+            str(m.get("content", ""))
+            for m in messages
+            if isinstance(m, dict) and m.get("role") == "user"
+        )
+        return dict(self.tokenizer(prompt, return_tensors="pt"))
+
+    def _run_layers(
+        self,
+        hidden_states: Any,
+        attention_mask: Any,
+        position_ids: Any,
+        start_layer: int | None = None,
+    ) -> Any:
+        # start_layer overrides shard_start for overlapping-shard routing
+        # (X-Meshnet-Start-Layer header). Clamped to shard_start to prevent
+        # indexing outside the loaded weights.
+        effective_start = (
+            max(self.shard_start, start_layer)
+            if start_layer is not None
+            else self.shard_start
+        )
+        position_embeddings = _rotary_position_embeddings(
+            self.model,
+            hidden_states,
+            position_ids,
+        )
+        layer_attention_mask = _decoder_attention_mask(
+            attention_mask,
+            hidden_states,
+            self.torch,
+        )
+        with self.torch.inference_mode():
+            for layer in self.layers[effective_start:self.shard_end + 1]:
+                hidden_states = _call_layer(
+                    layer,
+                    hidden_states,
+                    layer_attention_mask,
+                    position_ids,
+                    position_embeddings,
+                )
+            return hidden_states.to(self.torch.bfloat16)
+
+    def _payload(self, hidden_states: Any, attention_mask: Any, position_ids: Any) -> TensorPayload:
+        hidden_states = hidden_states.to(self.torch.bfloat16).contiguous()
+        return TensorPayload(
+            body=_tensor_to_bytes(hidden_states),
+            shape=list(hidden_states.shape),
+            attention_mask_header=_int_tensor_header(attention_mask)
+            if attention_mask is not None
+            else None,
+            position_ids_header=_int_tensor_header(position_ids)
+            if position_ids is not None
+            else None,
+        )
+
+
+def load_torch_shard(
+    model_id: str,
+    shard_start: int,
+    shard_end: int,
+    quantization: Quantization = "auto",
+    cache_dir: Path | None = None,
+) -> TorchModelShard:
+    return TorchModelShard(model_id, shard_start, shard_end, quantization, cache_dir)
+
+
+def _total_layers_for_local_snapshot(auto_config: Any, load_source: str) -> int | None:
+    snapshot_dir = Path(load_source)
+    if not (snapshot_dir / "config.json").exists():
+        return None
+    from .model_catalog import layers_from_config
+
+    try:
+        cfg = auto_config.from_pretrained(str(snapshot_dir))
+    except Exception:
+        return None
+    return layers_from_config(cfg)
+
+
+def _should_partial_materialize_shard(
+    load_source: str,
+    shard_start: int,
+    shard_end: int,
+    *,
+    total_layers_hint: int | None,
+    uses_quantized_weights: bool,
+) -> bool:
+    if uses_quantized_weights:
+        return False
+    snapshot_dir = Path(load_source)
+    if not snapshot_dir.exists() or not (snapshot_dir / "config.json").exists():
+        return False
+    if not (snapshot_dir / "model.safetensors.index.json").exists():
+        return False
+    if total_layers_hint is None:
+        return False
+    return True
+
+
+def _load_partial_model_from_snapshot(
+    auto_config: Any,
+    auto_model_for_causal_lm: Any,
+    torch: Any,
+    load_source: str,
+    shard_start: int,
+    shard_end: int,
+    dtype: Any,
+    device: Any,
+    *,
+    init_empty_weights_fn: Any | None = None,
+    set_tensor_fn: Any | None = None,
+    safe_open_fn: Any | None = None,
+) -> Any:
+    from .model_catalog import layers_from_config
+    from .safetensors_selection import (
+        INDEX_FILENAME,
+        select_tensor_names_for_layers_from_index,
+    )
+
+    if init_empty_weights_fn is None:
+        from accelerate import init_empty_weights as init_empty_weights_fn
+    if set_tensor_fn is None:
+        from accelerate.utils import set_module_tensor_to_device as set_tensor_fn
+    if safe_open_fn is None:
+        from safetensors import safe_open as safe_open_fn
+
+    snapshot_dir = Path(load_source)
+    cfg = auto_config.from_pretrained(str(snapshot_dir))
+    total_layers = layers_from_config(cfg)
+    if total_layers is None:
+        raise PartialModelLoadUnsupported(
+            f"could not determine num_hidden_layers for local snapshot {snapshot_dir}"
+        )
+    if shard_end >= total_layers:
+        raise ValueError(
+            f"shard_end {shard_end} exceeds last layer index {total_layers - 1}"
+        )
+
+    index_path = snapshot_dir / INDEX_FILENAME
+    try:
+        index = json.loads(index_path.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise PartialModelLoadUnsupported(
+            f"missing SafeTensors index for partial load: {index_path}"
+        ) from exc
+    weight_map = index.get("weight_map")
+    if not isinstance(weight_map, dict):
+        raise PartialModelLoadUnsupported(f"{INDEX_FILENAME} must contain a weight_map object")
+
+    tensor_names = select_tensor_names_for_layers_from_index(
+        weight_map,
+        shard_start,
+        shard_end,
+        total_layers=total_layers,
+    )
+    if not tensor_names:
+        raise PartialModelLoadUnsupported(
+            f"no checkpoint tensors matched layers {shard_start}-{shard_end} in {snapshot_dir}"
+        )
+
+    with init_empty_weights_fn():
+        model = auto_model_for_causal_lm.from_config(_causal_lm_config(cfg), torch_dtype=dtype)
+    tie_weights = getattr(model, "tie_weights", None)
+    if callable(tie_weights):
+        tie_weights()
+
+    # Multimodal/MTP checkpoints (e.g. Qwen3.5/3.6-MoE) carry vision and
+    # multi-token-prediction tensors the text-only CausalLM never builds;
+    # transformers' from_pretrained drops them via _keys_to_ignore_on_load_unexpected,
+    # so the manual loader must skip them too.
+    expected_keys = _model_state_dict_keys(model)
+    tensors_by_file: dict[str, list[str]] = {}
+    skipped: list[str] = []
+    for tensor_name in sorted(tensor_names):
+        rel_file = weight_map.get(tensor_name)
+        if not isinstance(rel_file, str):
+            continue
+        if (
+            expected_keys is not None
+            and _checkpoint_tensor_name_for_model(model, tensor_name) not in expected_keys
+        ):
+            skipped.append(tensor_name)
+            continue
+        tensors_by_file.setdefault(rel_file, []).append(tensor_name)
+    if skipped:
+        preview = ", ".join(skipped[:3])
+        print(
+            f"  Skipping {len(skipped)} checkpoint tensors absent from the causal LM "
+            f"(e.g. {preview})",
+            flush=True,
+        )
+    if not tensors_by_file:
+        raise PartialModelLoadUnsupported(
+            f"no checkpoint tensors for layers {shard_start}-{shard_end} match the "
+            f"causal LM built from {snapshot_dir}"
+        )
+
+    for rel_file, names in tensors_by_file.items():
+        checkpoint_file = snapshot_dir / rel_file
+        if not checkpoint_file.exists():
+            raise PartialModelLoadUnsupported(
+                f"checkpoint file advertised in {INDEX_FILENAME} is missing: {checkpoint_file}"
+            )
+        with safe_open_fn(str(checkpoint_file), framework="pt", device="cpu") as handle:
+            for tensor_name in names:
+                set_tensor_fn(
+                    model,
+                    _checkpoint_tensor_name_for_model(model, tensor_name),
+                    device,
+                    value=handle.get_tensor(tensor_name),
+                    dtype=dtype,
+                )
+
+    for module in _active_modules_for_shard(model, shard_start, shard_end):
+        if hasattr(module, "to"):
+            module.to(device)
+    return model
+
+
+def _model_load_plan(
+    auto_config: Any,
+    model_id: str,
+    quantization: Quantization,
+    torch: Any,
+    cache_dir: Path | None = None,
+) -> tuple[Any | None, Any, bool]:
+    """Return (explicit quant config, dtype, uses quantized weights)."""
+    if quantization != "auto":
+        quant_config = build_quantization_config(quantization)
+        return quant_config, torch.bfloat16, quant_config is not None
+
+    cfg = auto_config.from_pretrained(
+        model_id,
+        cache_dir=str(cache_dir) if cache_dir is not None else None,
+    )
+    if _native_quantization_config(cfg) is not None:
+        return None, _native_torch_dtype(cfg, torch), True
+    return None, _native_torch_dtype(cfg, torch), False
+
+
+def _config_candidates(cfg: Any) -> list[Any]:
+    candidates = [cfg]
+    get_text_config = getattr(cfg, "get_text_config", None)
+    if callable(get_text_config):
+        try:
+            candidates.append(get_text_config())
+        except Exception:
+            pass
+    text_config = getattr(cfg, "text_config", None)
+    if text_config is not None:
+        candidates.append(text_config)
+    return candidates
+
+
+def _native_quantization_config(cfg: Any) -> Any | None:
+    for candidate in _config_candidates(cfg):
+        quant_config = getattr(candidate, "quantization_config", None)
+        if quant_config:
+            return quant_config
+    return None
+
+
+def _native_torch_dtype(cfg: Any, torch: Any) -> Any:
+    for candidate in _config_candidates(cfg):
+        for attr in ("dtype", "torch_dtype"):
+            dtype = getattr(candidate, attr, None)
+            if dtype is None:
+                continue
+            if isinstance(dtype, str):
+                dtype_name = dtype.removeprefix("torch.")
+                dtype_value = getattr(torch, dtype_name, None)
+                if dtype_value is not None:
+                    return dtype_value
+            else:
+                return dtype
+    return torch.bfloat16
+
+
+def _causal_lm_config(cfg: Any) -> Any:
+    """Use the text decoder config for composite VLM/MoE presets."""
+    get_text_config = getattr(cfg, "get_text_config", None)
+    if callable(get_text_config):
+        try:
+            return get_text_config()
+        except Exception:
+            pass
+    text_config = getattr(cfg, "text_config", None)
+    if text_config is not None:
+        return text_config
+    return cfg
+
+
+def _model_state_dict_keys(model: Any) -> set[str] | None:
+    """Expected parameter/buffer names, or None when the model can't report them."""
+    state_dict = getattr(model, "state_dict", None)
+    if not callable(state_dict):
+        return None
+    try:
+        return set(state_dict().keys())
+    except Exception:
+        return None
+
+
+def _checkpoint_tensor_name_for_model(model: Any, tensor_name: str) -> str:
+    """Map multimodal checkpoint keys onto text-only CausalLM modules when needed."""
+    inner = getattr(model, "model", None)
+    if inner is not None and hasattr(inner, "language_model"):
+        return tensor_name
+    if ".language_model." in tensor_name:
+        return tensor_name.replace(".language_model.", ".")
+    return tensor_name
+
+
+def _transformer_backbone(model: Any) -> Any:
+    if hasattr(model, "model"):
+        inner = model.model
+        language_model = getattr(inner, "language_model", None)
+        if language_model is not None:
+            return language_model
+        return inner
+    if hasattr(model, "transformer"):
+        return model.transformer
+    raise ModelBackendError(
+        "unsupported HuggingFace model architecture: no transformer backbone found"
+    )
+
+
+def _model_layers(model: Any) -> Any:
+    backbone = _transformer_backbone(model)
+    for attr in ("layers", "h", "blocks"):
+        layers = getattr(backbone, attr, None)
+        if layers is not None:
+            return layers
+    raise ModelBackendError(
+        "unsupported HuggingFace model architecture: no transformer layers found"
+    )
+
+
+def _embed_tokens(model: Any) -> Any:
+    backbone = _transformer_backbone(model)
+    for attr in ("embed_tokens", "wte"):
+        embed = getattr(backbone, attr, None)
+        if embed is not None:
+            return embed
+    raise ModelBackendError(
+        "unsupported HuggingFace model architecture: no token embeddings found"
+    )
+
+
+def _position_embeddings(model: Any) -> Any | None:
+    backbone = _transformer_backbone(model)
+    return getattr(backbone, "wpe", None)
+
+
+def _rotary_embedding_module(model: Any) -> Any | None:
+    backbone = _transformer_backbone(model)
+    return getattr(backbone, "rotary_emb", None)
+
+
+def _active_modules_for_shard(model: Any, shard_start: int, shard_end: int) -> list[Any]:
+    active: list[Any] = []
+
+    def add(module: Any | None) -> None:
+        if module is None:
+            return
+        if any(existing is module for existing in active):
+            return
+        active.append(module)
+
+    if shard_start == 0:
+        add(_embed_tokens(model))
+        add(_position_embeddings(model))
+    add(_rotary_embedding_module(model))
+    for layer in _model_layers(model)[shard_start:shard_end + 1]:
+        add(layer)
+    total_layers = len(_model_layers(model))
+    if shard_end >= total_layers - 1:
+        add(_final_norm(model))
+        add(getattr(model, "lm_head", None))
+    return active
+
+
+def _final_norm(model: Any) -> Any | None:
+    backbone = _transformer_backbone(model)
+    for attr in ("norm", "ln_f", "final_layer_norm"):
+        norm = getattr(backbone, attr, None)
+        if norm is not None:
+            return norm
+    return None
+
+
+def _position_ids(attention_mask: Any, torch: Any) -> Any:
+    position_ids = attention_mask.long().cumsum(-1) - 1
+    return position_ids.masked_fill(attention_mask == 0, 0).to(torch.long)
+
+
+def _decoder_attention_mask(attention_mask: Any, hidden_states: Any, torch: Any) -> Any:
+    """Build a causal additive mask for decoder layers called outside model.forward."""
+    if attention_mask is None:
+        return None
+    if len(getattr(attention_mask, "shape", ())) != 2:
+        return attention_mask
+    batch_size, seq_len = attention_mask.shape
+    if seq_len <= 1:
+        return None if bool(attention_mask.all()) else attention_mask.to(hidden_states.dtype)
+
+    min_value = torch.finfo(hidden_states.dtype).min
+    causal = torch.full(
+        (seq_len, seq_len),
+        min_value,
+        dtype=hidden_states.dtype,
+        device=hidden_states.device,
+    )
+    causal = torch.triu(causal, diagonal=1)
+    causal = causal[None, None, :, :].expand(batch_size, 1, seq_len, seq_len).clone()
+
+    padding = attention_mask.to(device=hidden_states.device)
+    if not bool(padding.all()):
+        causal = causal.masked_fill(padding[:, None, None, :] == 0, min_value)
+    return causal
+
+
+def _rotary_position_embeddings(model: Any, hidden_states: Any, position_ids: Any) -> Any | None:
+    """Return model-level rotary embeddings required by newer HF decoder layers."""
+    if position_ids is None:
+        return None
+    rotary = _rotary_embedding_module(model)
+    if rotary is None:
+        return None
+    return rotary(hidden_states, position_ids)
+
+
+def _call_layer(
+    layer: Any,
+    hidden_states: Any,
+    attention_mask: Any,
+    position_ids: Any,
+    position_embeddings: Any | None = None,
+) -> Any:
+    attempts = (
+        {
+            "attention_mask": attention_mask,
+            "position_ids": position_ids,
+            "position_embeddings": position_embeddings,
+            "use_cache": False,
+        },
+        {
+            "attention_mask": attention_mask,
+            "position_ids": position_ids,
+            "use_cache": False,
+        },
+        {"attention_mask": attention_mask, "use_cache": False},
+        {"use_cache": False},
+        {},
+    )
+    last_exc: Exception | None = None
+    for kwargs in attempts:
+        filtered = {key: value for key, value in kwargs.items() if value is not None}
+        try:
+            output = layer(hidden_states, **filtered)
+            return output[0] if isinstance(output, tuple) else output
+        except TypeError as exc:
+            last_exc = exc
+    if last_exc is not None:
+        raise last_exc
+    return layer(hidden_states)[0]
+
+
+def _tensor_to_bytes(tensor: Any) -> bytes:
+    import torch
+
+    return tensor.detach().cpu().contiguous().view(torch.uint8).numpy().tobytes()
+
+
+def _tensor_from_bfloat16_bytes(body: bytes, shape: list[int], torch: Any) -> Any:
+    tensor = torch.frombuffer(bytearray(body), dtype=torch.bfloat16)
+    return tensor.reshape(shape)
+
+
+def _int_tensor_header(tensor: Any) -> str:
+    data = tensor.detach().cpu().long().contiguous()
+    raw = data.numpy().tobytes()
+    shape = ",".join(str(dim) for dim in data.shape)
+    encoded = base64.b64encode(raw).decode("ascii")
+    return f"{shape}:{encoded}"
+
+
+def _tensor_from_int64_header(value: str | None, torch: Any, device: Any) -> Any | None:
+    if not value:
+        return None
+    shape_text, encoded = value.split(":", 1)
+    shape = [int(part) for part in shape_text.split(",") if part]
+    raw = base64.b64decode(encoded.encode("ascii"))
+    return torch.frombuffer(bytearray(raw), dtype=torch.int64).reshape(shape).to(device)
+
+
+def _looks_like_oom(exc: BaseException) -> bool:
+    current: BaseException | None = exc
+    while current is not None:
+        text = str(current).lower()
+        if (
+            "out of memory" in text
+            or "cuda error: out of memory" in text
+            or "paging file is too small" in text
+            or "os error 1455" in text
+        ):
+            return True
+        current = current.__cause__ or current.__context__
+    return False
diff --git a/packages/tracker/meshnet_tracker/dashboard.html b/packages/tracker/meshnet_tracker/dashboard.html
index ffda954..faa07fb 100644
--- a/packages/tracker/meshnet_tracker/dashboard.html
+++ b/packages/tracker/meshnet_tracker/dashboard.html
@@ -5,8 +5,9 @@
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>meshnet tracker</title>
 <style>
-  :root { --bg:#0d1117; --panel:#161b22; --border:#30363d; --fg:#c9d1d9;
-          --dim:#8b949e; --accent:#58a6ff; --ok:#3fb950; --bad:#f85149; --warn:#d29922; }
+  :root { --bg:#0d1117; --panel:#161b22; --border:#30363d; --fg:#e6edf3;
+          --dim:#8b949e; --accent:#58a6ff; --ok:#3fb950; --bad:#f85149; --warn:#d29922;
+          --chat-input-bg:#21262d; --chat-user-bg:#1f4788; --chat-user-border:#388bfd; }
   * { box-sizing:border-box; }
   html, body { height:100%; }
   body { margin:0; background:var(--bg); color:var(--fg);
@@ -114,7 +115,7 @@
   .chat-session-item:hover .chat-session-delete,
   .chat-session-item.active .chat-session-delete { opacity:1; }
   .chat-session-delete:hover { color:var(--bad); background:#1a1012; }
-  .chat-main { display:flex; flex-direction:column; min-height:0; min-width:0; }
+  .chat-main { display:flex; flex-direction:column; min-height:0; min-width:0; color-scheme:dark; }
   .chat-toolbar {
     display:flex; gap:12px; align-items:center; flex-shrink:0;
     padding:10px 16px; border-bottom:1px solid var(--border); background:var(--panel);
@@ -122,10 +123,15 @@
   .chat-toolbar label {
     display:flex; align-items:center; gap:8px; color:var(--dim); margin:0;
   }
-  .chat-toolbar select { min-width:220px; max-width:min(420px, 50vw); }
+  .chat-toolbar select {
+    min-width:220px; max-width:min(420px, 50vw);
+    color:var(--fg); background:var(--chat-input-bg); border:1px solid var(--border);
+    border-radius:6px; padding:6px 8px;
+  }
   .chat-status { color:var(--dim); font-size:12px; margin-left:auto; }
   .chat-messages {
     flex:1; overflow:auto; padding:24px 16px; min-height:0;
+    background:var(--bg); color:var(--fg);
   }
   .chat-messages-inner {
     max-width:768px; margin:0 auto; display:flex; flex-direction:column; gap:20px;
@@ -139,13 +145,15 @@
   .chat-row.assistant, .chat-row.error { justify-content:flex-start; }
   .chat-bubble {
     max-width:85%; padding:12px 14px; border-radius:16px; line-height:1.55;
-    white-space:pre-wrap; word-break:break-word; font-size:13px;
+    white-space:pre-wrap; word-break:break-word; font-size:14px; color:var(--fg);
   }
   .chat-bubble.user {
-    background:#1f3a5f; border:1px solid #264a73; border-bottom-right-radius:4px;
+    background:var(--chat-user-bg); border:1px solid var(--chat-user-border);
+    border-bottom-right-radius:4px; color:#f0f6fc;
   }
   .chat-bubble.assistant {
-    background:transparent; border:0; padding-left:0; padding-right:0; max-width:100%;
+    background:var(--panel); border:1px solid var(--border);
+    border-bottom-left-radius:4px; max-width:100%; color:var(--fg);
   }
   .chat-bubble.error {
     background:#1a1012; border:1px solid #5c2020; color:#ffb4b4; border-bottom-left-radius:4px;
@@ -157,16 +165,25 @@
   .chat-compose {
     display:flex; gap:8px; align-items:flex-end; max-width:768px; margin:0 auto;
     padding:10px 12px; border:1px solid var(--border); border-radius:16px;
-    background:var(--bg);
+    background:var(--chat-input-bg);
+  }
+  .chat-compose:focus-within {
+    border-color:var(--accent);
+    box-shadow:0 0 0 1px var(--accent);
   }
-  .chat-compose:focus-within { border-color:var(--accent); }
   .chat-compose textarea {
     flex:1; min-height:24px; max-height:200px; resize:none; width:auto;
-    border:0; background:transparent; padding:2px 0; outline:none;
+    border:0; background:transparent; padding:4px 0; outline:none;
+    color:var(--fg); caret-color:var(--accent); font:inherit; font-size:14px; line-height:1.5;
   }
+  .chat-compose textarea::placeholder { color:var(--dim); opacity:1; }
   .chat-compose button {
     flex-shrink:0; min-width:36px; height:36px; padding:0;
-    border-radius:8px; border:1px solid var(--border);
+    border-radius:8px; border:1px solid var(--chat-user-border);
+    background:var(--chat-user-bg); color:#f0f6fc;
+  }
+  .chat-compose button:hover:not(:disabled) {
+    border-color:var(--accent); background:#2563b8;
   }
   .chat-compose button:disabled { opacity:.45; cursor:not-allowed; }
   .console {
diff --git a/tests/test_real_model_backend.py b/tests/test_real_model_backend.py
index de8e5e5..b1aaf4c 100644
--- a/tests/test_real_model_backend.py
+++ b/tests/test_real_model_backend.py
@@ -1,875 +1,965 @@
-"""US-012 tests for the real PyTorch node backend."""
-
-import json
-import os
-from pathlib import Path
-import sys
-import threading
-import time
-import types
-import urllib.request
-
-import pytest
-
-from meshnet_node.model_backend import (
-    InsufficientVRAMError,
-    PartialModelLoadUnsupported,
-    TensorPayload,
-    TorchModelShard,
-    _call_layer,
-    _checkpoint_tensor_name_for_model,
-    _load_partial_model_from_snapshot,
-    _should_partial_materialize_shard,
-    _decoder_attention_mask,
-    _int_tensor_header,
-    build_quantization_config,
-    validate_quantization,
-)
-from meshnet_node.torch_server import TorchNodeServer
-
-
-class _FakeBackend:
-    model_id = "fake-model"
-    total_layers = 12
-    is_head = True
-    is_tail = False
-
-    def encode_prompt(self, prompt: str) -> TensorPayload:
-        assert prompt == "The capital of France is"
-        return TensorPayload(
-            body=b"\x00" * (1 * 6 * 8 * 2),
-            shape=[1, 6, 8],
-            attention_mask_header=None,
-            position_ids_header=None,
-        )
-
-    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
-        assert shape == [1, 6, 8]
-        return TensorPayload(
-            body=body,
-            shape=shape,
-            attention_mask_header=attention_mask_header,
-            position_ids_header=position_ids_header,
-        )
-
-
-class _FakeTailBackend(_FakeBackend):
-    is_head = False
-    is_tail = True
-
-    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
-        assert len(body) == 1 * 6 * 8 * 2
-        return " Paris"
-
-
-class _FakeFullBackend(_FakeBackend):
-    is_head = True
-    is_tail = True
-
-    def generate_text(
-        self,
-        messages: list[dict],
-        max_new_tokens: int = 16,
-        temperature: float = 1.0,
-        top_p: float = 1.0,
-    ) -> str:
-        assert messages == [{"role": "user", "content": "What is 7 times 8?"}]
-        assert max_new_tokens == 7
-        assert temperature == 1.0
-        assert top_p == 1.0
-        return "56"
-
-    def count_prompt_tokens(self, messages: list[dict]) -> int:
-        assert messages == [{"role": "user", "content": "What is 7 times 8?"}]
-        return 8
-
-    def count_text_tokens(self, text: str) -> int:
-        assert text == "56"
-        return 1
-
-
-class _FakeChatTokenizer:
-    eos_token = ""
-
-    def apply_chat_template(self, messages, add_generation_prompt=True, tokenize=False):
-        assert add_generation_prompt is True
-        assert tokenize is False
-        return "debug prompt"
-
-
-class _FakePipelineHeadBackend(_FakeBackend):
-    tokenizer = _FakeChatTokenizer()
-
-    def encode_prompt(self, prompt: str) -> TensorPayload:
-        assert prompt.startswith("debug prompt")
-        return TensorPayload(
-            body=b"\x00" * (1 * 6 * 8 * 2),
-            shape=[1, 6, 8],
-            attention_mask_header=None,
-            position_ids_header=None,
-        )
-
-
-class _FakePipelineTailBackend(_FakeTailBackend):
-    def __init__(self) -> None:
-        self.start_layers: list[int | None] = []
-
-    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
-        self.start_layers.append(start_layer)
-        assert len(body) == 1 * 6 * 8 * 2
-        return " token"
-
-
-class _BlockingStreamingTailBackend(_FakeTailBackend):
-    def __init__(self, second_token_release: threading.Event) -> None:
-        self._release = second_token_release
-        self.calls = 0
-
-    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
-        self.calls += 1
-        if self.calls == 1:
-            return " first"
-        self._release.wait(timeout=3.0)
-        return " second"
-
-
-def test_quantization_flag_validation():
-    assert validate_quantization("bfloat16") == "bfloat16"
-    assert validate_quantization("int8") == "int8"
-    assert validate_quantization("nf4") == "nf4"
-    with pytest.raises(ValueError, match="quantization"):
-        validate_quantization("float32")
-
-
-def test_node_package_declares_torch_dependency():
-    pyproject = Path("packages/node/pyproject.toml").read_text(encoding="utf-8")
-
-    assert '"torch>=' in pyproject
-
-
-def test_bitsandbytes_configs_are_created_lazily(monkeypatch):
-    calls = []
-
-    class FakeBitsAndBytesConfig:
-        def __init__(self, **kwargs):
-            calls.append(kwargs)
-
-    monkeypatch.setitem(sys.modules, "torch", types.SimpleNamespace(bfloat16="bf16"))
-    monkeypatch.setitem(
-        sys.modules,
-        "transformers",
-        types.SimpleNamespace(BitsAndBytesConfig=FakeBitsAndBytesConfig),
-    )
-
-    assert build_quantization_config("bfloat16") is None
-    build_quantization_config("int8")
-    build_quantization_config("nf4")
-
-    assert calls == [
-        {"load_in_8bit": True},
-        {
-            "load_in_4bit": True,
-            "bnb_4bit_quant_type": "nf4",
-            "bnb_4bit_compute_dtype": "bf16",
-        },
-    ]
-
-
-def test_head_forward_accepts_text_prompt_and_returns_bfloat16_activations():
-    node = TorchNodeServer(backend=_FakeBackend())
-    port = node.start()
-    try:
-        payload = json.dumps({"prompt": "The capital of France is"}).encode()
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{port}/forward",
-            data=payload,
-            headers={"Content-Type": "application/json"},
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            body = resp.read()
-            headers = {key.lower(): value for key, value in resp.headers.items()}
-
-        assert len(body) == 1 * 6 * 8 * 2
-        assert headers["x-meshnet-shape"] == "1,6,8"
-        assert headers["x-meshnet-dtype"] == "bfloat16"
-        assert headers["x-meshnet-wire"] == "2"
-    finally:
-        node.stop()
-
-
-def test_tail_forward_returns_text_completion_from_binary_activations():
-    node = TorchNodeServer(backend=_FakeTailBackend())
-    port = node.start()
-    try:
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{port}/forward",
-            data=b"\x00" * (1 * 6 * 8 * 2),
-            headers={
-                "Content-Type": "application/octet-stream",
-                "X-Meshnet-Shape": "1,6,8",
-                "X-Meshnet-Dtype": "bfloat16",
-                "X-Meshnet-Session": "session-1",
-                "X-Meshnet-Chunk-Index": "0",
-                "X-Meshnet-Chunk-Total": "1",
-                "X-Meshnet-Hop-Index": "1",
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            body = json.loads(resp.read())
-
-        assert body == {"text": " Paris"}
-        assert node.received_activations
-        assert node.forward_chunk_count == 1
-    finally:
-        node.stop()
-
-
-def test_full_model_chat_completion_uses_generation_not_single_token_decode(capsys):
-    node = TorchNodeServer(backend=_FakeFullBackend())
-    port = node.start()
-    try:
-        payload = json.dumps({
-            "model": "fake-model",
-            "messages": [{"role": "user", "content": "What is 7 times 8?"}],
-            "max_tokens": 7,
-        }).encode()
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{port}/v1/chat/completions",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "X-Meshnet-Request-Id": "req-test-123",
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            body = json.loads(resp.read())
-
-        assert body["choices"][0]["message"]["content"] == "56"
-        assert body["usage"] == {"prompt_tokens": 8, "completion_tokens": 1, "total_tokens": 9}
-    finally:
-        node.stop()
-
-    out = capsys.readouterr().out
-    assert "  [node] processing chat model='fake-model' stream=False max_tokens=7 request_id=req-test-123" in out
-    assert "  [node] chat complete tokens=1 elapsed_s=" in out
-
-
-def test_pipeline_hop_logs_are_suppressed_without_debug(capsys):
-    tail_backend = _FakePipelineTailBackend()
-    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True)
-    tail = TorchNodeServer(backend=tail_backend)
-    head_port = head.start()
-    tail_port = tail.start()
-    try:
-        payload = json.dumps({
-            "model": "fake-model",
-            "messages": [{"role": "user", "content": "hello"}],
-            "max_tokens": 1,
-        }).encode()
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{head_port}/v1/chat/completions",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "X-Meshnet-Route": json.dumps([
-                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
-                ]),
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            body = json.loads(resp.read())
-    finally:
-        head.stop()
-        tail.stop()
-
-    out = capsys.readouterr().out
-    assert body["choices"][0]["message"]["content"] == " token"
-    assert tail_backend.start_layers == [22]
-    assert "pipeline hop 0:" not in out
-    assert "pipeline hop 0 returned text" not in out
-
-
-def test_pipeline_hop_logs_are_enabled_with_debug(capsys):
-    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True, debug=True)
-    tail = TorchNodeServer(backend=_FakePipelineTailBackend())
-    head_port = head.start()
-    tail_port = tail.start()
-    try:
-        payload = json.dumps({
-            "model": "fake-model",
-            "messages": [{"role": "user", "content": "hello"}],
-            "max_tokens": 1,
-        }).encode()
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{head_port}/v1/chat/completions",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "X-Meshnet-Route": json.dumps([
-                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
-                ]),
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(req, timeout=5) as resp:
-            json.loads(resp.read())
-    finally:
-        head.stop()
-        tail.stop()
-
-    out = capsys.readouterr().out
-    assert f"  [node] pipeline hop 0: http://127.0.0.1:{tail_port} start_layer=22" in out
-    assert "  [node] pipeline hop 0 returned text=' token'" in out
-
-
-def test_split_shard_chat_streams_each_generated_token_incrementally():
-    release_second = threading.Event()
-    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True)
-    tail = TorchNodeServer(backend=_BlockingStreamingTailBackend(release_second))
-    head_port = head.start()
-    tail_port = tail.start()
-    response = None
-    try:
-        payload = json.dumps({
-            "model": "fake-model",
-            "messages": [{"role": "user", "content": "hello"}],
-            "stream": True,
-            "max_tokens": 2,
-        }).encode()
-        req = urllib.request.Request(
-            f"http://127.0.0.1:{head_port}/v1/chat/completions",
-            data=payload,
-            headers={
-                "Content-Type": "application/json",
-                "X-Meshnet-Route": json.dumps([
-                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
-                ]),
-            },
-            method="POST",
-        )
-        response = urllib.request.urlopen(req, timeout=5)
-
-        first_token_line = ""
-        deadline = time.time() + 2.0
-        while time.time() < deadline:
-            line = response.readline().decode()
-            if '"content": " first"' in line:
-                first_token_line = line
-                break
-
-        assert first_token_line
-        assert not release_second.is_set()
-        release_second.set()
-        rest = response.read().decode()
-    finally:
-        release_second.set()
-        if response is not None:
-            response.close()
-        head.stop()
-        tail.stop()
-
-    assert '"content": " second"' in rest
-    assert "data: [DONE]" in rest
-
-
-def test_int_tensor_header_serializes_torch_tensors():
-    torch = pytest.importorskip("torch")
-
-    header = _int_tensor_header(torch.tensor([[1, 2, 3]], dtype=torch.long))
-
-    assert header.startswith("1,3:")
-
-
-def test_decoder_attention_mask_is_causal_float_mask():
-    torch = pytest.importorskip("torch")
-
-    hidden_states = torch.zeros((1, 3, 8), dtype=torch.bfloat16)
-    mask = _decoder_attention_mask(torch.ones((1, 3), dtype=torch.long), hidden_states, torch)
-
-    assert mask.shape == (1, 1, 3, 3)
-    assert mask.dtype == torch.bfloat16
-    assert mask[0, 0, 0, 1] < 0
-    assert mask[0, 0, 2, 0] == 0
-
-
-def test_call_layer_passes_rotary_position_embeddings():
-    class NeedsPositionEmbeddings:
-        def __call__(self, hidden_states, **kwargs):
-            assert kwargs["position_embeddings"] == "rotary"
-            return hidden_states
-
-    assert _call_layer(
-        NeedsPositionEmbeddings(),
-        "hidden",
-        attention_mask=None,
-        position_ids="positions",
-        position_embeddings="rotary",
-    ) == "hidden"
-
-
-def test_partial_materialize_guard_requires_local_non_full_non_quantized_snapshot(tmp_path):
-    snapshot_dir = tmp_path / "snapshot"
-    snapshot_dir.mkdir()
-    (snapshot_dir / "config.json").write_text("{}")
-    (snapshot_dir / "model.safetensors.index.json").write_text('{"weight_map": {}}')
-
-    assert _should_partial_materialize_shard(
-        str(snapshot_dir),
-        4,
-        7,
-        total_layers_hint=40,
-        uses_quantized_weights=False,
-    ) is True
-    assert _should_partial_materialize_shard(
-        str(snapshot_dir),
-        0,
-        39,
-        total_layers_hint=40,
-        uses_quantized_weights=False,
-    ) is True
-    assert _should_partial_materialize_shard(
-        str(snapshot_dir),
-        4,
-        7,
-        total_layers_hint=40,
-        uses_quantized_weights=True,
-    ) is False
-    assert _should_partial_materialize_shard(
-        "repo/model",
-        4,
-        7,
-        total_layers_hint=40,
-        uses_quantized_weights=False,
-    ) is False
-
-
-def test_checkpoint_tensor_name_remapped_for_text_only_causal_lm():
-    class TextOnlyModel:
-        def __init__(self):
-            self.model = types.SimpleNamespace(layers=[])
-
-    model = TextOnlyModel()
-    assert _checkpoint_tensor_name_for_model(
-        model,
-        "model.language_model.layers.0.mlp.gate.weight",
-    ) == "model.layers.0.mlp.gate.weight"
-    assert _checkpoint_tensor_name_for_model(
-        model,
-        "model.language_model.embed_tokens.weight",
-    ) == "model.embed_tokens.weight"
-
-
-def test_checkpoint_tensor_name_kept_for_multimodal_backbone():
-    class MultimodalModel:
-        def __init__(self):
-            self.model = types.SimpleNamespace(language_model=types.SimpleNamespace())
-
-    model = MultimodalModel()
-    name = "model.language_model.layers.0.mlp.gate.weight"
-    assert _checkpoint_tensor_name_for_model(model, name) == name
-
-
-def test_partial_snapshot_loader_remaps_language_model_checkpoint_keys(tmp_path):
-    snapshot_dir = tmp_path / "snapshot"
-    snapshot_dir.mkdir()
-    (snapshot_dir / "config.json").write_text(json.dumps({
-        "text_config": {"num_hidden_layers": 3},
-    }))
-    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
-        "weight_map": {
-            "model.language_model.layers.1.self_attn.q_proj.weight": "shard-2.safetensors",
-        }
-    }))
-    (snapshot_dir / "shard-2.safetensors").write_bytes(b"stub")
-
-    class FakeModule:
-        def __init__(self):
-            self.to_calls = []
-
-        def to(self, device):
-            self.to_calls.append(device)
-            return self
-
-    class FakeModel:
-        def __init__(self):
-            self.model = types.SimpleNamespace(
-                layers=[FakeModule(), FakeModule(), FakeModule()],
-                rotary_emb=FakeModule(),
-            )
-
-        def tie_weights(self):
-            pass
-
-    class AutoConfigStub:
-        @staticmethod
-        def from_pretrained(model_id):
-            return types.SimpleNamespace(
-                text_config=types.SimpleNamespace(num_hidden_layers=3),
-                get_text_config=lambda: types.SimpleNamespace(num_hidden_layers=3),
-            )
-
-    class AutoModelStub:
-        @staticmethod
-        def from_config(cfg, torch_dtype=None):
-            return FakeModel()
-
-    set_calls = []
-
-    def fake_set_tensor(module, tensor_name, device, value=None, dtype=None):
-        set_calls.append(tensor_name)
-
-    class FakeSafeOpen:
-        def __init__(self, filename, framework, device):
-            self.filename = Path(filename).name
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, tb):
-            return False
-
-        def get_tensor(self, tensor_name):
-            return tensor_name
-
-    class UnusedContext:
-        def __enter__(self):
-            return None
-
-        def __exit__(self, exc_type, exc, tb):
-            return False
-
-    _load_partial_model_from_snapshot(
-        AutoConfigStub,
-        AutoModelStub,
-        types.SimpleNamespace(),
-        str(snapshot_dir),
-        1,
-        1,
-        "bf16",
-        "cpu:0",
-        init_empty_weights_fn=UnusedContext,
-        set_tensor_fn=fake_set_tensor,
-        safe_open_fn=FakeSafeOpen,
-    )
-
-    assert set_calls == ["model.layers.1.self_attn.q_proj.weight"]
-
-
-def test_partial_snapshot_loader_materializes_only_assigned_tensors(tmp_path):
-    snapshot_dir = tmp_path / "snapshot"
-    snapshot_dir.mkdir()
-    (snapshot_dir / "config.json").write_text("{}")
-    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
-        "weight_map": {
-            "model.embed_tokens.weight": "shard-1.safetensors",
-            "model.layers.0.self_attn.q_proj.weight": "shard-1.safetensors",
-            "model.layers.1.self_attn.q_proj.weight": "shard-2.safetensors",
-            "model.layers.2.self_attn.q_proj.weight": "shard-3.safetensors",
-            "model.norm.weight": "shard-3.safetensors",
-            "lm_head.weight": "shard-3.safetensors",
-        }
-    }))
-    for rel in ("shard-1.safetensors", "shard-2.safetensors", "shard-3.safetensors"):
-        (snapshot_dir / rel).write_bytes(b"stub")
-
-    class FakeModule:
-        def __init__(self, name):
-            self.name = name
-            self.to_calls = []
-
-        def to(self, device):
-            self.to_calls.append(device)
-            return self
-
-    class FakeModel:
-        def __init__(self):
-            self.model = types.SimpleNamespace(
-                embed_tokens=FakeModule("embed"),
-                layers=[FakeModule("layer0"), FakeModule("layer1"), FakeModule("layer2")],
-                rotary_emb=FakeModule("rotary"),
-                norm=FakeModule("norm"),
-            )
-            self.lm_head = FakeModule("lm_head")
-            self.tie_weights_called = 0
-
-        def tie_weights(self):
-            self.tie_weights_called += 1
-
-    class AutoConfigStub:
-        @staticmethod
-        def from_pretrained(model_id):
-            assert model_id == str(snapshot_dir)
-            return types.SimpleNamespace(num_hidden_layers=3)
-
-    class AutoModelStub:
-        @staticmethod
-        def from_config(cfg, torch_dtype=None):
-            assert cfg.num_hidden_layers == 3
-            assert torch_dtype == "bf16"
-            return FakeModel()
-
-    class EmptyWeights:
-        def __init__(self):
-            self.entered = 0
-            self.exited = 0
-
-        def __call__(self):
-            return self
-
-        def __enter__(self):
-            self.entered += 1
-            return None
-
-        def __exit__(self, exc_type, exc, tb):
-            self.exited += 1
-            return False
-
-    init_empty_weights = EmptyWeights()
-    set_calls = []
-
-    def fake_set_tensor(module, tensor_name, device, value=None, dtype=None):
-        set_calls.append((tensor_name, device, value, dtype))
-
-    tensors = {
-        "shard-1.safetensors": {
-            "model.embed_tokens.weight": "embed",
-            "model.layers.0.self_attn.q_proj.weight": "layer0",
-        },
-        "shard-2.safetensors": {
-            "model.layers.1.self_attn.q_proj.weight": "layer1",
-        },
-        "shard-3.safetensors": {
-            "model.layers.2.self_attn.q_proj.weight": "layer2",
-            "model.norm.weight": "norm",
-            "lm_head.weight": "lm_head",
-        },
-    }
-
-    class FakeSafeOpen:
-        def __init__(self, filename, framework, device):
-            assert framework == "pt"
-            assert device == "cpu"
-            self.filename = Path(filename).name
-
-        def __enter__(self):
-            return self
-
-        def __exit__(self, exc_type, exc, tb):
-            return False
-
-        def get_tensor(self, tensor_name):
-            return tensors[self.filename][tensor_name]
-
-    model = _load_partial_model_from_snapshot(
-        AutoConfigStub,
-        AutoModelStub,
-        types.SimpleNamespace(),
-        str(snapshot_dir),
-        1,
-        1,
-        "bf16",
-        "cpu:0",
-        init_empty_weights_fn=init_empty_weights,
-        set_tensor_fn=fake_set_tensor,
-        safe_open_fn=FakeSafeOpen,
-    )
-
-    assert init_empty_weights.entered == 1
-    assert init_empty_weights.exited == 1
-    assert model.tie_weights_called == 1
-    assert [call[0] for call in set_calls] == ["model.layers.1.self_attn.q_proj.weight"]
-    assert model.model.layers[1].to_calls == ["cpu:0"]
-    assert model.model.layers[0].to_calls == []
-    assert model.model.layers[2].to_calls == []
-    assert model.model.embed_tokens.to_calls == []
-    assert model.model.norm.to_calls == []
-    assert model.lm_head.to_calls == []
-    assert model.model.rotary_emb.to_calls == ["cpu:0"]
-
-
-def test_partial_snapshot_loader_requires_known_layer_count(tmp_path):
-    snapshot_dir = tmp_path / "snapshot"
-    snapshot_dir.mkdir()
-    (snapshot_dir / "config.json").write_text("{}")
-    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
-        "weight_map": {"model.layers.0.self_attn.q_proj.weight": "shard.safetensors"}
-    }))
-    (snapshot_dir / "shard.safetensors").write_bytes(b"stub")
-
-    class AutoConfigStub:
-        @staticmethod
-        def from_pretrained(model_id):
-            return types.SimpleNamespace()
-
-    class AutoModelStub:
-        @staticmethod
-        def from_config(cfg, torch_dtype=None):
-            raise AssertionError("from_config should not run without a known layer count")
-
-    class UnusedContext:
-        def __enter__(self):
-            return None
-
-        def __exit__(self, exc_type, exc, tb):
-            return False
-
-    with pytest.raises(PartialModelLoadUnsupported, match="num_hidden_layers"):
-        _load_partial_model_from_snapshot(
-            AutoConfigStub,
-            AutoModelStub,
-            types.SimpleNamespace(),
-            str(snapshot_dir),
-            0,
-            0,
-            "bf16",
-            "cpu:0",
-            init_empty_weights_fn=lambda: UnusedContext(),
-            set_tensor_fn=lambda *args, **kwargs: None,
-            safe_open_fn=lambda *args, **kwargs: None,
-        )
-
-
-def test_torch_model_shard_prefers_partial_loader_for_local_snapshot(tmp_path, monkeypatch):
-    import meshnet_node.model_backend as backend
-
-    snapshot_dir = tmp_path / "snapshot"
-    snapshot_dir.mkdir()
-    (snapshot_dir / "config.json").write_text("{}")
-    (snapshot_dir / "model.safetensors.index.json").write_text('{"weight_map": {}}')
-
-    class FakeModel:
-        def __init__(self):
-            self.model = types.SimpleNamespace(
-                layers=[object(), object(), object()],
-                embed_tokens=object(),
-            )
-            self.config = types.SimpleNamespace(hidden_size=8)
-            self.eval_called = 0
-
-        def eval(self):
-            self.eval_called += 1
-
-    fake_model = FakeModel()
-    partial_calls = []
-
-    class AutoConfigStub:
-        @staticmethod
-        def from_pretrained(model_id, cache_dir=None):
-            return types.SimpleNamespace(num_hidden_layers=3, text_config=types.SimpleNamespace(dtype="torch.bfloat16"))
-
-    class AutoModelStub:
-        @staticmethod
-        def from_pretrained(*args, **kwargs):
-            raise AssertionError("full model load should not run for partial local shards")
-
-    class AutoTokenizerStub:
-        @staticmethod
-        def from_pretrained(model_id, cache_dir=None):
-            assert model_id == str(snapshot_dir)
-            return types.SimpleNamespace()
-
-    monkeypatch.setitem(
-        sys.modules,
-        "torch",
-        types.SimpleNamespace(
-            cuda=types.SimpleNamespace(is_available=lambda: False),
-            device=lambda value: value,
-            bfloat16="bf16",
-        ),
-    )
-    monkeypatch.setitem(
-        sys.modules,
-        "transformers",
-        types.SimpleNamespace(
-            AutoConfig=AutoConfigStub,
-            AutoModelForCausalLM=AutoModelStub,
-            AutoTokenizer=AutoTokenizerStub,
-        ),
-    )
-    monkeypatch.setattr(
-        backend,
-        "_load_partial_model_from_snapshot",
-        lambda *args, **kwargs: partial_calls.append((args, kwargs)) or fake_model,
-    )
-
-    shard = TorchModelShard(
-        "repo/model",
-        1,
-        1,
-        quantization="auto",
-        cache_dir=snapshot_dir,
-    )
-
-    assert len(partial_calls) == 1
-    assert shard.model is fake_model
-    assert fake_model.eval_called == 1
-    assert shard.total_layers == 3
-    assert shard.is_head is False
-    assert shard.is_tail is False
-
-
-@pytest.mark.integration
-def test_two_node_gpt2_completion_is_deterministic():
-    if os.environ.get("CI"):
-        pytest.skip("GPT-2 integration test is skipped in CI")
-    torch = pytest.importorskip("torch")
-    pytest.importorskip("transformers")
-    pytest.importorskip("safetensors")
-    pytest.importorskip("accelerate")
-    pytest.importorskip("bitsandbytes")
-    if not torch.cuda.is_available():
-        pytest.skip("GPT-2 integration test requires a CUDA GPU")
-
-    head = TorchNodeServer(
-        model_id="openai-community/gpt2",
-        shard_start=0,
-        shard_end=6,
-        quantization="bfloat16",
-    )
-    tail = TorchNodeServer(
-        model_id="openai-community/gpt2",
-        shard_start=6,
-        shard_end=12,
-        quantization="bfloat16",
-    )
-    head_port = head.start()
-    tail_port = tail.start()
-    try:
-        prompt_req = urllib.request.Request(
-            f"http://127.0.0.1:{head_port}/forward",
-            data=json.dumps({"prompt": "The capital of France is"}).encode(),
-            headers={"Content-Type": "application/json"},
-            method="POST",
-        )
-        with urllib.request.urlopen(prompt_req, timeout=60) as resp:
-            activation = resp.read()
-            head_headers = resp.headers
-
-        tail_req = urllib.request.Request(
-            f"http://127.0.0.1:{tail_port}/forward",
-            data=activation,
-            headers={
-                "Content-Type": "application/octet-stream",
-                "X-Meshnet-Shape": head_headers["X-Meshnet-Shape"],
-                "X-Meshnet-Dtype": head_headers["X-Meshnet-Dtype"],
-                "X-Meshnet-Session": "gpt2-session",
-                "X-Meshnet-Chunk-Index": "0",
-                "X-Meshnet-Chunk-Total": "1",
-                "X-Meshnet-Hop-Index": "1",
-                "X-Meshnet-Attn-Mask": head_headers["X-Meshnet-Attn-Mask"],
-                "X-Meshnet-Position-Ids": head_headers["X-Meshnet-Position-Ids"],
-            },
-            method="POST",
-        )
-        with urllib.request.urlopen(tail_req, timeout=60) as resp:
-            body = json.loads(resp.read())
-
-        assert body["text"].strip()
-        assert body["text"] == " Paris"
-    finally:
-        head.stop()
-        tail.stop()
+"""US-012 tests for the real PyTorch node backend."""
+
+import json
+import os
+from pathlib import Path
+import sys
+import threading
+import time
+import types
+import urllib.request
+
+import pytest
+
+from meshnet_node.model_backend import (
+    InsufficientVRAMError,
+    PartialModelLoadUnsupported,
+    TensorPayload,
+    TorchModelShard,
+    _call_layer,
+    _checkpoint_tensor_name_for_model,
+    _load_partial_model_from_snapshot,
+    _should_partial_materialize_shard,
+    _decoder_attention_mask,
+    _int_tensor_header,
+    build_quantization_config,
+    validate_quantization,
+)
+from meshnet_node.torch_server import TorchNodeServer
+
+
+class _FakeBackend:
+    model_id = "fake-model"
+    total_layers = 12
+    is_head = True
+    is_tail = False
+
+    def encode_prompt(self, prompt: str) -> TensorPayload:
+        assert prompt == "The capital of France is"
+        return TensorPayload(
+            body=b"\x00" * (1 * 6 * 8 * 2),
+            shape=[1, 6, 8],
+            attention_mask_header=None,
+            position_ids_header=None,
+        )
+
+    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
+        assert shape == [1, 6, 8]
+        return TensorPayload(
+            body=body,
+            shape=shape,
+            attention_mask_header=attention_mask_header,
+            position_ids_header=position_ids_header,
+        )
+
+
+class _FakeTailBackend(_FakeBackend):
+    is_head = False
+    is_tail = True
+
+    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
+        assert len(body) == 1 * 6 * 8 * 2
+        return " Paris"
+
+
+class _FakeFullBackend(_FakeBackend):
+    is_head = True
+    is_tail = True
+
+    def generate_text(
+        self,
+        messages: list[dict],
+        max_new_tokens: int = 16,
+        temperature: float = 1.0,
+        top_p: float = 1.0,
+    ) -> str:
+        assert messages == [{"role": "user", "content": "What is 7 times 8?"}]
+        assert max_new_tokens == 7
+        assert temperature == 1.0
+        assert top_p == 1.0
+        return "56"
+
+    def count_prompt_tokens(self, messages: list[dict]) -> int:
+        assert messages == [{"role": "user", "content": "What is 7 times 8?"}]
+        return 8
+
+    def count_text_tokens(self, text: str) -> int:
+        assert text == "56"
+        return 1
+
+
+class _FakeChatTokenizer:
+    eos_token = ""
+
+    def apply_chat_template(self, messages, add_generation_prompt=True, tokenize=False):
+        assert add_generation_prompt is True
+        assert tokenize is False
+        return "debug prompt"
+
+
+class _FakePipelineHeadBackend(_FakeBackend):
+    tokenizer = _FakeChatTokenizer()
+
+    def encode_prompt(self, prompt: str) -> TensorPayload:
+        assert prompt.startswith("debug prompt")
+        return TensorPayload(
+            body=b"\x00" * (1 * 6 * 8 * 2),
+            shape=[1, 6, 8],
+            attention_mask_header=None,
+            position_ids_header=None,
+        )
+
+
+class _FakePipelineTailBackend(_FakeTailBackend):
+    def __init__(self) -> None:
+        self.start_layers: list[int | None] = []
+
+    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
+        self.start_layers.append(start_layer)
+        assert len(body) == 1 * 6 * 8 * 2
+        return " token"
+
+
+class _BlockingStreamingTailBackend(_FakeTailBackend):
+    def __init__(self, second_token_release: threading.Event) -> None:
+        self._release = second_token_release
+        self.calls = 0
+
+    def forward_bytes(self, body, shape, attention_mask_header, position_ids_header, start_layer=None):
+        self.calls += 1
+        if self.calls == 1:
+            return " first"
+        self._release.wait(timeout=3.0)
+        return " second"
+
+
+def test_quantization_flag_validation():
+    assert validate_quantization("bfloat16") == "bfloat16"
+    assert validate_quantization("int8") == "int8"
+    assert validate_quantization("nf4") == "nf4"
+    with pytest.raises(ValueError, match="quantization"):
+        validate_quantization("float32")
+
+
+def test_node_package_declares_torch_dependency():
+    pyproject = Path("packages/node/pyproject.toml").read_text(encoding="utf-8")
+
+    assert '"torch>=' in pyproject
+
+
+def test_bitsandbytes_configs_are_created_lazily(monkeypatch):
+    calls = []
+
+    class FakeBitsAndBytesConfig:
+        def __init__(self, **kwargs):
+            calls.append(kwargs)
+
+    monkeypatch.setitem(sys.modules, "torch", types.SimpleNamespace(bfloat16="bf16"))
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        types.SimpleNamespace(BitsAndBytesConfig=FakeBitsAndBytesConfig),
+    )
+
+    assert build_quantization_config("bfloat16") is None
+    build_quantization_config("int8")
+    build_quantization_config("nf4")
+
+    assert calls == [
+        {"load_in_8bit": True},
+        {
+            "load_in_4bit": True,
+            "bnb_4bit_quant_type": "nf4",
+            "bnb_4bit_compute_dtype": "bf16",
+        },
+    ]
+
+
+def test_head_forward_accepts_text_prompt_and_returns_bfloat16_activations():
+    node = TorchNodeServer(backend=_FakeBackend())
+    port = node.start()
+    try:
+        payload = json.dumps({"prompt": "The capital of France is"}).encode()
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{port}/forward",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            body = resp.read()
+            headers = {key.lower(): value for key, value in resp.headers.items()}
+
+        assert len(body) == 1 * 6 * 8 * 2
+        assert headers["x-meshnet-shape"] == "1,6,8"
+        assert headers["x-meshnet-dtype"] == "bfloat16"
+        assert headers["x-meshnet-wire"] == "2"
+    finally:
+        node.stop()
+
+
+def test_tail_forward_returns_text_completion_from_binary_activations():
+    node = TorchNodeServer(backend=_FakeTailBackend())
+    port = node.start()
+    try:
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{port}/forward",
+            data=b"\x00" * (1 * 6 * 8 * 2),
+            headers={
+                "Content-Type": "application/octet-stream",
+                "X-Meshnet-Shape": "1,6,8",
+                "X-Meshnet-Dtype": "bfloat16",
+                "X-Meshnet-Session": "session-1",
+                "X-Meshnet-Chunk-Index": "0",
+                "X-Meshnet-Chunk-Total": "1",
+                "X-Meshnet-Hop-Index": "1",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            body = json.loads(resp.read())
+
+        assert body == {"text": " Paris"}
+        assert node.received_activations
+        assert node.forward_chunk_count == 1
+    finally:
+        node.stop()
+
+
+def test_full_model_chat_completion_uses_generation_not_single_token_decode(capsys):
+    node = TorchNodeServer(backend=_FakeFullBackend())
+    port = node.start()
+    try:
+        payload = json.dumps({
+            "model": "fake-model",
+            "messages": [{"role": "user", "content": "What is 7 times 8?"}],
+            "max_tokens": 7,
+        }).encode()
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{port}/v1/chat/completions",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Meshnet-Request-Id": "req-test-123",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            body = json.loads(resp.read())
+
+        assert body["choices"][0]["message"]["content"] == "56"
+        assert body["usage"] == {"prompt_tokens": 8, "completion_tokens": 1, "total_tokens": 9}
+    finally:
+        node.stop()
+
+    out = capsys.readouterr().out
+    assert "  [node] processing chat model='fake-model' stream=False max_tokens=7 request_id=req-test-123" in out
+    assert "  [node] chat complete tokens=1 elapsed_s=" in out
+
+
+def test_pipeline_hop_logs_are_suppressed_without_debug(capsys):
+    tail_backend = _FakePipelineTailBackend()
+    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True)
+    tail = TorchNodeServer(backend=tail_backend)
+    head_port = head.start()
+    tail_port = tail.start()
+    try:
+        payload = json.dumps({
+            "model": "fake-model",
+            "messages": [{"role": "user", "content": "hello"}],
+            "max_tokens": 1,
+        }).encode()
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{head_port}/v1/chat/completions",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Meshnet-Route": json.dumps([
+                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
+                ]),
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            body = json.loads(resp.read())
+    finally:
+        head.stop()
+        tail.stop()
+
+    out = capsys.readouterr().out
+    assert body["choices"][0]["message"]["content"] == " token"
+    assert tail_backend.start_layers == [22]
+    assert "pipeline hop 0:" not in out
+    assert "pipeline hop 0 returned text" not in out
+
+
+def test_pipeline_hop_logs_are_enabled_with_debug(capsys):
+    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True, debug=True)
+    tail = TorchNodeServer(backend=_FakePipelineTailBackend())
+    head_port = head.start()
+    tail_port = tail.start()
+    try:
+        payload = json.dumps({
+            "model": "fake-model",
+            "messages": [{"role": "user", "content": "hello"}],
+            "max_tokens": 1,
+        }).encode()
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{head_port}/v1/chat/completions",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Meshnet-Route": json.dumps([
+                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
+                ]),
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            json.loads(resp.read())
+    finally:
+        head.stop()
+        tail.stop()
+
+    out = capsys.readouterr().out
+    assert f"  [node] pipeline hop 0: http://127.0.0.1:{tail_port} start_layer=22" in out
+    assert "  [node] pipeline hop 0 returned text=' token'" in out
+
+
+def test_split_shard_chat_streams_each_generated_token_incrementally():
+    release_second = threading.Event()
+    head = TorchNodeServer(backend=_FakePipelineHeadBackend(), tracker_mode=True)
+    tail = TorchNodeServer(backend=_BlockingStreamingTailBackend(release_second))
+    head_port = head.start()
+    tail_port = tail.start()
+    response = None
+    try:
+        payload = json.dumps({
+            "model": "fake-model",
+            "messages": [{"role": "user", "content": "hello"}],
+            "stream": True,
+            "max_tokens": 2,
+        }).encode()
+        req = urllib.request.Request(
+            f"http://127.0.0.1:{head_port}/v1/chat/completions",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "X-Meshnet-Route": json.dumps([
+                    {"endpoint": f"http://127.0.0.1:{tail_port}", "start_layer": 22},
+                ]),
+            },
+            method="POST",
+        )
+        response = urllib.request.urlopen(req, timeout=5)
+
+        first_token_line = ""
+        deadline = time.time() + 2.0
+        while time.time() < deadline:
+            line = response.readline().decode()
+            if '"content": " first"' in line:
+                first_token_line = line
+                break
+
+        assert first_token_line
+        assert not release_second.is_set()
+        release_second.set()
+        rest = response.read().decode()
+    finally:
+        release_second.set()
+        if response is not None:
+            response.close()
+        head.stop()
+        tail.stop()
+
+    assert '"content": " second"' in rest
+    assert "data: [DONE]" in rest
+
+
+def test_int_tensor_header_serializes_torch_tensors():
+    torch = pytest.importorskip("torch")
+
+    header = _int_tensor_header(torch.tensor([[1, 2, 3]], dtype=torch.long))
+
+    assert header.startswith("1,3:")
+
+
+def test_decoder_attention_mask_is_causal_float_mask():
+    torch = pytest.importorskip("torch")
+
+    hidden_states = torch.zeros((1, 3, 8), dtype=torch.bfloat16)
+    mask = _decoder_attention_mask(torch.ones((1, 3), dtype=torch.long), hidden_states, torch)
+
+    assert mask.shape == (1, 1, 3, 3)
+    assert mask.dtype == torch.bfloat16
+    assert mask[0, 0, 0, 1] < 0
+    assert mask[0, 0, 2, 0] == 0
+
+
+def test_call_layer_passes_rotary_position_embeddings():
+    class NeedsPositionEmbeddings:
+        def __call__(self, hidden_states, **kwargs):
+            assert kwargs["position_embeddings"] == "rotary"
+            return hidden_states
+
+    assert _call_layer(
+        NeedsPositionEmbeddings(),
+        "hidden",
+        attention_mask=None,
+        position_ids="positions",
+        position_embeddings="rotary",
+    ) == "hidden"
+
+
+def test_partial_materialize_guard_requires_local_non_full_non_quantized_snapshot(tmp_path):
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text("{}")
+    (snapshot_dir / "model.safetensors.index.json").write_text('{"weight_map": {}}')
+
+    assert _should_partial_materialize_shard(
+        str(snapshot_dir),
+        4,
+        7,
+        total_layers_hint=40,
+        uses_quantized_weights=False,
+    ) is True
+    assert _should_partial_materialize_shard(
+        str(snapshot_dir),
+        0,
+        39,
+        total_layers_hint=40,
+        uses_quantized_weights=False,
+    ) is True
+    assert _should_partial_materialize_shard(
+        str(snapshot_dir),
+        4,
+        7,
+        total_layers_hint=40,
+        uses_quantized_weights=True,
+    ) is False
+    assert _should_partial_materialize_shard(
+        "repo/model",
+        4,
+        7,
+        total_layers_hint=40,
+        uses_quantized_weights=False,
+    ) is False
+
+
+def test_checkpoint_tensor_name_remapped_for_text_only_causal_lm():
+    class TextOnlyModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(layers=[])
+
+    model = TextOnlyModel()
+    assert _checkpoint_tensor_name_for_model(
+        model,
+        "model.language_model.layers.0.mlp.gate.weight",
+    ) == "model.layers.0.mlp.gate.weight"
+    assert _checkpoint_tensor_name_for_model(
+        model,
+        "model.language_model.embed_tokens.weight",
+    ) == "model.embed_tokens.weight"
+
+
+def test_checkpoint_tensor_name_kept_for_multimodal_backbone():
+    class MultimodalModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(language_model=types.SimpleNamespace())
+
+    model = MultimodalModel()
+    name = "model.language_model.layers.0.mlp.gate.weight"
+    assert _checkpoint_tensor_name_for_model(model, name) == name
+
+
+def test_partial_snapshot_loader_remaps_language_model_checkpoint_keys(tmp_path):
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text(json.dumps({
+        "text_config": {"num_hidden_layers": 3},
+    }))
+    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
+        "weight_map": {
+            "model.language_model.layers.1.self_attn.q_proj.weight": "shard-2.safetensors",
+        }
+    }))
+    (snapshot_dir / "shard-2.safetensors").write_bytes(b"stub")
+
+    class FakeModule:
+        def __init__(self):
+            self.to_calls = []
+
+        def to(self, device):
+            self.to_calls.append(device)
+            return self
+
+    class FakeModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(
+                layers=[FakeModule(), FakeModule(), FakeModule()],
+                rotary_emb=FakeModule(),
+            )
+
+        def tie_weights(self):
+            pass
+
+    class AutoConfigStub:
+        @staticmethod
+        def from_pretrained(model_id):
+            return types.SimpleNamespace(
+                text_config=types.SimpleNamespace(num_hidden_layers=3),
+                get_text_config=lambda: types.SimpleNamespace(num_hidden_layers=3),
+            )
+
+    class AutoModelStub:
+        @staticmethod
+        def from_config(cfg, torch_dtype=None):
+            return FakeModel()
+
+    set_calls = []
+
+    def fake_set_tensor(module, tensor_name, device, value=None, dtype=None):
+        set_calls.append(tensor_name)
+
+    class FakeSafeOpen:
+        def __init__(self, filename, framework, device):
+            self.filename = Path(filename).name
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def get_tensor(self, tensor_name):
+            return tensor_name
+
+    class UnusedContext:
+        def __enter__(self):
+            return None
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    _load_partial_model_from_snapshot(
+        AutoConfigStub,
+        AutoModelStub,
+        types.SimpleNamespace(),
+        str(snapshot_dir),
+        1,
+        1,
+        "bf16",
+        "cpu:0",
+        init_empty_weights_fn=UnusedContext,
+        set_tensor_fn=fake_set_tensor,
+        safe_open_fn=FakeSafeOpen,
+    )
+
+    assert set_calls == ["model.layers.1.self_attn.q_proj.weight"]
+
+
+def test_partial_snapshot_loader_skips_tensors_absent_from_causal_lm(tmp_path):
+    # Multimodal/MTP checkpoints (Qwen3.5/3.6-MoE) carry mtp.* and model.visual.*
+    # tensors that the text-only CausalLM never builds — they must be skipped,
+    # not assigned (assignment raises AttributeError: 'mtp' / 'visual').
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text(json.dumps({
+        "text_config": {"num_hidden_layers": 3},
+    }))
+    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
+        "weight_map": {
+            "model.language_model.layers.1.self_attn.q_proj.weight": "shard-2.safetensors",
+            "mtp.layers.1.input_layernorm.weight": "shard-2.safetensors",
+            "model.visual.blocks.1.attn.qkv.weight": "shard-2.safetensors",
+        }
+    }))
+    (snapshot_dir / "shard-2.safetensors").write_bytes(b"stub")
+
+    class FakeModule:
+        def to(self, device):
+            return self
+
+    class FakeModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(
+                layers=[FakeModule(), FakeModule(), FakeModule()],
+                rotary_emb=FakeModule(),
+            )
+
+        def tie_weights(self):
+            pass
+
+        def state_dict(self):
+            return {"model.layers.1.self_attn.q_proj.weight": None}
+
+    class AutoConfigStub:
+        @staticmethod
+        def from_pretrained(model_id):
+            return types.SimpleNamespace(
+                text_config=types.SimpleNamespace(num_hidden_layers=3),
+                get_text_config=lambda: types.SimpleNamespace(num_hidden_layers=3),
+            )
+
+    class AutoModelStub:
+        @staticmethod
+        def from_config(cfg, torch_dtype=None):
+            return FakeModel()
+
+    set_calls = []
+
+    def fake_set_tensor(module, tensor_name, device, value=None, dtype=None):
+        set_calls.append(tensor_name)
+
+    class FakeSafeOpen:
+        def __init__(self, filename, framework, device):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def get_tensor(self, tensor_name):
+            return tensor_name
+
+    class UnusedContext:
+        def __enter__(self):
+            return None
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    _load_partial_model_from_snapshot(
+        AutoConfigStub,
+        AutoModelStub,
+        types.SimpleNamespace(),
+        str(snapshot_dir),
+        1,
+        1,
+        "bf16",
+        "cpu:0",
+        init_empty_weights_fn=UnusedContext,
+        set_tensor_fn=fake_set_tensor,
+        safe_open_fn=FakeSafeOpen,
+    )
+
+    assert set_calls == ["model.layers.1.self_attn.q_proj.weight"]
+
+
+def test_partial_snapshot_loader_materializes_only_assigned_tensors(tmp_path):
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text("{}")
+    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
+        "weight_map": {
+            "model.embed_tokens.weight": "shard-1.safetensors",
+            "model.layers.0.self_attn.q_proj.weight": "shard-1.safetensors",
+            "model.layers.1.self_attn.q_proj.weight": "shard-2.safetensors",
+            "model.layers.2.self_attn.q_proj.weight": "shard-3.safetensors",
+            "model.norm.weight": "shard-3.safetensors",
+            "lm_head.weight": "shard-3.safetensors",
+        }
+    }))
+    for rel in ("shard-1.safetensors", "shard-2.safetensors", "shard-3.safetensors"):
+        (snapshot_dir / rel).write_bytes(b"stub")
+
+    class FakeModule:
+        def __init__(self, name):
+            self.name = name
+            self.to_calls = []
+
+        def to(self, device):
+            self.to_calls.append(device)
+            return self
+
+    class FakeModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(
+                embed_tokens=FakeModule("embed"),
+                layers=[FakeModule("layer0"), FakeModule("layer1"), FakeModule("layer2")],
+                rotary_emb=FakeModule("rotary"),
+                norm=FakeModule("norm"),
+            )
+            self.lm_head = FakeModule("lm_head")
+            self.tie_weights_called = 0
+
+        def tie_weights(self):
+            self.tie_weights_called += 1
+
+    class AutoConfigStub:
+        @staticmethod
+        def from_pretrained(model_id):
+            assert model_id == str(snapshot_dir)
+            return types.SimpleNamespace(num_hidden_layers=3)
+
+    class AutoModelStub:
+        @staticmethod
+        def from_config(cfg, torch_dtype=None):
+            assert cfg.num_hidden_layers == 3
+            assert torch_dtype == "bf16"
+            return FakeModel()
+
+    class EmptyWeights:
+        def __init__(self):
+            self.entered = 0
+            self.exited = 0
+
+        def __call__(self):
+            return self
+
+        def __enter__(self):
+            self.entered += 1
+            return None
+
+        def __exit__(self, exc_type, exc, tb):
+            self.exited += 1
+            return False
+
+    init_empty_weights = EmptyWeights()
+    set_calls = []
+
+    def fake_set_tensor(module, tensor_name, device, value=None, dtype=None):
+        set_calls.append((tensor_name, device, value, dtype))
+
+    tensors = {
+        "shard-1.safetensors": {
+            "model.embed_tokens.weight": "embed",
+            "model.layers.0.self_attn.q_proj.weight": "layer0",
+        },
+        "shard-2.safetensors": {
+            "model.layers.1.self_attn.q_proj.weight": "layer1",
+        },
+        "shard-3.safetensors": {
+            "model.layers.2.self_attn.q_proj.weight": "layer2",
+            "model.norm.weight": "norm",
+            "lm_head.weight": "lm_head",
+        },
+    }
+
+    class FakeSafeOpen:
+        def __init__(self, filename, framework, device):
+            assert framework == "pt"
+            assert device == "cpu"
+            self.filename = Path(filename).name
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def get_tensor(self, tensor_name):
+            return tensors[self.filename][tensor_name]
+
+    model = _load_partial_model_from_snapshot(
+        AutoConfigStub,
+        AutoModelStub,
+        types.SimpleNamespace(),
+        str(snapshot_dir),
+        1,
+        1,
+        "bf16",
+        "cpu:0",
+        init_empty_weights_fn=init_empty_weights,
+        set_tensor_fn=fake_set_tensor,
+        safe_open_fn=FakeSafeOpen,
+    )
+
+    assert init_empty_weights.entered == 1
+    assert init_empty_weights.exited == 1
+    assert model.tie_weights_called == 1
+    assert [call[0] for call in set_calls] == ["model.layers.1.self_attn.q_proj.weight"]
+    assert model.model.layers[1].to_calls == ["cpu:0"]
+    assert model.model.layers[0].to_calls == []
+    assert model.model.layers[2].to_calls == []
+    assert model.model.embed_tokens.to_calls == []
+    assert model.model.norm.to_calls == []
+    assert model.lm_head.to_calls == []
+    assert model.model.rotary_emb.to_calls == ["cpu:0"]
+
+
+def test_partial_snapshot_loader_requires_known_layer_count(tmp_path):
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text("{}")
+    (snapshot_dir / "model.safetensors.index.json").write_text(json.dumps({
+        "weight_map": {"model.layers.0.self_attn.q_proj.weight": "shard.safetensors"}
+    }))
+    (snapshot_dir / "shard.safetensors").write_bytes(b"stub")
+
+    class AutoConfigStub:
+        @staticmethod
+        def from_pretrained(model_id):
+            return types.SimpleNamespace()
+
+    class AutoModelStub:
+        @staticmethod
+        def from_config(cfg, torch_dtype=None):
+            raise AssertionError("from_config should not run without a known layer count")
+
+    class UnusedContext:
+        def __enter__(self):
+            return None
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+    with pytest.raises(PartialModelLoadUnsupported, match="num_hidden_layers"):
+        _load_partial_model_from_snapshot(
+            AutoConfigStub,
+            AutoModelStub,
+            types.SimpleNamespace(),
+            str(snapshot_dir),
+            0,
+            0,
+            "bf16",
+            "cpu:0",
+            init_empty_weights_fn=lambda: UnusedContext(),
+            set_tensor_fn=lambda *args, **kwargs: None,
+            safe_open_fn=lambda *args, **kwargs: None,
+        )
+
+
+def test_torch_model_shard_prefers_partial_loader_for_local_snapshot(tmp_path, monkeypatch):
+    import meshnet_node.model_backend as backend
+
+    snapshot_dir = tmp_path / "snapshot"
+    snapshot_dir.mkdir()
+    (snapshot_dir / "config.json").write_text("{}")
+    (snapshot_dir / "model.safetensors.index.json").write_text('{"weight_map": {}}')
+
+    class FakeModel:
+        def __init__(self):
+            self.model = types.SimpleNamespace(
+                layers=[object(), object(), object()],
+                embed_tokens=object(),
+            )
+            self.config = types.SimpleNamespace(hidden_size=8)
+            self.eval_called = 0
+
+        def eval(self):
+            self.eval_called += 1
+
+    fake_model = FakeModel()
+    partial_calls = []
+
+    class AutoConfigStub:
+        @staticmethod
+        def from_pretrained(model_id, cache_dir=None):
+            return types.SimpleNamespace(num_hidden_layers=3, text_config=types.SimpleNamespace(dtype="torch.bfloat16"))
+
+    class AutoModelStub:
+        @staticmethod
+        def from_pretrained(*args, **kwargs):
+            raise AssertionError("full model load should not run for partial local shards")
+
+    class AutoTokenizerStub:
+        @staticmethod
+        def from_pretrained(model_id, cache_dir=None):
+            assert model_id == str(snapshot_dir)
+            return types.SimpleNamespace()
+
+    monkeypatch.setitem(
+        sys.modules,
+        "torch",
+        types.SimpleNamespace(
+            cuda=types.SimpleNamespace(is_available=lambda: False),
+            device=lambda value: value,
+            bfloat16="bf16",
+        ),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        types.SimpleNamespace(
+            AutoConfig=AutoConfigStub,
+            AutoModelForCausalLM=AutoModelStub,
+            AutoTokenizer=AutoTokenizerStub,
+        ),
+    )
+    monkeypatch.setattr(
+        backend,
+        "_load_partial_model_from_snapshot",
+        lambda *args, **kwargs: partial_calls.append((args, kwargs)) or fake_model,
+    )
+
+    shard = TorchModelShard(
+        "repo/model",
+        1,
+        1,
+        quantization="auto",
+        cache_dir=snapshot_dir,
+    )
+
+    assert len(partial_calls) == 1
+    assert shard.model is fake_model
+    assert fake_model.eval_called == 1
+    assert shard.total_layers == 3
+    assert shard.is_head is False
+    assert shard.is_tail is False
+
+
+@pytest.mark.integration
+def test_two_node_gpt2_completion_is_deterministic():
+    if os.environ.get("CI"):
+        pytest.skip("GPT-2 integration test is skipped in CI")
+    torch = pytest.importorskip("torch")
+    pytest.importorskip("transformers")
+    pytest.importorskip("safetensors")
+    pytest.importorskip("accelerate")
+    pytest.importorskip("bitsandbytes")
+    if not torch.cuda.is_available():
+        pytest.skip("GPT-2 integration test requires a CUDA GPU")
+
+    head = TorchNodeServer(
+        model_id="openai-community/gpt2",
+        shard_start=0,
+        shard_end=6,
+        quantization="bfloat16",
+    )
+    tail = TorchNodeServer(
+        model_id="openai-community/gpt2",
+        shard_start=6,
+        shard_end=12,
+        quantization="bfloat16",
+    )
+    head_port = head.start()
+    tail_port = tail.start()
+    try:
+        prompt_req = urllib.request.Request(
+            f"http://127.0.0.1:{head_port}/forward",
+            data=json.dumps({"prompt": "The capital of France is"}).encode(),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(prompt_req, timeout=60) as resp:
+            activation = resp.read()
+            head_headers = resp.headers
+
+        tail_req = urllib.request.Request(
+            f"http://127.0.0.1:{tail_port}/forward",
+            data=activation,
+            headers={
+                "Content-Type": "application/octet-stream",
+                "X-Meshnet-Shape": head_headers["X-Meshnet-Shape"],
+                "X-Meshnet-Dtype": head_headers["X-Meshnet-Dtype"],
+                "X-Meshnet-Session": "gpt2-session",
+                "X-Meshnet-Chunk-Index": "0",
+                "X-Meshnet-Chunk-Total": "1",
+                "X-Meshnet-Hop-Index": "1",
+                "X-Meshnet-Attn-Mask": head_headers["X-Meshnet-Attn-Mask"],
+                "X-Meshnet-Position-Ids": head_headers["X-Meshnet-Position-Ids"],
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(tail_req, timeout=60) as resp:
+            body = json.loads(resp.read())
+
+        assert body["text"].strip()
+        assert body["text"] == " Paris"
+    finally:
+        head.stop()
+        tail.stop()