@caupulican/pi-adaptative 0.81.13 → 0.81.16

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [0.81.16] - 2026-07-08
+
+### Added
+- Added graded `/toolprobe` native capability reporting and persistence so native verdicts require both an echo probe and a task-scale read probe, while echo-only or absent native support can calibrate the text protocol.
+- Added MiniCPM5-1B to the live acceptance fleet as a full-base native tool-calling target through the pi-managed Transformers sidecar.
+- Added a pi-managed Hugging Face Transformers runtime path for curated full-base local model suggestions, starting with `openbmb/MiniCPM5-1B`, using an isolated venv and pi-owned HF cache.
+
+### Fixed
+- Fixed tool probing so a real task-scale native tool call wins without requiring a separate echo-only probe, and the MiniCPM sidecar stops generation after a complete native function call.
+- Documented the Ollama serving-context requirement for local OpenAI-compatible models.
+
+## [0.81.15] - 2026-07-07
+
+## [0.81.14] - 2026-07-07
+
+### Fixed
+- Fixed text protocol model gating so persisted probe verdicts opt in only text-protocol models after env/settings/model gates, while unflagged native models do not receive the primer.
+- Documented the `propertyCaseNormalize` and `jsonObjectPropertySalvage` repair modes in the operator docs and bundled tool-repair skill.
+
 ## [0.81.13] - 2026-07-07
 
 ### Fixed

package/dist/bundled-resources/runtimes/hf-transformers-openai-server.py

