steerable-agent-runtime 0.6.32__tar.gz → 0.6.34__tar.gz

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.32
+Version: 0.6.34
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.32"
+version = "0.6.34"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/__init__.py

@@ -131,6 +131,7 @@ from .hooks import (
     ChainHooks,
     CompletionAction,
     CompletionDraft,
+    DecisionNote,
     LoopHooks,
     NoopHooks,
     PreStepAction,
@@ -339,6 +340,7 @@ __all__ = [
     "ContextFragment",
     "ContextManager",
     "CoreLoop",
+    "DecisionNote",
     "ExecutionBudget",
     "FamilyTree",
     "FamilyTreeNode",

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/antihallucination.py

@@ -34,7 +34,13 @@ import re
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal, Sequence
 
-from .hooks import CompletionAction, CompletionDraft, NoopHooks, PreStepAction
+from .hooks import (
+    CompletionAction,
+    CompletionDraft,
+    DecisionNote,
+    NoopHooks,
+    PreStepAction,
+)
 
 if TYPE_CHECKING:
     from .llm import LLMMessage, LLMProvider
@@ -473,12 +479,22 @@ class AntiHallucinationHooks(NoopHooks):
         ):
             return PreStepAction(kind="proceed")
         self._route = await self._classify_route()
+        # Both branches record the verdict: the allow_no_tool turns are the
+        # denominator for how often routing forces a tool at all, and a run
+        # with no note at all means routing was skipped (plan mode, no tools,
+        # forcing disabled) rather than that it allowed a free turn.
+        note = DecisionNote(
+            action="data_need_route",
+            reason="anti-hallucination data-need routing",
+            value=self._route,
+        )
         if self._route == "require_tool":
             return PreStepAction(
                 kind="proceed",
                 tool_choice=self._config.force_tool_choice,
+                notes=(note,),
             )
-        return PreStepAction(kind="proceed")
+        return PreStepAction(kind="proceed", notes=(note,))
 
     async def _classify_route(self) -> DataNeedRoute:
         from .llm import LLMMessage

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/hooks.py

@@ -32,7 +32,7 @@ existing behavior.
 from __future__ import annotations
 
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Literal, Protocol, runtime_checkable
 
 from steerable_agent_protocol.generated import ToolCall, ToolResult
@@ -118,6 +118,26 @@ class RewriteRequest:
     bracket: CompactionBracket | None = None
 
 
+@dataclass(frozen=True, slots=True)
+class DecisionNote:
+    """A hook verdict the loop should record even though it changed nothing.
+
+    Verdicts that *act* are already visible as ``hook_action`` (a rewrite, an
+    append, a ``tool_choice``). The verdict that declined to act leaves no
+    trace, so a trajectory cannot distinguish "the data-need router allowed a
+    no-tool turn" from "routing never ran" — and that is exactly the
+    denominator a routing-variance measurement needs.
+
+    ``value`` carries the verdict itself (a route name, a chosen option) and
+    ``probability`` the backend's confidence when it reports one.
+    """
+
+    action: str
+    reason: str
+    value: str | None = None
+    probability: float | None = None
+
+
 @dataclass(slots=True)
 class PreStepAction:
     """Outcome of a ``pre_step`` hook.
@@ -131,6 +151,9 @@ class PreStepAction:
     this step's LLM call — the data-need router uses it to force a tool call
     on the first round of a data-seeking turn. Pass-through value, forwarded
     as a provider kwarg; providers that cannot honor it ignore it.
+
+    ``notes`` records verdicts that took no action, so a hook's decision rate
+    is measurable and not just its intervention rate.
     """
 
     kind: Literal["proceed", "reject"] = "proceed"
@@ -138,6 +161,7 @@ class PreStepAction:
     rewrite: RewriteRequest | None = None
     reason: str | None = None
     tool_choice: str | None = None
+    notes: tuple[DecisionNote, ...] = ()
     #: Label for the ``hook_action`` event when this action appended context
     #: (a rewrite is labelled by its own ``RewriteRequest.action``). Skill
     #: catalog injection owns ``"skill_catalog"``; the generic default is
@@ -327,6 +351,9 @@ class ChainHooks:
       after a rewrite fold into that rewrite — "hook1 rewrites, hook2
       appends" is exactly ``replace_all`` then ``append``. The first
       ``reject`` wins; the first non-``None`` ``tool_choice`` wins.
+      ``notes`` accumulate from every hook in order: a note describes a
+      decision instead of declaring one, so the hook that loses the
+      ``tool_choice`` must still have its verdict recorded.
     - ``post_tool_result``: the result threads through each hook in order.
     - ``on_request_error``: the first ``retry`` decision wins; if every hook
       says ``fail``, the first failure reason is surfaced.
@@ -356,10 +383,14 @@ class ChainHooks:
         appends: list[TranscriptAppend] = []
         append_action: str | None = None
         reason: str | None = None
+        notes: list[DecisionNote] = []
         for hook in self._hooks:
             action = await hook.pre_step(current, ctx)
+            notes.extend(action.notes)
             if action.kind == "reject":
-                return action
+                # A reject ends the turn, but the verdicts that preceded it
+                # still describe how the turn got there.
+                return replace(action, notes=tuple(notes))
             if action.rewrite is not None:
                 # The rewriter computed against the current projection, so
                 # its message list already contains any earlier appends.
@@ -391,6 +422,7 @@ class ChainHooks:
             reason=reason,
             tool_choice=tool_choice,
             append_action=append_action,
+            notes=tuple(notes),
         )
 
     async def compact_now(

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/llm/openai_compat.py

@@ -162,6 +162,19 @@ class OpenAICompatProvider:
     # Public API
     # ------------------------------------------------------------------
 
+    def honors_forced_tool_choice(self) -> bool:
+        """Whether ``tool_choice="required"`` reaches the wire unchanged.
+
+        ``_build_body`` downgrades it to ``auto`` for vendors that reject the
+        forced value, which makes a caller's gate a silent no-op. Callers that
+        record the gate (the loop's ``hook_action``) ask first so the trace
+        distinguishes a gate that held from one the vendor dropped.
+        """
+        compat = self.compat or OpenAICompatFlags()
+        return compat.supports_forced_tool_choice and not (
+            _thinking_rejects_forced_tool_choice(self.model, self.base_url)
+        )
+
     async def complete(
         self,
         messages: Sequence[LLMMessage],
@@ -385,16 +398,13 @@ class OpenAICompatProvider:
             for key, value in preset.extra_body.items():
                 if key not in body:
                     body[key] = value
-        # ``tool_choice=required`` downgrade paths:
-        #  - compat flag: vendors whose thinking mode 400s the forced value
-        #    (DeepSeek: "Thinking mode does not support this tool_choice");
-        #  - model-name paths host flags cannot cover: Z.AI GLM, OpenRouter
-        #    Qwen thinking, OpenRouter DeepSeek thinking. Harbor still logs
-        #    the hook; the wire must send auto or the trial dies on round 0
-        #    (failed-prev 33335200327, cheap-12 Qwen×steerable 34439098611).
-        if body.get("tool_choice") == "required" and (
-            not compat.supports_forced_tool_choice
-            or _thinking_rejects_forced_tool_choice(self.model, self.base_url)
+        # ``tool_choice=required`` downgrade (see honors_forced_tool_choice):
+        # the wire must send auto for these vendors or the trial dies on round
+        # 0 (failed-prev 33335200327, cheap-12 Qwen×steerable 34439098611).
+        # The caller's ``hook_action`` carries ``honored: false`` here, so a
+        # forced turn that the vendor dropped stays distinguishable in traces.
+        if body.get("tool_choice") == "required" and not (
+            self.honors_forced_tool_choice()
         ):
             body["tool_choice"] = "auto"
         # W6-8: clamp the requested reasoning effort to a level the model

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/loop.py

@@ -1184,6 +1184,22 @@ class CoreLoop:
                         "round": round_index,
                     },
                 )
+            # Verdicts that took no action. Without these a trace shows only
+            # the rounds a hook intervened in, which is a numerator with no
+            # denominator — "routing allowed a no-tool turn" and "routing
+            # never ran" look identical.
+            for note in pre.notes:
+                yield LoopEvent(
+                    "hook_action",
+                    {
+                        "hook": "pre_step",
+                        "action": note.action,
+                        "reason": note.reason,
+                        "value": note.value,
+                        "probability": note.probability,
+                        "round": round_index,
+                    },
+                )
             # ── manual compact: host-requested (agent.chat.compact, CC ────
             # ── /compact parity) ──
             # Consumed AFTER the regular pre_step pass, on the projection
@@ -1227,6 +1243,14 @@ class CoreLoop:
                         "hook": "pre_step",
                         "action": "tool_choice",
                         "value": step_tool_choice,
+                        # Several vendors downgrade ``required`` to ``auto`` on
+                        # the wire (Z.AI GLM, Qwen/DeepSeek thinking). Logging
+                        # the hook without this reads as a gate that held, so
+                        # every measurement over forced turns silently mixes
+                        # the models where the gate is a no-op.
+                        "honored": _honors_forced_tool_choice(
+                            self._provider, step_tool_choice
+                        ),
                         "round": round_index,
                     },
                 )
