steerable-agent-runtime 0.6.72__tar.gz → 0.6.74__tar.gz

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.72
+Version: 0.6.74
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 License: Apache-2.0
 Requires-Python: >=3.10

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.72"
+version = "0.6.74"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 license = { text = "Apache-2.0" }
 readme = "README.md"

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/__init__.py

@@ -246,6 +246,7 @@ from .skills import (
     matches_conditions,
     render_skill_catalog,
     select_catalog,
+    select_pinned_loadable,
     select_skills,
     skill_to_dict,
     skill_tool_descriptor,
@@ -503,6 +504,7 @@ __all__ = [
     "resolve_model_info",
     "rule_from_amendment",
     "select_catalog",
+    "select_pinned_loadable",
     "select_skills",
     "should_run_grounding_judge",
     "skill_to_dict",

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/antihallucination.py

@@ -459,6 +459,14 @@ class AntiHallucinationHooks(NoopHooks):
         self._route: DataNeedRoute | None = None
         self._retries = 0
         self._narrations = 0
+        #: The wall a narration round swallowed (first one wins). The loop
+        #: reports ``completed`` once the narration round answers, which the
+        #: host would otherwise read as "the model decided it was done".
+        self._wall_status: str | None = None
+
+    def wall_status(self) -> str | None:
+        """Pre-wrap-up terminal status, for the host's completion mapping."""
+        return self._wall_status
 
     # -- pre_step: data-need routing → tool_choice on the first round ------
 
@@ -535,6 +543,11 @@ class AntiHallucinationHooks(NoopHooks):
             and draft.tool_calls_used > 0
         ):
             self._narrations += 1
+            # Remember the wall the narration is papering over — the loop
+            # reports ``completed`` after this round, and the host needs the
+            # original status to know the task did not actually finish.
+            if self._wall_status is None:
+                self._wall_status = draft.status
             return CompletionAction(
                 kind="narrate",
                 message=(

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/ask_user.py

@@ -131,11 +131,12 @@ def normalize_ask_user_questions(
 ) -> list[dict[str, Any]]:
     """Map known alias keys onto the canonical payload fields, enforce the
     Claude Code ``AskUserQuestion`` bounds (1-4 questions, 2-4 options per
-    select, ``header`` <=12 chars, ``multiSelect`` explicit), and require the
-    two fields the host card cannot render without (``id`` to key the answer,
-    ``text`` to label the control). A violation raises ``ToolDispatchError`` —
-    the router wraps it as the tool result, so the model sees exactly what to
-    fix and retries within the same turn."""
+    select, ``multiSelect`` explicit), and require the two fields the host
+    card cannot render without (``id`` to key the answer, ``text`` to label
+    the control). An over-long ``header`` is clipped to 12 characters so a
+    local model that ignores the cap still gets a card. Any other violation
+    raises ``ToolDispatchError`` — the router wraps it as the tool result, so
+    the model sees exactly what to fix and retries within the same turn."""
     if not isinstance(questions, list):
         raise ToolDispatchError(
             f"ask_user: questions must be an array, got {type(questions).__name__}"
@@ -166,8 +167,8 @@ def normalize_ask_user_questions(
                 f"ask_user: questions[{index}] is missing a non-empty string "
                 '"text" (the question label shown to the user).'
             )
-        # header: optional on the wire; validate length when present, derive
-        # from text when absent so the card always has a chip label.
+        # header: optional on the wire. Derive from text when absent, and
+        # clip an over-long label so the chip still fits.
         header = q.get("header")
         if header is None:
             q["header"] = _derive_header(q["text"])
@@ -176,10 +177,7 @@ def normalize_ask_user_questions(
                 f"ask_user: questions[{index}].header must be a non-empty string."
             )
         elif len(header) > _MAX_HEADER_LEN:
-            raise ToolDispatchError(
-                f"ask_user: questions[{index}].header is {len(header)} chars; "
-                f"the chip label must be <= {_MAX_HEADER_LEN}."
-            )
+            q["header"] = _derive_header(header)
         # multiSelect: CC requires the model to commit to single vs multi —
         # the field is required, so an omission is a model error to fix, not
         # a default to assume.
@@ -233,6 +231,23 @@ class AskUserHandler(Protocol):
     ) -> Awaitable[dict[str, Any]]: ...
 
 
+def _resolve_intro(intro: str | None, extra: dict[str, Any]) -> str:
+    """Return the framing line, accepting local-model key spellings.
+
+    Qwen often emits ``"intro questions"`` (a space, or an underscore) instead
+    of ``intro``. The published schema still requires ``intro``; this only
+    recovers a call that already arrived with the framing text under another
+    key.
+    """
+    if isinstance(intro, str) and intro.strip():
+        return intro.strip()
+    for key, value in extra.items():
+        folded = key.replace(" ", "_").replace("-", "_").lower()
+        if folded.startswith("intro") and isinstance(value, str) and value.strip():
+            return value.strip()
+    raise ToolDispatchError("ask_user: intro must be a non-empty string")
+
+
 def make_ask_user_tool(handler: AskUserHandler) -> Callable[..., Awaitable[dict[str, Any]]]:
     """Build the ``ask_user`` tool handler bound to ``handler``.
 
@@ -244,11 +259,17 @@ def make_ask_user_tool(handler: AskUserHandler) -> Callable[..., Awaitable[dict[
     """
 
     async def ask_user(
-        intro: str,
-        questions: list[dict[str, Any]],
+        intro: str | None = None,
+        questions: list[dict[str, Any]] | None = None,
         outro: str | None = None,
         context: dict[str, Any] | None = None,
+        **extra: Any,
     ) -> dict[str, Any]:
+        intro = _resolve_intro(intro, extra)
+        if not isinstance(questions, list):
+            raise ToolDispatchError(
+                "ask_user: questions must be an array of question objects."
+            )
         normalized = normalize_ask_user_questions(questions)
         answers = await _call_handler(handler, intro, normalized, context)
         return {

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/history.py

@@ -370,14 +370,18 @@ class SystemPromptFragment(ContextFragment):
 
     role: LLMRole = "system"
     content_kind: str = "system_prompt"
-    max_tokens: int | None = 4096
+    #: Align the system-prompt backstop with the framework's absolute
+    #: per-fragment ceiling. Desktop prompts with pinned/eager skills (e.g.
+    #: word-master + ppt-master) legitimately reach ~6-8k tokens; the old
+    #: 4k cap silently truncated the very skill body the agent bound.
+    max_tokens: int | None = FRAGMENT_TOKEN_CEILING
     review_note: str | None = (
-        "Desktop production prompts (persona + eager skill layer + runtime "
-        "environment + tool reality check) measure 1-3k tokens; 4k is the "
-        "headroom for larger skill stacks, not the target. Crossings "
-        "degrade with a visible marker so an over-budget assembly is "
-        "discoverable in the transcript instead of silently inflating every "
-        "request."
+        "Desktop production prompts (persona + pinned/eager skill stack + "
+        "runtime environment + tool reality check) legitimately reach 6-8k "
+        "tokens when an agent pins large skills. Reusing the absolute "
+        "per-fragment ceiling (10k) keeps a bounded backstop without "
+        "truncating the bound skill body; crossings still degrade with a "
+        "visible marker."
     )
 
     def __init__(self, prompt: str) -> None:

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/hooks.py

@@ -340,6 +340,22 @@ class NoopHooks:
         """
         return result.success
 
+    def wall_status(self) -> str | None:
+        """Terminal status a ``before_completion`` wrap-up swallowed, or None.
+
+        ``before_completion`` may grant a *narration* round after the turn
+        already hit a wall (``failed`` / ``budget_exhausted``). That round
+        produces a natural-language summary, so the loop's own terminal
+        status becomes ``completed`` even though the task never finished —
+        and the host's auto-continue, which only resumes on
+        ``budget_exhausted``, reads ``completed`` as "the model decided it
+        was done" and stops. Returning the pre-wrap-up status lets the host
+        report (and resume) the wall instead of the laundered completion.
+
+        Default None: no wrap-up disguised a wall.
+        """
+        return None
+
 
 class ChainHooks:
     """Compose several hooks into one ``LoopHooks``.
@@ -507,3 +523,19 @@ class ChainHooks:
             if callable(judge) and not judge(result, call):
                 return False
         return True
+
+    def wall_status(self) -> str | None:
+        """First hook that recorded a wrap-up-swallowed wall wins.
+
+        AntiHallucinationHooks is the recorder today. Probed with
+        ``getattr`` like the other optional capabilities, so a chain of
+        product hooks that never wraps up answers None without needing the
+        method.
+        """
+        for hook in self._hooks:
+            probe = getattr(hook, "wall_status", None)
+            if callable(probe):
+                status = probe()
+                if status is not None:
+                    return status
+        return None

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/native_bridge.py

@@ -33,6 +33,7 @@ from steerable_agent_runtime.loop import (
 from steerable_agent_runtime.pseudo import (
     PseudoStreamStripper,
     extract_inline_tool_calls,
+    reply_text_from_call,
     split_trailing_high_surrogate,
 )
 from steerable_agent_runtime.replay import build_step_decision_event
@@ -316,7 +317,8 @@ async def _collect_stream(
         send("chunk", chunk={"finish_reason": cut_finish_reason})
     elif not tool_seen:
         recovered, _ = extract_inline_tool_calls("".join(raw_content))
-        for index, call in enumerate(recovered):
+        actionable = [call for call in recovered if reply_text_from_call(call) is None]
+        for index, call in enumerate(actionable):
             send(
                 "chunk",
                 chunk={

{steerable_agent_runtime-0.6.72 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/pseudo.py

@@ -7,6 +7,9 @@ regress into prose) emit tool *intent* as text instead of a structured
 - MiniMax XML:      ``<invoke name="tool"><parameter name="k">v</parameter></invoke>``
 - DeepSeek XML:     ``<function=tool><parameter=k>v</parameter></function>``
 - Markdown pseudo:  ``[Tool call: NAME]\\n{"k": "v"}``
+- JSON tool object: a fenced or ``<tool_call>`` ``{"name", "arguments"}``
+  object (Qwen / Ollama), or a message that is only that object.
+  ``{"name": "text", "arguments": {"value": "..."}}`` is a reply, not a tool.
 
 If the loop treated that text as a final answer it would end the turn having
 never run the tool — the model "meant" to act but the loop stopped. This module
@@ -53,6 +56,27 @@ _PSEUDO_TOOL_CALL_HEADER_RE = re.compile(
     re.IGNORECASE,
 )
 
+# --- JSON tool objects (Qwen / Ollama) --------------------------------------
+#
+# Small local models often answer with a markdown fence (or a <tool_call>
+# wrapper, or a message that is only the object) instead of a structured
+# tool_calls block:
+#
+#   ```json
+#   {"name": "ask_user", "arguments": {"intro": "..."}}
+#   ```
+#
+# Only a payload whose every element is {name, arguments} is a call. A fenced
+# config or a JSON object mentioned inside a sentence stays text.
+
+_TOOL_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_FENCE_RE = re.compile(r"```[^\n`]*\n?(.*?)```", re.DOTALL)
+_TOOL_CALL_BLOCK_RE = re.compile(
+    r"<tool_call>\s*(.*?)\s*</tool_call>",
+    re.DOTALL | re.IGNORECASE,
+)
+_FENCE_HOLD_CAP = 8192
+
 
 def _scan_balanced_json_object(text: str, start: int) -> tuple[str, int] | None:
     """Find the next ``{...}`` JSON object starting at/after ``start``.
@@ -151,6 +175,9 @@ def extract_inline_tool_calls(text: str) -> tuple[list[dict[str, Any]], str]:
         cursor = end_idx
 
     if not results:
+        recovered = _extract_json_tool_calls(text)
+        if recovered is not None:
+            return recovered
         return [], text
 
     cleaned_segments.append(text[cursor:])
@@ -159,6 +186,128 @@ def extract_inline_tool_calls(text: str) -> tuple[list[dict[str, Any]], str]:
     return results, cleaned_text
 
 
+def _coerce_arguments(raw: Any) -> dict[str, Any] | None:
+    """Return a dict of tool arguments, parsing a JSON string when needed."""
+    if raw is None:
+        return {}
+    if isinstance(raw, str):
+        stripped = raw.strip()
+        if not stripped:
+            return {}
+        try:
+            raw = json.loads(stripped)
+        except json.JSONDecodeError:
+            return None
+    if isinstance(raw, dict):
+        return raw
+    return None
+
+
+_REPLY_TOOL_NAMES = frozenset({"text"})
+_REPLY_ARG_KEYS = ("value", "content", "text", "message")
+
+
+def reply_text_from_call(call: dict[str, Any]) -> str | None:
+    """Return the visible reply when a model wrapped plain text as a tool.
+
+    Some local models emit ``{"name": "text", "arguments": {"value": "..."}}``
+    instead of a message. ``None`` means the call is a real tool.
+
+    @param call: one ``{"name", "arguments"}`` object from inline recovery.
+    """
+    name = call.get("name")
+    if not isinstance(name, str) or name.strip().lower() not in _REPLY_TOOL_NAMES:
+        return None
+    arguments = call.get("arguments") or {}
+    if not isinstance(arguments, dict):
+        return ""
+    for key in _REPLY_ARG_KEYS:
+        value = arguments.get(key)
+        if isinstance(value, str):
+            return value
+    return ""
+
+
+def _calls_from_payload(payload: Any) -> list[dict[str, Any]] | None:
+    """Accept one tool-call object or a list of them. Anything else is text."""
+    items = payload if isinstance(payload, list) else [payload]
+    if not items:
+        return None
+    calls: list[dict[str, Any]] = []
+    for item in items:
+        if not isinstance(item, dict):
+            return None
+        name = item.get("name")
+        if not isinstance(name, str) or _TOOL_NAME_RE.fullmatch(name.strip()) is None:
+            return None
+        arguments = _coerce_arguments(item.get("arguments", {}))
+        if arguments is None:
+            return None
+        calls.append({"name": name.strip(), "arguments": arguments})
+    return calls
+
+
+def _parse_tool_call_blob(blob: str) -> list[dict[str, Any]] | None:
+    """Parse a tool-call JSON blob, unwrapping one surrounding fence."""
+    blob = blob.strip()
+    if not blob:
+        return None
+    fenced = _FENCE_RE.fullmatch(blob)
+    if fenced is not None:
+        blob = fenced.group(1).strip()
+        if not blob:
+            return None
+    try:
+        payload = json.loads(blob)
+    except json.JSONDecodeError:
+        return None
+    return _calls_from_payload(payload)
+
+
+def _extract_json_tool_calls(text: str) -> tuple[list[dict[str, Any]], str] | None:
+    """Recover fenced / ``<tool_call>`` / whole-message JSON tool calls.
+
+    Returns ``None`` when the text is not this format, so the caller can
+    leave it untouched.
+    """
+    results: list[dict[str, Any]] = []
+    spans: list[tuple[int, int]] = []
+
+    def take(match: re.Match[str], blob: str) -> None:
+        if any(match.start() < end and match.end() > start for start, end in spans):
+            return
+        calls = _parse_tool_call_blob(blob)
+        if not calls:
+            return
+        results.extend(calls)
+        spans.append(match.span())
+
+    for match in _TOOL_CALL_BLOCK_RE.finditer(text):
+        take(match, match.group(1))
+    for match in _FENCE_RE.finditer(text):
+        take(match, match.group(1))
+    if not results:
+        unclosed = re.search(r"```[^\n`]*\n(.*)\Z", text, re.DOTALL)
+        if unclosed is not None:
+            calls = _parse_tool_call_blob(unclosed.group(1))
+            if calls:
+                results.extend(calls)
+                spans.append(unclosed.span())
+    if not results:
+        stripped = text.strip()
+        if stripped[:1] in "{[":
+            calls = _parse_tool_call_blob(stripped)
+            if calls:
+                return calls, ""
+        return None
+
+    cleaned = text
+    for start, end in sorted(spans, reverse=True):
+        cleaned = cleaned[:start] + cleaned[end:]
+    cleaned = re.sub(r"\n{3,}", "\n\n", cleaned).strip()
+    return results, cleaned
+
+
 # ---------------------------------------------------------------------------
 # Streaming-time stripping (display path)
 # ---------------------------------------------------------------------------
@@ -378,8 +527,171 @@ class _MdCallFilter:
         return tail
 
 
+def _split_partial_backticks(buf: str) -> tuple[str, str]:
+    """Hold a trailing 1-2 backticks that may still become a fence opener."""
+    hold = 0
+    for char in reversed(buf):
+        if char != "`" or hold == 2:
+            break
+        hold += 1
+    if hold == 0:
+        return buf, ""
+    return buf[:-hold], buf[-hold:]
+
+
+def _opened_fence_body(held: str) -> str | None:
+    """Body of a span that starts with an opening fence.
+
+    ``held`` includes the closing fence when the span is complete. An
+    unclosed span returns the text after the language line.
+    """
+    if not held.startswith("```"):
+        return None
+    if held.endswith("```") and len(held) >= 6:
+        match = _FENCE_RE.fullmatch(held)
+        if match is None:
+            return None
+        return match.group(1)
+    rest = held[3:]
+    newline = rest.find("\n")
+    if newline < 0:
+        return rest
+    return rest[newline + 1 :]
+
+
+class _JsonFenceFilter:
+    """Hold a ``` fence and drop it only when the body is a tool-call object.
+
+    A code sample or a JSON config is released unchanged, including when the
+    fence never closes. A fence larger than ``_FENCE_HOLD_CAP`` is released
+    so a long code block is not stuck in the filter.
+    """
+
+    def __init__(self) -> None:
+        self._buf = ""
+        self._open = False
+        self._held = ""
+
+    def feed(self, chunk: str) -> str:
+        buf = self._buf + (chunk or "")
+        self._buf = ""
+        out: list[str] = []
+        while True:
+            if self._open:
+                close = buf.find("```")
+                if close < 0:
+                    self._held += buf
+                    if len(self._held) > _FENCE_HOLD_CAP:
+                        out.append(self._held)
+                        self._held = ""
+                        self._open = False
+                    break
+                self._held += buf[: close + 3]
+                buf = buf[close + 3 :]
+                released = self._release_held()
+                if released:
+                    out.append(released)
+                continue
+            opener = buf.find("```")
+            if opener >= 0:
+                if opener:
+                    out.append(buf[:opener])
+                buf = buf[opener + 3 :]
+                self._open = True
+                self._held = "```"
+                continue
+            emit, hold = _split_partial_backticks(buf)
+            if emit:
+                out.append(emit)
+            self._buf = hold
+            break
+        return "".join(out)
+
+    def _release_held(self) -> str:
+        held = self._held
+        self._held = ""
+        self._open = False
+        body = _opened_fence_body(held)
+        if body is not None and _parse_tool_call_blob(body):
+            return ""
+        return held
+
+    def flush(self) -> str:
+        if self._open:
+            self._held += self._buf
+            self._buf = ""
+            return self._release_held()
+        tail = self._buf
+        self._buf = ""
+        return tail
+
+
+class _BareToolJsonFilter:
+    """Hold a message that is only a tool-call JSON object.
+
+    A real tool object is dropped so recovery can execute it. A ``text``
+    reply object is replaced by its value. Any other leading ``{`` or ``[``
+    is released once it is clearly not that object.
+    """
+
+    def __init__(self) -> None:
+        self._buf = ""
+        self._passthrough = False
+
+    def feed(self, chunk: str) -> str:
+        if self._passthrough:
+            return chunk or ""
+        self._buf += chunk or ""
+        return self._decide(final=False)
+
+    def flush(self) -> str:
+        if self._passthrough:
+            return ""
+        return self._decide(final=True)
+
+    def _release(self, text: str) -> str:
+        self._passthrough = True
+        self._buf = ""
+        return text
+
+    def _decide(self, final: bool) -> str:
+        text = self._buf
+        stripped = text.lstrip()
+        if not stripped:
+            if final:
+                return self._release(text)
+            return ""
+        if stripped[0] not in "{[":
+            return self._release(text)
+        if len(text) > _FENCE_HOLD_CAP and not final:
+            return self._release(text)
+        try:
+            payload, end = json.JSONDecoder().raw_decode(stripped)
+        except json.JSONDecodeError as exc:
+            # An error at the end, or an open string, can still become JSON.
+            # `{not` and `[Tool call:` cannot, so they must stream immediately.
+            incomplete = exc.pos >= len(stripped) or "Unterminated" in exc.msg
+            if incomplete and not final and len(text) <= _FENCE_HOLD_CAP:
+                return ""
+            return self._release(text)
+        rest = stripped[end:]
+        if rest.strip():
+            return self._release(text)
+        calls = _calls_from_payload(payload)
+        if not calls:
+            return self._release(text)
+        if not final:
+            return ""
+        self._passthrough = True
+        self._buf = ""
+        replies = [reply_text_from_call(call) for call in calls]
+        if all(reply is not None for reply in replies):
+            return "".join(replies)
+        return ""
+
+
 class PseudoStreamStripper:
-    """Display-path filter chaining the fn-echo and markdown-call filters.
+    """Display-path filter chaining the fn-echo, JSON, and markdown filters.
 
     Usage: ``feed`` each raw content delta, emit what comes back; at stream
     end, ``flush`` once and emit the tail. Text held back to detect markers
@@ -388,10 +700,14 @@ class PseudoStreamStripper:
 
     def __init__(self) -> None:
         self._fn = _FnEchoFilter()
+        self._fence = _JsonFenceFilter()
+        self._bare = _BareToolJsonFilter()
         self._md = _MdCallFilter()
 
     def feed(self, chunk: str) -> str:
-        return self._md.feed(self._fn.feed(chunk))
+        return self._md.feed(self._bare.feed(self._fence.feed(self._fn.feed(chunk))))
 
     def flush(self) -> str:
-        return self._md.feed(self._fn.flush()) + self._md.flush()
+        fenced = self._fence.feed(self._fn.flush()) + self._fence.flush()
+        bare = self._bare.feed(fenced) + self._bare.flush()
+        return self._md.feed(bare) + self._md.flush()