@@ -0,0 +1,427 @@
+#!/usr/bin/env python3
+"""Tiny OpenAI-compatible chat sidecar for pi-managed Hugging Face Transformers models.
+
+Intentionally stdlib-only at the server layer: the managed venv supplies torch,
+transformers, and huggingface_hub, while HTTP serving stays dependency-free so pi
+does not need FastAPI/Uvicorn just to run a suggested local model.
+"""
+
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import os
+import re
+import sys
+import time
+import traceback
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
+
+_MODEL_ID = ""
+_TOKENIZER: Any = None
+_MODEL: Any = None
+_TORCH: Any = None
+_DEVICE = "cpu"
+_FUNCTION_CALL_RE = re.compile(r"<function\b[^>]*>.*?</function>", re.DOTALL)
+_FUNCTION_NAME_RE = re.compile(r"<function\b[^>]*\bname=(['\"])(.*?)\1", re.DOTALL)
+_PARAM_RE = re.compile(r"<param\b[^>]*\bname=(['\"])(.*?)\1[^>]*>(.*?)</param>", re.DOTALL)
+
+
+def _json_response(handler: BaseHTTPRequestHandler, status: int, body: dict[str, Any]) -> None:
+    payload = json.dumps(body).encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("content-type", "application/json")
+    handler.send_header("content-length", str(len(payload)))
+    handler.end_headers()
+    handler.wfile.write(payload)
+
+
+def _message_text(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                text = item.get("text")
+                if isinstance(text, str):
+                    parts.append(text)
+        return "\n".join(parts)
+    return "" if content is None else str(content)
+
+
+def _decode_arguments(arguments: Any) -> Any:
+    if isinstance(arguments, str):
+        try:
+            return json.loads(arguments)
+        except json.JSONDecodeError as error:
+            raise ValueError(f"tool_call function.arguments must be valid JSON: {error.msg}") from error
+    return arguments
+
+
+def _normalize_tool_calls(tool_calls: Any) -> list[dict[str, Any]]:
+    normalized: list[dict[str, Any]] = []
+    if not isinstance(tool_calls, list):
+        return normalized
+    for tool_call in tool_calls:
+        if not isinstance(tool_call, dict):
+            continue
+        function = tool_call.get("function")
+        if not isinstance(function, dict):
+            continue
+        name = function.get("name")
+        if not isinstance(name, str) or not name:
+            continue
+        normalized_call: dict[str, Any] = {
+            "type": "function",
+            "function": {"name": name, "arguments": _decode_arguments(function.get("arguments"))},
+        }
+        tool_call_id = tool_call.get("id")
+        if isinstance(tool_call_id, str) and tool_call_id:
+            normalized_call["id"] = tool_call_id
+        normalized.append(normalized_call)
+    return normalized
+
+
+def _normalize_messages(messages: Any) -> list[dict[str, Any]]:
+    normalized: list[dict[str, Any]] = []
+    if not isinstance(messages, list):
+        return normalized
+    for message in messages:
+        if not isinstance(message, dict):
+            continue
+        role = message.get("role")
+        if role == "developer":
+            role = "system"
+        if role not in {"system", "user", "assistant", "tool"}:
+            role = "user"
+        normalized_message: dict[str, Any] = {"role": str(role), "content": _message_text(message.get("content"))}
+        if role == "assistant":
+            tool_calls = _normalize_tool_calls(message.get("tool_calls"))
+            if tool_calls:
+                normalized_message["tool_calls"] = tool_calls
+        if role == "tool":
+            tool_call_id = message.get("tool_call_id")
+            if isinstance(tool_call_id, str) and tool_call_id:
+                normalized_message["tool_call_id"] = tool_call_id
+        normalized.append(normalized_message)
+    return normalized
+
+
+def _render_prompt(messages: list[dict[str, Any]], tools: Any) -> str:
+    tokenizer = _TOKENIZER
+    kwargs: dict[str, Any] = {
+        "tokenize": False,
+        "add_generation_prompt": True,
+    }
+    if isinstance(tools, list) and tools:
+        kwargs["tools"] = tools
+    return tokenizer.apply_chat_template(messages, **kwargs)
+
+
+def _generation_options(request: dict[str, Any]) -> dict[str, Any]:
+    max_tokens = request.get("max_completion_tokens", request.get("max_tokens", 512))
+    try:
+        max_new_tokens = max(1, min(int(max_tokens), 2048))
+    except Exception:
+        max_new_tokens = 512
+
+    temperature_value = request.get("temperature", 0.0)
+    try:
+        temperature = float(temperature_value)
+    except Exception:
+        temperature = 0.0
+    do_sample = temperature > 0.0
+
+    return {
+        "max_new_tokens": max_new_tokens,
+        "do_sample": do_sample,
+        **({"temperature": temperature} if do_sample else {}),
+    }
+
+
+def _clean_generated_text(text: str) -> str:
+    tokenizer = _TOKENIZER
+    eos = getattr(tokenizer, "eos_token", None)
+    if eos:
+        text = text.replace(eos, "")
+    pad = getattr(tokenizer, "pad_token", None)
+    if pad and pad != eos:
+        text = text.replace(pad, "")
+    return text.strip()
+
+
+def _decode_param_value(raw: str) -> Any:
+    stripped = raw.strip()
+    if stripped.startswith("{") or stripped.startswith("["):
+        try:
+            return json.loads(stripped)
+        except Exception:
+            return stripped
+    return stripped
+
+
+def _extract_native_function_calls(text: str) -> tuple[str, list[dict[str, Any]]]:
+    calls: list[dict[str, Any]] = []
+    spans: list[tuple[int, int]] = []
+    for match in _FUNCTION_CALL_RE.finditer(text):
+        block = match.group(0)
+        name_match = _FUNCTION_NAME_RE.search(block)
+        if not name_match:
+            continue
+        name = html.unescape(name_match.group(2).strip())
+        if not name:
+            continue
+        arguments: dict[str, Any] = {}
+        for param_match in _PARAM_RE.finditer(block):
+            param_name = html.unescape(param_match.group(2).strip())
+            if not param_name:
+                continue
+            arguments[param_name] = _decode_param_value(html.unescape(param_match.group(3)))
+        calls.append(
+            {
+                "id": f"call_{uuid.uuid4().hex}",
+                "type": "function",
+                "function": {"name": name, "arguments": json.dumps(arguments, ensure_ascii=False)},
+            }
+        )
+        spans.append(match.span())
+    if not calls:
+        return text, []
+    remaining_parts: list[str] = []
+    cursor = 0
+    for start, end in spans:
+        remaining_parts.append(text[cursor:start])
+        cursor = end
+    remaining_parts.append(text[cursor:])
+    return "".join(remaining_parts).strip(), calls
+
+
+def _function_call_stopping_criteria(prompt_token_count: int) -> Any:
+    from transformers import StoppingCriteria, StoppingCriteriaList
+
+    class StopAfterFunctionCall(StoppingCriteria):
+        def __call__(self, input_ids: Any, _scores: Any, **_kwargs: Any) -> bool:
+            generated_ids = input_ids[0][prompt_token_count:]
+            if int(generated_ids.shape[-1]) == 0:
+                return False
+            text = _TOKENIZER.decode(generated_ids, skip_special_tokens=False)
+            return bool(_FUNCTION_CALL_RE.search(text))
+
+    return StoppingCriteriaList([StopAfterFunctionCall()])
+
+
+def _generate(request: dict[str, Any]) -> str:
+    tokenizer = _TOKENIZER
+    model = _MODEL
+    torch = _TORCH
+    messages = _normalize_messages(request.get("messages"))
+    prompt = _render_prompt(messages, request.get("tools"))
+    encoded = tokenizer(prompt, return_tensors="pt")
+    encoded = {key: value.to(_DEVICE) for key, value in encoded.items()}
+    input_length = int(encoded["input_ids"].shape[-1])
+    options = _generation_options(request)
+    eos_token_id = getattr(tokenizer, "eos_token_id", None)
+    pad_token_id = getattr(tokenizer, "pad_token_id", None) or eos_token_id
+    generation_args: dict[str, Any] = {
+        **encoded,
+        "eos_token_id": eos_token_id,
+        "pad_token_id": pad_token_id,
+        **options,
+    }
+    if isinstance(request.get("tools"), list) and request.get("tools"):
+        generation_args["stopping_criteria"] = _function_call_stopping_criteria(input_length)
+    with torch.inference_mode():
+        output = model.generate(**generation_args)
+    generated = output[0][input_length:]
+    return _clean_generated_text(tokenizer.decode(generated, skip_special_tokens=False))
+
+
+def _stream_chunk(handler: BaseHTTPRequestHandler, chunk: dict[str, Any]) -> None:
+    handler.wfile.write(f"data: {json.dumps(chunk)}\n\n".encode("utf-8"))
+    handler.wfile.flush()
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "pi-hf-transformers/1"
+
+    def log_message(self, fmt: str, *args: Any) -> None:
+        sys.stderr.write("[%s] %s\n" % (self.log_date_time_string(), fmt % args))
+
+    def do_GET(self) -> None:  # noqa: N802 - stdlib handler API
+        if self.path == "/health":
+            _json_response(self, 200, {"ok": True, "model": _MODEL_ID})
+            return
+        if self.path == "/v1/models":
+            _json_response(
+                self,
+                200,
+                {"object": "list", "data": [{"id": _MODEL_ID, "object": "model", "owned_by": "pi"}]},
+            )
+            return
+        _json_response(self, 404, {"error": "not found"})
+
+    def do_POST(self) -> None:  # noqa: N802 - stdlib handler API
+        if self.path != "/v1/chat/completions":
+            _json_response(self, 404, {"error": "not found"})
+            return
+        try:
+            length = int(self.headers.get("content-length", "0"))
+            request = json.loads(self.rfile.read(length).decode("utf-8"))
+            text = _generate(request)
+            content, tool_calls = _extract_native_function_calls(text)
+            if request.get("stream", False):
+                self.send_response(200)
+                self.send_header("content-type", "text/event-stream")
+                self.send_header("cache-control", "no-cache")
+                self.end_headers()
+                chunk_id = f"chatcmpl-pi-{uuid.uuid4().hex}"
+                created = int(time.time())
+                _stream_chunk(
+                    self,
+                    {
+                        "id": chunk_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": _MODEL_ID,
+                        "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+                    },
+                )
+                if content:
+                    _stream_chunk(
+                        self,
+                        {
+                            "id": chunk_id,
+                            "object": "chat.completion.chunk",
+                            "created": created,
+                            "model": _MODEL_ID,
+                            "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": None}],
+                        },
+                    )
+                for index, tool_call in enumerate(tool_calls):
+                    _stream_chunk(
+                        self,
+                        {
+                            "id": chunk_id,
+                            "object": "chat.completion.chunk",
+                            "created": created,
+                            "model": _MODEL_ID,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {
+                                        "tool_calls": [
+                                            {
+                                                "index": index,
+                                                "id": tool_call["id"],
+                                                "type": "function",
+                                                "function": tool_call["function"],
+                                            }
+                                        ]
+                                    },
+                                    "finish_reason": None,
+                                }
+                            ],
+                        },
+                    )
+                _stream_chunk(
+                    self,
+                    {
+                        "id": chunk_id,
+                        "object": "chat.completion.chunk",
+                        "created": created,
+                        "model": _MODEL_ID,
+                        "choices": [
+                            {"index": 0, "delta": {}, "finish_reason": "tool_calls" if tool_calls else "stop"}
+                        ],
+                    },
+                )
+                self.wfile.write(b"data: [DONE]\n\n")
+                self.wfile.flush()
+                return
+
+            _json_response(
+                self,
+                200,
+                {
+                    "id": f"chatcmpl-pi-{uuid.uuid4().hex}",
+                    "object": "chat.completion",
+                    "created": int(time.time()),
+                    "model": _MODEL_ID,
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": content if content else None,
+                                **({"tool_calls": tool_calls} if tool_calls else {}),
+                            },
+                            "finish_reason": "tool_calls" if tool_calls else "stop",
+                        }
+                    ],
+                },
+            )
+        except Exception as exc:  # pragma: no cover - surfaced to the TypeScript caller as HTTP 500
+            traceback.print_exc()
+            _json_response(self, 500, {"error": str(exc)})
+
+
+def _download_only(model_id: str, cache_dir: str) -> None:
+    from huggingface_hub import snapshot_download
+
+    snapshot_download(repo_id=model_id, cache_dir=cache_dir)
+
+
+def _load_model(model_id: str, cache_dir: str, device: str) -> None:
+    global _MODEL_ID, _TOKENIZER, _MODEL, _TORCH, _DEVICE
+
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+
+    threads = os.environ.get("PI_TRANSFORMERS_THREADS")
+    if threads:
+        try:
+            torch.set_num_threads(max(1, int(threads)))
+        except Exception:
+            pass
+
+    dtype_name = os.environ.get("PI_TRANSFORMERS_TORCH_DTYPE", "float32")
+    torch_dtype = getattr(torch, dtype_name, torch.float32)
+    tokenizer = AutoTokenizer.from_pretrained(model_id, cache_dir=cache_dir)
+    model = AutoModelForCausalLM.from_pretrained(model_id, cache_dir=cache_dir, torch_dtype=torch_dtype)
+    model.to(device)
+    model.eval()
+
+    _MODEL_ID = model_id
+    _TOKENIZER = tokenizer
+    _MODEL = model
+    _TORCH = torch
+    _DEVICE = device
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-id", required=True)
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=18100)
+    parser.add_argument("--cache-dir", required=True)
+    parser.add_argument("--device", default=os.environ.get("PI_TRANSFORMERS_DEVICE", "cpu"))
+    parser.add_argument("--download-only", action="store_true")
+    args = parser.parse_args()
+
+    os.makedirs(args.cache_dir, exist_ok=True)
+    if args.download_only:
+        _download_only(args.model_id, args.cache_dir)
+        return
+
+    _load_model(args.model_id, args.cache_dir, args.device)
+    server = ThreadingHTTPServer((args.host, args.port), Handler)
+    print(f"pi hf-transformers server ready model={args.model_id} url=http://{args.host}:{args.port}", flush=True)
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