@@ -2459,6 +2483,20 @@ async def _safe_aclose(stream: Any) -> None:
         pass
 
 
+def _honors_forced_tool_choice(provider: LLMProvider, tool_choice: str) -> bool:
+    """Whether ``tool_choice`` survives to the wire on this provider.
+
+    Only ``required`` is ever downgraded, so any other value is honored by
+    definition. The capability is duck-typed like ``on_stream_chunk``: a
+    provider that does not publish ``honors_forced_tool_choice`` is taken at
+    its word, since the downgrade is a vendor quirk the adapter owns.
+    """
+    if tool_choice != "required":
+        return True
+    honors = getattr(provider, "honors_forced_tool_choice", None)
+    return bool(honors()) if callable(honors) else True
+
+
 def _apply_rewrite(manager: ContextManager, rewrite: RewriteRequest) -> None:
     """Apply one declared rewrite to the record.
 

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime/native_bridge.py

@@ -9,6 +9,7 @@ module is importable; ``STEERABLE_RUST_CORELOOP=0`` forces Python and
 from __future__ import annotations
 
 import asyncio
+import contextvars
 import json
 import logging
 import os
@@ -24,7 +25,13 @@ from steerable_agent_runtime.history import ContextManager
 from steerable_agent_runtime.llm import LLMMessage
 from steerable_agent_runtime.llm.errors import LLMError
 from steerable_agent_runtime.llm.parts import ImagePart, TextPart
-from steerable_agent_runtime.loop import CoreLoop, LoopContext, LoopEvent, _apply_rewrite
+from steerable_agent_runtime.loop import (
+    CoreLoop,
+    LoopContext,
+    LoopEvent,
+    _apply_rewrite,
+    _honors_forced_tool_choice,
+)
 from steerable_agent_runtime.pseudo import (
     PseudoStreamStripper,
     extract_inline_tool_calls,
@@ -403,6 +410,22 @@ async def _pre_step(
             else action.append_action or "append"
         ),
         "tool_choice": action.tool_choice,
+        # The Rust engine emits the tool_choice hook_action, but only the
+        # Python provider knows whether the vendor downgrades the forced value.
+        "tool_choice_honored": (
+            _honors_forced_tool_choice(loop._provider, action.tool_choice)
+            if action.tool_choice
+            else None
+        ),
+        "notes": [
+            {
+                "action": note.action,
+                "reason": note.reason,
+                "value": note.value,
+                "probability": note.probability,
+            }
+            for note in action.notes
+        ],
         "pre_tokens": (
             rewrite.pre_tokens if rewrite is not None else None
         ),
@@ -535,8 +558,26 @@ async def _sync_history(
     return json.dumps({"ok": True})
 
 
-def _await_on_loop(coro: Any, aio_loop: asyncio.AbstractEventLoop) -> str:
-    """Schedule ``coro`` on the running asyncio loop; block without holding the GIL."""
+def _await_on_loop(
+    coro: Any,
+    aio_loop: asyncio.AbstractEventLoop,
+    caller_context: contextvars.Context | None = None,
+) -> str:
+    """Schedule ``coro`` on the running asyncio loop; block without holding the GIL.
+
+    The callback runs under ``caller_context`` so it sees the ContextVars the
+    turn was started with. Rust drives these callbacks from its own thread,
+    whose context knows nothing the process set up earlier: without this the
+    task would copy that empty context and every ContextVar read would fall
+    back to its default, while the pure-Python loop — awaiting in the caller's
+    own task — reads the value. ``run_code`` binds its nested-tool router this
+    way, so the divergence surfaced as "no tool executor bound for nested
+    calls" on the native path only.
+
+    ``Task`` takes no ``context`` argument before 3.11, so the context is
+    applied one level up: ``call_soon_threadsafe`` runs ``start`` inside it and
+    ``create_task`` copies from there.
+    """
     box: queue.Queue[str] = queue.Queue()
 
     def start() -> None:
@@ -551,7 +592,7 @@ def _await_on_loop(coro: Any, aio_loop: asyncio.AbstractEventLoop) -> str:
 
         task.add_done_callback(done)
 
-    aio_loop.call_soon_threadsafe(start)
+    aio_loop.call_soon_threadsafe(start, context=caller_context)
     return box.get()
 
 
@@ -566,6 +607,9 @@ async def run_native(
     import steerable_agent_runtime_native as native
 
     aio_loop = asyncio.get_running_loop()
+    # Every Python callback below runs under this snapshot, so the Rust-driven
+    # path reads the same ContextVars the pure-Python loop would.
+    caller_context = contextvars.copy_context()
     out: asyncio.Queue[tuple[LoopEvent, threading.Event] | None] = asyncio.Queue()
     loop._run_context = LoopContext(chat_id=chat_id)
     loop._wrap_up_active = False
@@ -735,7 +779,7 @@ async def run_native(
 
             task.add_done_callback(done)
 
-        aio_loop.call_soon_threadsafe(start)
+        aio_loop.call_soon_threadsafe(start, context=caller_context)
         first_frame = output.get()
         first = json.loads(first_frame)
         if first.get("kind") == "error":
@@ -783,7 +827,7 @@ async def run_native(
 
             task.add_done_callback(done)
 
-        aio_loop.call_soon_threadsafe(start)
+        aio_loop.call_soon_threadsafe(start, context=caller_context)
         return box.get()
 
     def tool_concurrency_safe(call_json: str) -> bool:
@@ -810,6 +854,7 @@ async def run_native(
         return _await_on_loop(
             _sync_history(loop, manager, history_json, chat_id),
             aio_loop,
+            caller_context,
         )
 
     def sync_context(context_json: str) -> str:
@@ -848,17 +893,23 @@ async def run_native(
         return json.dumps({"ok": True})
 
     def before_completion(draft_json: str) -> str:
-        return _await_on_loop(_before_completion(loop, draft_json), aio_loop)
+        return _await_on_loop(
+            _before_completion(loop, draft_json), aio_loop, caller_context
+        )
 
     def post_tool_result(payload_json: str) -> str:
-        return _await_on_loop(_post_tool_result(loop, payload_json), aio_loop)
+        return _await_on_loop(
+            _post_tool_result(loop, payload_json), aio_loop, caller_context
+        )
 
     def pre_step(transcript_json: str) -> str:
-        return _await_on_loop(_pre_step(loop, manager, transcript_json), aio_loop)
+        return _await_on_loop(
+            _pre_step(loop, manager, transcript_json), aio_loop, caller_context
+        )
 
     def on_request_error(payload_json: str) -> str:
         return _await_on_loop(
-            _on_request_error(loop, manager, payload_json), aio_loop
+            _on_request_error(loop, manager, payload_json), aio_loop, caller_context
         )
 
     def wrap_up_may_drop_tools() -> bool:

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/src/steerable_agent_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.32
+Version: 0.6.34
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/tests/test_antihallucination.py

@@ -107,6 +107,15 @@ def final_completion(events: list[LoopEvent]) -> dict[str, Any]:
     return completions[-1].data
 
 
+def route_notes(events: list[LoopEvent]) -> list[tuple[str, str]]:
+    """``(action, value)`` of every recorded data-need routing verdict."""
+    return [
+        (e.data["action"], e.data["value"])
+        for e in events
+        if e.kind == "hook_action" and e.data.get("action") == "data_need_route"
+    ]
+
+
 def make_router_with_tool() -> ToolRouter:
     router = ToolRouter()
 
@@ -325,6 +334,13 @@ async def test_routing_require_tool_forces_tool_choice_on_first_call() -> None:
     # 第二轮起不再强制
     assert provider.stream_kwargs[1].get("tool_choice") is None
     assert final_completion(events)["status"] == "completed"
+    assert route_notes(events) == [("data_need_route", "require_tool")]
+    # 这个 fake provider 不声明 honors_forced_tool_choice，按"照实发送"处理。
+    forced = [
+        e for e in events
+        if e.kind == "hook_action" and e.data.get("action") == "tool_choice"
+    ]
+    assert [e.data["honored"] for e in forced] == [True]
 
 
 @pytest.mark.asyncio
@@ -341,6 +357,9 @@ async def test_routing_allow_no_tool_passes_through() -> None:
 
     assert provider.stream_kwargs[0].get("tool_choice") is None
     assert final_completion(events)["status"] == "completed"
+    # allow_no_tool 不改变这一步，但必须留痕：没有它，"路由放行"和"路由没跑"
+    # 在轨迹里长得一样，强制率就没有分母。
+    assert route_notes(events) == [("data_need_route", "allow_no_tool")]
 
 
 @pytest.mark.asyncio
@@ -353,8 +372,13 @@ async def test_routing_classification_error_falls_back_to_require_tool() -> None
         provider, AntiHallucinationConfig(user_question="查一下数值")
     )
     loop = CoreLoop(provider, RouterToolExecutor(make_router_with_tool()), hooks=hooks)
-    await collect(loop.run([LLMMessage.text_of("user", "查一下数值")], tools=TOOLS))
+    events = await collect(
+        loop.run([LLMMessage.text_of("user", "查一下数值")], tools=TOOLS)
+    )
     assert provider.stream_kwargs[0].get("tool_choice") == "required"
+    # 分类失败走保守回退，留痕与真判 require_tool 无法区分——这是有意的：
+    # 记录的是生效的裁决，不是它的来源。
+    assert route_notes(events) == [("data_need_route", "require_tool")]
 
 
 @pytest.mark.asyncio

steerable_agent_runtime-0.6.34/tests/test_native_default.py

@@ -0,0 +1,124 @@
+"""Rust CoreLoop is the default when the native binding is importable."""
+
+from __future__ import annotations
+
+import contextvars
+from collections.abc import AsyncIterator
+from typing import Any
+
+import pytest
+from steerable_agent_protocol.generated import ToolCall
+from steerable_agent_runtime import CoreLoop, RouterToolExecutor, ToolRouter, tool
+from steerable_agent_runtime.llm import LLMMessage, LLMStreamChunk
+from steerable_agent_runtime.native_bridge import native_available, uses_native_coreloop
+
+
+def test_uses_native_coreloop_follows_availability_when_unset(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("STEERABLE_RUST_CORELOOP", raising=False)
+    monkeypatch.setattr(
+        "steerable_agent_runtime.native_bridge.native_available",
+        lambda: True,
+    )
+    assert uses_native_coreloop() is True
+    monkeypatch.setattr(
+        "steerable_agent_runtime.native_bridge.native_available",
+        lambda: False,
+    )
+    assert uses_native_coreloop() is False
+
+
+def test_uses_native_coreloop_zero_forces_python(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("STEERABLE_RUST_CORELOOP", "0")
+    monkeypatch.setattr(
+        "steerable_agent_runtime.native_bridge.native_available",
+        lambda: True,
+    )
+    assert uses_native_coreloop() is False
+
+
+def test_uses_native_coreloop_one_forces_rust(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("STEERABLE_RUST_CORELOOP", "1")
+    monkeypatch.setattr(
+        "steerable_agent_runtime.native_bridge.native_available",
+        lambda: False,
+    )
+    assert uses_native_coreloop() is True
+
+
+#: Stand-in for the process-lifetime ContextVars callers bind around a turn —
+#: ``run_code`` keeps its nested-tool router in one.
+_ambient: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "test_ambient", default=None
+)
+
+
+def _provider_calling(name: str) -> Any:
+    class _FakeProvider:
+        name = "fake"
+        model = "fake-model"
+
+        def __init__(self) -> None:
+            self._idx = 0
+
+        async def complete(self, messages, *, tools=None, **kw):  # pragma: no cover
+            raise NotImplementedError
+
+        def stream(self, messages, *, tools=None, **kw) -> AsyncIterator[LLMStreamChunk]:
+            first = self._idx == 0
+            self._idx += 1
+
+            async def _gen() -> AsyncIterator[LLMStreamChunk]:
+                if first:
+                    yield LLMStreamChunk(
+                        tool_call_delta=ToolCall(id="c1", name=name, arguments={})
+                    )
+                    yield LLMStreamChunk(finish_reason="tool_calls")
+                else:
+                    yield LLMStreamChunk(content_delta="done")
+                    yield LLMStreamChunk(finish_reason="stop")
+
+            return _gen()
+
+    return _FakeProvider()
+
+
+@pytest.mark.skipif(
+    not native_available(), reason="the context bridge only applies to the Rust loop"
+)
+@pytest.mark.asyncio
+async def test_native_tool_execution_sees_the_callers_context_vars() -> None:
+    """Rust drives the Python callbacks from its own thread, so a task created
+    for them copies that thread's context, not the turn's. A tool that reads an
+    ambient ContextVar would then see the default while the pure-Python loop
+    sees the value — which is how ``run_code`` lost its nested-tool router.
+    """
+    router = ToolRouter()
+    seen: list[str | None] = []
+
+    @tool(router=router, name="peek", description="read the ambient var", mode="read")
+    async def peek() -> dict[str, Any]:
+        seen.append(_ambient.get())
+        return {"value": seen[-1]}
+
+    _ambient.set("bound-by-caller")
+    loop = CoreLoop(_provider_calling("peek"), RouterToolExecutor(router))
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "peek",
+                "description": "read",
+                "parameters": {"type": "object", "properties": {}},
+            },
+        }
+    ]
+    async for _event in loop.run([LLMMessage.text_of("user", "go")], tools=tools):
+        pass
+
+    assert seen == ["bound-by-caller"]

{steerable_agent_runtime-0.6.32 → steerable_agent_runtime-0.6.34}/tests/test_provider_compat.py

@@ -114,6 +114,27 @@ def test_forced_tool_choice_downgraded_when_flagged_off() -> None:
     assert body["tool_choice"] == "auto"
 
 
+def test_honors_forced_tool_choice_matches_the_downgrade() -> None:
+    """The probe callers record must agree with what the body actually sends.
+
+    Two sources downgrade: the compat flag and the model-name paths host
+    flags cannot cover (Z.AI GLM, Qwen/DeepSeek thinking over OpenRouter).
+    """
+    assert _provider().honors_forced_tool_choice() is True
+    assert (
+        _provider(
+            compat=OpenAICompatFlags(supports_forced_tool_choice=False)
+        ).honors_forced_tool_choice()
+        is False
+    )
+    assert (
+        _provider(
+            model="z-ai/glm-5", base_url="https://openrouter.ai/api/v1"
+        ).honors_forced_tool_choice()
+        is False
+    )
+
+
 def test_forced_tool_choice_kept_by_default() -> None:
     from steerable_agent_runtime.llm import LLMMessage
 

steerable_agent_runtime-0.6.32/tests/test_native_default.py

@@ -1,44 +0,0 @@
-"""Rust CoreLoop is the default when the native binding is importable."""
-
-from __future__ import annotations
-
-import pytest
-from steerable_agent_runtime.native_bridge import uses_native_coreloop
-
-
-def test_uses_native_coreloop_follows_availability_when_unset(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.delenv("STEERABLE_RUST_CORELOOP", raising=False)
-    monkeypatch.setattr(
-        "steerable_agent_runtime.native_bridge.native_available",
-        lambda: True,
-    )
-    assert uses_native_coreloop() is True
-    monkeypatch.setattr(
-        "steerable_agent_runtime.native_bridge.native_available",
-        lambda: False,
-    )
-    assert uses_native_coreloop() is False
-
-
-def test_uses_native_coreloop_zero_forces_python(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setenv("STEERABLE_RUST_CORELOOP", "0")
-    monkeypatch.setattr(
-        "steerable_agent_runtime.native_bridge.native_available",
-        lambda: True,
-    )
-    assert uses_native_coreloop() is False
-
-
-def test_uses_native_coreloop_one_forces_rust(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    monkeypatch.setenv("STEERABLE_RUST_CORELOOP", "1")
-    monkeypatch.setattr(
-        "steerable_agent_runtime.native_bridge.native_available",
-        lambda: False,
-    )
-    assert uses_native_coreloop() is True