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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.73
+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.73 → steerable_agent_runtime-0.6.74}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.73"
+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.73 → 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.73 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime/pseudo.py

@@ -8,7 +8,8 @@ regress into prose) emit tool *intent* as text instead of a structured
 - 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
+  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
@@ -202,6 +203,31 @@ def _coerce_arguments(raw: Any) -> dict[str, Any] | None:
     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]
@@ -600,8 +626,72 @@ class _JsonFenceFilter:
         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, JSON-fence, and markdown 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
@@ -611,11 +701,13 @@ 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._fence.feed(self._fn.feed(chunk)))
+        return self._md.feed(self._bare.feed(self._fence.feed(self._fn.feed(chunk))))
 
     def flush(self) -> str:
-        mid = self._fence.feed(self._fn.flush()) + self._fence.flush()
-        return self._md.feed(mid) + 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()

{steerable_agent_runtime-0.6.73 → steerable_agent_runtime-0.6.74}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.73
+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.73 → steerable_agent_runtime-0.6.74}/tests/test_stream_strip.py

@@ -99,6 +99,25 @@ def test_stripper_keeps_a_fenced_config() -> None:
     assert _strip([text]) == text
 
 
+def test_stripper_shows_a_text_tool_as_the_reply() -> None:
+    # Local models wrap the answer as {"name":"text","arguments":{"value":...}}.
+    text = '{"name": "text", "arguments": {"value": "Hello, World!"}}'
+    assert _strip(['{"name": "te', 'xt", "arguments": {"value": "Hello, World!"}}']) == (
+        "Hello, World!"
+    )
+    assert _strip([text]) == "Hello, World!"
+
+
+def test_stripper_hides_a_bare_tool_object() -> None:
+    text = '{"name": "get_weather", "arguments": {"city": "Berlin"}}'
+    assert _strip([text[:12], text[12:]]) == ""
+
+
+def test_stripper_keeps_json_that_is_not_a_tool() -> None:
+    text = '{"host": "127.0.0.1"}'
+    assert _strip([text]) == text
+
+
 def test_stripper_holds_partial_opener_then_releases() -> None:
     # "[Tool" at a chunk end is held back; when the next chunk shows it was
     # NOT an opener, the held text is released.
@@ -241,6 +260,52 @@ async def test_loop_display_stream_strips_json_fence_but_recovers_call() -> None
     assert events[-1].data["status"] == "completed"
 
 
+@pytest.mark.asyncio
+async def test_loop_display_stream_shows_text_tool_as_reply() -> None:
+    # The whole message is a fake text tool. Show the value, do not call it.
+    payload = '{"name": "text", "arguments": {"value": "Hello, World!"}}'
+    provider = make_provider([{"content_pieces": [payload[:20], payload[20:]]}])
+    router = ToolRouter()
+    executed: list[str] = []
+
+    async def text(value: str) -> str:
+        executed.append(value)
+        return value
+
+    router.register(text)
+    loop = CoreLoop(provider, RouterToolExecutor(router))
+    events = await collect(loop.run([LLMMessage.text_of("user", "hello")]))
+
+    displayed = "".join(e.data["delta"] for e in events if e.kind == "content_delta")
+    assert displayed == "Hello, World!"
+    assert executed == []
+    assert events[-1].data["status"] == "completed"
+
+
+@pytest.mark.asyncio
+async def test_loop_display_stream_strips_bare_tool_json_but_recovers_call() -> None:
+    payload = '{"name": "get_weather", "arguments": {"city": "Berlin"}}'
+    provider = make_provider(
+        [{"content_pieces": [payload[:18], payload[18:]]}, {"content": "It is sunny."}]
+    )
+    router = ToolRouter()
+    executed: list[str] = []
+
+    async def get_weather(city: str) -> str:
+        executed.append(city)
+        return "sunny"
+
+    router.register(get_weather)
+    loop = CoreLoop(provider, RouterToolExecutor(router))
+    events = await collect(loop.run([LLMMessage.text_of("user", "weather?")]))
+
+    displayed = "".join(e.data["delta"] for e in events if e.kind == "content_delta")
+    assert "get_weather" not in displayed
+    assert "{" not in displayed.split("It is sunny.")[0]
+    assert "It is sunny." in displayed
+    assert executed == ["Berlin"]
+
+
 @pytest.mark.asyncio
 async def test_loop_display_stream_strips_echo_blocks() -> None:
     pieces = ["answer: ", "<function_results>{'fake': 1}</function_results>", " 42"]