package/dist/bundled-resources/skills/tool-call-repair/SKILL.md

@@ -103,17 +103,19 @@ as code (not prose):
 |---|---|---|---|
 | 1 | nullOptionalDrop | `null` for an optional field | delete key |
 | 2 | nullRequiredBounce | `null` for a required field | no repair; bounce with required-value feedback |
-| 3 | jsonStringParse | `"[...]"`/`"{...}"` string where container expected | JSON.parse; keep if it matches + checks |
-| 4 | singleObjectWrap | single object where array-of-objects expected | wrap `[obj]` if it passes `items` |
-| 5 | bareScalarWrap | bare scalar where array expected | wrap `[v]` if it passes `items` |
-| 6 | emptyObjectPlaceholder | `{}` placeholder where scalar expected | delete if optional (default applies); else bounce |
-| 7 | numberFromString | `"42"` where number expected | `Number(s)` if finite |
-| 8 | boolFromString | `"true"`/`"false"` where bool expected | exact map (never truthiness) |
-| 9 | enumCaseNormalize | case/space enum variant | match to the one member, else bounce |
-| 10 | singleElementUnwrap | `[v]` where scalar expected | unwrap if 1 elem and checks |
-| 11 | stringifiedNumberInArray | `["1","2"]` where number[] expected | map Number if all finite |
-| 12 | bashCommandArgvJoin | bash `command` sent as an argv list | join string values with spaces |
-| 13 | bashCommandUnwrap | bash `command` sent as a single-key object wrapper | unwrap the string-valued wrapper |
+| 3 | jsonStringParse | `"[...]"`/`"{...}"` string where container expected | JSON.parse; guarded smart-quote delimiter fallback; keep if it matches + checks |
+| 4 | jsonObjectPropertySalvage | malformed object string with recoverable declared properties | keep declared property values if the whole object checks |
+| 5 | singleObjectWrap | single object where array-of-objects expected | wrap `[obj]` if it passes `items` |
+| 6 | bareScalarWrap | bare scalar where array expected | wrap `[v]` if it passes `items` |
+| 7 | emptyObjectPlaceholder | `{}` placeholder where scalar expected | delete if optional (default applies); else bounce |
+| 8 | numberFromString | `"42"` where number expected | `Number(s)` if finite |
+| 9 | boolFromString | `"true"`/`"false"` where bool expected | exact map (never truthiness) |
+| 10 | enumCaseNormalize | case/space enum variant | match to the one member, else bounce |
+| 11 | propertyCaseNormalize | root argument key casing differs from schema casing | rename to the schema key when unique |
+| 12 | singleElementUnwrap | `[v]` where scalar expected | unwrap if 1 elem and checks |
+| 13 | stringifiedNumberInArray | `["1","2"]` where number[] expected | map Number if all finite |
+| 14 | bashCommandArgvJoin | bash `command` sent as an argv list | join string values with spaces |
+| 15 | bashCommandUnwrap | bash `command` sent as a single-key object wrapper | unwrap the string-valued wrapper |
 
 Every entry is a NAMED registry entry
 `{name, errorSignature, transform, guard, noteTemplate}` — one table powers

package/dist/bundled-resources/skills/tool-call-repair/references/failure-grammar.md

@@ -18,15 +18,17 @@ is in its parent's `required`; `def(P)` = P has a schema `default`.
 |---|---|---|---|---|---|---|
 | 1 | nullOptionalDrop | type mismatch at P | `null`, `!req(P)` | delete key P | always (absence is valid for optional) | "sent null for optional `P` → omit the field instead" |
 | 1b | nullRequiredBounce | type mismatch at P | `null`, `req(P)`, `!def(P)` | none | never (bounce) | "`P` is required and cannot be null → send a real value" |
-| 2 | jsonStringParse | expect array\|object at P, got string | `"[...]"`/`"{...}"` | `JSON.parse(s)` | parsed matches expect(P) AND sub-checks | "sent `P` as a quoted JSON string → send a raw JSON array/object" |
+| 2 | jsonStringParse | expect array\|object at P, got string | `"[...]"`/`"{...}"`, including text-protocol smart-quote delimiter drift | `JSON.parse(s)`; if strict parse fails, normalize `“`/`”` delimiters and the observed missing object-key quote pattern, then parse | parsed matches expect(P) AND sub-checks | "sent `P` as a quoted JSON string → send a raw JSON array/object" |
+| 2b | jsonObjectPropertySalvage | expect object at P, got malformed object string | e.g. `{"path":"x" extra:1000}` | extract schema-declared JSON literal property values into a new object | each declared property appears at most once, no undeclared value is kept, and whole-object Check passes | "sent `P` as malformed JSON with recoverable declared properties → keep the schema-declared properties" |
 | 3 | singleObjectWrap | expect array at P, got object | `{...}` | `[obj]` | `[obj]` passes `items(P)` | "sent one object where `P` takes a list → wrap it in `[ ]`" |
 | 4 | bareScalarWrap | expect array at P, got scalar | string/number/bool | `[v]` | `[v]` passes `items(P)` | "sent a single value where `P` takes a list → wrap it in `[ ]`" |
 | 5 | emptyObjectPlaceholder | expect scalar at P (or array whose `items` reject `{}`), got object | `{}` | delete key P | `!req(P)` (schema default applies) else bounce | "sent `{}` as a placeholder → omit `P`; its default applies" |
 | 6 | numberFromString | expect number/integer at P, got string | `"42"`, numeric | `Number(s)` | finite (and integer if integer(P)) | "sent `P` as a quoted number → send a bare number" |
 | 7 | boolFromString | expect boolean at P, got string | `"true"`/`"false"` | `s === "true"` | exact match only (never truthiness) | "sent `P` as a quoted boolean → send bare true/false" |
 | 8 | enumCaseNormalize | expect enum at P, got string not in set | case/space variant | match case-insensitively/trimmed to one enum member | exactly one member matches | "`P` must be one of `a|b|c` → matched `<value>`" |
-| 9 | singleElementUnwrap | expect scalar at P, got 1-elem array | `[v]` | `v` | `v` passes expect(P) AND `length===1` | "sent `P` as a 1-item list where a single value was expected → send the value" |
-| 10 | stringifiedNumberInArray | expect number[] at P, got string[] | `["1","2"]` | map `Number` | all finite | "list `P` holds quoted numbers → send bare numbers" |
+| 9 | propertyCaseNormalize | root object has key K whose casing differs from a declared schema property | e.g. `Path` for `path` | rename K to the schema key | exactly one declared root property matches case-insensitively and the canonical key is absent | "sent `P` with different property-key casing → use the schema key casing" |
+| 10 | singleElementUnwrap | expect scalar at P, got 1-elem array | `[v]` | `v` | `v` passes expect(P) AND `length===1` | "sent `P` as a 1-item list where a single value was expected → send the value" |
+| 11 | stringifiedNumberInArray | expect number[] at P, got string[] | `["1","2"]` | map `Number` | all finite | "list `P` holds quoted numbers → send bare numbers" |
 
 Rules that keep this deterministic and safe:
 - **Repairs never invent a value.** 5 relies on the schema `default`; nothing
@@ -34,13 +36,14 @@ Rules that keep this deterministic and safe:
 - **Guard is mandatory.** Every transform runs on a clone and is kept ONLY if
   it Checks against the sub-schema at P. A transform whose guard fails leaves
   args untouched and falls through to the next applicable mode, then bounce.
-- **Order within one path:** 2 (parse) → 8/6/7 (coerce scalar) → 3/4/10 (wrap)
-  → 9 (unwrap) → 5 (placeholder-drop) → 1 (null-drop). Parse before wrap so a
+- **Order within one path:** 2 (strict/quote-normalized parse) → 2b (declared-property salvage) → 8/6/7 (coerce scalar) → 3/4/11 (wrap)
+  → 10 (unwrap) → 5 (placeholder-drop) → 1 (null-drop). Parse before wrap so a
   stringified array becomes an array, not a wrapped string. Across paths:
-  instance-path order.
+  instance-path order. Root property-key casing repair runs before these per-path
+  transforms because required-property validator errors do not carry the misspelled key path.
 - **One re-Check.** After all per-path transforms, Check the whole args once.
   Pass → return repaired; fail → bounce. Never loop transforms.
-- Modes 6–10 are the increment past the original four; each is guard-gated so
+- Modes 2b and 6–11 are the increment past the original four; each is guard-gated so
   it can only ever turn an invalid call into a valid one, never change a
   valid call (the hot path never reaches them — see Performance).
 
@@ -104,10 +107,13 @@ The failure grammar only ever runs on ALREADY-FAILED calls. The hot path
    `validator.Check(args)` (cached compiled validator) and returns the SAME
    object — no clone, no walk, no grammar lookup. This is the ~99% path for
    strong models and it is unchanged from today's cost.
-2. **Repairs are O(errors), not O(schema).** The analyzer walks the
+2. **Repairs are bounded on the failed path.** The analyzer walks the
    validator's error list (already produced by the failed Check), not the
-   schema tree. Each error maps to at most a few candidate modes by a static
-   dispatch table keyed on `(expect, got)` — a Map lookup, not a scan.
+   schema tree; the exceptions are `propertyCaseNormalize` and
+   `jsonObjectPropertySalvage`, which scan only root object keys or declared
+   object properties after a failed Check. Each
+   path error maps to at most a few candidate modes by a static dispatch table
+   keyed on `(expect, got)` — a Map lookup, not a scan.
 3. **No per-call compilation.** errorSignature matchers are precompiled
    constants; note templates are format strings; the registry is built once
    at module load. Nothing in the repair path constructs a RegExp, compiles a

package/dist/bundled-resources/skills/tool-call-repair/references/text-protocol-grammar.md

@@ -54,11 +54,18 @@ pre-trained on other stacks' conventions.
 2. `<tool_call>{"name":"X","arguments":{...}}</tool_call>` (common OSS
    convention; `arguments` may itself be a JSON STRING — that is exactly
    R31 mode 2, handed straight to the repairer).
-3. Fenced block tagged `tool`/`tool_call`:
+3. Fenced block tagged `tool`/`tool_call`/`json`:
    ```` ```tool\n{"name":"X","arguments":{...}}\n``` ````
+4. XML function-call convention:
+   `<function name="X"><param name="k">value</param></function>`.
+   The scanner requires an explicit `</function>` close tag. Each `param`
+   becomes a string-valued argument; R31 owns string-to-number, string-to-bool,
+   and JSON-string coercion after parsing. Nested `<function>` bodies,
+   duplicate param names, or non-whitespace text inside the function body are
+   ambiguous and are refused rather than guessed.
 Everything else is prose. Ambiguous text is NEVER guessed into a call
-(doctrine: no heuristic soup). Unknown `tool-name` → not a call; it becomes a
-bounce with the "unknown tool" note listing valid names.
+(doctrine: no heuristic soup). Unknown `tool-name` → a text-protocol bounce with
+an "unknown tool" note listing valid names.
 
 ## 3. Schema -> primer projection (how the dictionary is generated)
 
@@ -135,7 +142,7 @@ string }` where:
 
 The trial tool is `echo(data:string)` (harness-provided, side-effect-free).
 Calibration asks the model to `echo` a known token via the protocol and
-checks the parser round-trips it. Grammar variants tried on failure, in
-order: (a) restate header + one example; (b) drop to fenced-block variant 3
-if angle-bracket tags fail; (c) shrink the dictionary to the single tool
-under test. The variant that first round-trips is persisted per model (R46).
+checks the parser round-trips it. Grammar variants tried on failure are the
+parser's supported variants in deterministic order: canonical `<pi:call>`,
+`<tool_call>`, fenced JSON/tool blocks, then XML `<function>`. The variant that
+first round-trips is persisted per model (R46).

package/dist/core/agent-session.d.ts

@@ -28,8 +28,9 @@ import { type CurationProposals } from "./learning/skill-curator.ts";
 import type { MemoryProvider } from "./memory/memory-provider.ts";
 import { type ModelCapabilityProfile } from "./model-capability.ts";
 import type { ModelRegistry } from "./model-registry.ts";
+import { type NativeToolProbeGrade } from "./models/adaptation-store.ts";
 import type { StoredFitnessReport } from "./models/fitness-store.ts";
-import type { LocalRuntimeDeps, OllamaRuntime } from "./models/local-runtime.ts";
+import type { LocalRuntimeDeps, OllamaRuntime, TransformersRuntime } from "./models/local-runtime.ts";
 import { type PromptTemplate } from "./prompt-templates.ts";
 import type { ModelFitnessReport } from "./research/model-fitness.ts";
 import type { ResearchRunResult } from "./research/research-runner.ts";
@@ -203,6 +204,7 @@ export interface ToolProbeResult {
     model: string;
     verdict: ToolProbeVerdict;
     variant?: TextToolProtocolVariant;
+    nativeGrade?: NativeToolProbeGrade;
     diagnostic?: string;
 }
 export interface ToolProbeReport {
@@ -374,6 +376,7 @@ export declare class AgentSession {
     private readonly _repairModeSessionCounts;
     private readonly _textProtocolParseFailures;
     private _textProtocolParseObservedThisTurn;
+    private _textProtocolValidationOutcomeThisTurn;
     /** Assembles the session's base system prompt from live session state (see
      * system-prompt-builder.ts); owns the paired _baseSystemPromptOptions. */
     private readonly _systemPromptBuilder;
@@ -507,8 +510,11 @@ export declare class AgentSession {
     private _textProtocolFlag;
     private _streamForToolProbe;
     private _textProtocolCalibrationContext;
-    private _messageHasEchoProbe;
-    private _runNativeToolProbeTrial;
+    private _messageHasToolCallWithStringArgument;
+    private _nativeToolProbeSystemPrompt;
+    private _runNativeReadTaskProbeTrial;
+    private _runNativeEchoToolProbeTrial;
+    private _gradeNativeToolCallingForModel;
     private _runTextProtocolTrial;
     private _calibrateTextToolProtocolForModel;
     private _ensureTextToolProtocolForActiveModel;
@@ -519,6 +525,7 @@ export declare class AgentSession {
     private _resolveToolProbeModels;
     probeToolCalling(target?: string): Promise<ToolProbeReport>;
     private _handleTextToolProtocolParse;
+    private _handleTextToolProtocolValidationOutcome;
     private _recordTextToolProtocolParseOutcomeFromLastAssistant;
     private _looksLikeTextToolProtocolAttempt;
     private _recordToolValidationBounce;
@@ -764,6 +771,7 @@ export declare class AgentSession {
      * untracked child. Delegates to {@link LocalRuntimeController}.
      */
     getLocalRuntime(baseUrl?: string): OllamaRuntime;
+    getTransformersRuntime(modelId: string, baseUrl?: string): TransformersRuntime;
     /** models.json registers a local model's baseUrl as `<server>/v1` (OpenAI-compat); the runtime's
      * own health/boot endpoints are on the Ollama-native server root. Delegates to
      * {@link LocalRuntimeController}; kept here for `_warnIfManualModelChoiceIsRisky`'s own use. */