Release 0.7.19 remove session sticky routing

Author: anjieyang

openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjieyang/uncommon-route",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "description": "OpenClaw plugin for UncommonRoute, the local LLM router that cuts premium-model spend",
   "type": "module",
   "main": "src/index.js",

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uncommon-route"
-version = "0.7.18"
+version = "0.7.19"
 description = "Local LLM router that cuts premium-model spend with adaptive 3-tier routing, OpenAI + Anthropic compatible"
 requires-python = ">=3.11"
 license = "MIT"

tests/test_proxy.py

@@ -973,7 +973,7 @@ def handler(request: httpx.Request) -> httpx.Response:
 
 
 class TestRoutingContinuity:
-    def test_agent_tool_session_locks_route_pool_to_previous_model(
+    def test_agent_tool_session_keeps_full_route_pool(
         self,
         monkeypatch: pytest.MonkeyPatch,
     ) -> None:
@@ -993,7 +993,7 @@ def fake_route(*_args, **kwargs) -> RoutingDecision:
                 mode=RoutingMode.AUTO,
                 confidence=0.9,
                 method="pool",
-                reasoning="sticky session route",
+                reasoning="session route",
                 cost_estimate=0.001,
                 baseline_cost=0.002,
                 savings=0.5,
@@ -1064,11 +1064,147 @@ def handler(request: httpx.Request) -> httpx.Response:
             )
 
             assert resp.status_code == 200
-            assert routed["available_models"] == ["anthropic/claude-opus-4-5"]
+            assert routed["available_models"] == [
+                "anthropic/claude-opus-4-5",
+                "anthropic/claude-sonnet-4-6",
+            ]
             assert captured["body"]["model"] == "anthropic/claude-opus-4-5"
             trace = traces.find(resp.headers["x-uncommon-route-request-id"])
             assert trace is not None
-            assert "session-sticky=previous-model=anthropic/claude-opus-4-5" in trace["route_reasoning"]
+            assert "session-sticky" not in trace["route_reasoning"]
+            assert "previous-model" not in trace["route_reasoning"]
+        finally:
+            asyncio.run(async_client.aclose())
+
+    def test_semantic_tool_failure_keeps_full_route_pool_and_records_failure(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        routed: dict[str, object] = {}
+        captured: dict[str, object] = {}
+
+        def fake_route(*_args, **kwargs) -> RoutingDecision:
+            available_models = list(kwargs.get("available_models") or [])
+            routed["available_models"] = available_models
+            selected_model = available_models[0]
+            return RoutingDecision(
+                model=selected_model,
+                tier=Tier.COMPLEX,
+                capability_lane=CapabilityLane.GENERAL,
+                served_quality=ServedQuality.PREMIUM,
+                served_quality_target=ServedQuality.PREMIUM,
+                served_quality_floor=ServedQuality.BALANCED,
+                continuity_quality_floor=kwargs["routing_features"].continuity_quality_floor,
+                mode=RoutingMode.AUTO,
+                confidence=0.8,
+                method="pool",
+                reasoning="semantic failure route",
+                cost_estimate=0.001,
+                baseline_cost=0.002,
+                savings=0.5,
+                routing_features=kwargs["routing_features"],
+            )
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            captured["body"] = json.loads(request.content.decode("utf-8"))
+            return httpx.Response(
+                200,
+                json={
+                    "id": "chatcmpl_semantic_retry",
+                    "object": "chat.completion",
+                    "created": 1,
+                    "model": captured["body"].get("model", "google/gemini-2.5-pro"),
+                    "choices": [{
+                        "index": 0,
+                        "message": {"role": "assistant", "content": "retrying"},
+                        "finish_reason": "stop",
+                    }],
+                    "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+                },
+                headers={"content-type": "application/json"},
+            )
+
+        traces = TraceStore(storage=InMemoryTraceStorage(), now_fn=lambda: 1.0)
+        traces.record(RequestTrace(
+            timestamp=1.0,
+            request_id="prev_req",
+            requested_model="uncommon-route/auto",
+            model="google/gemini-2.5-pro",
+            status_code=200,
+            api_format="openai",
+            endpoint="chat_completions",
+            is_virtual=True,
+            session_id="agent-session",
+            step_type="tool-result-followup",
+            transport="openai-chat",
+            served_quality="premium",
+        ))
+
+        async_client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+        monkeypatch.setattr("uncommon_route.proxy._get_client", lambda: async_client)
+        monkeypatch.setattr("uncommon_route.proxy.route", fake_route)
+
+        try:
+            app = create_app(
+                upstream="https://api.example.test/v1",
+                model_mapper=_build_test_mapper(
+                    "google/gemini-2.5-pro",
+                    "anthropic/claude-opus-4-6",
+                    "openai/gpt-5.4-2026-03-05",
+                ),
+                trace_store=traces,
+                spend_control=SpendControl(storage=InMemorySpendControlStorage()),
+            )
+            client = TestClient(app, raise_server_exceptions=False)
+            resp = client.post(
+                "/v1/chat/completions",
+                json={
+                    "model": "uncommon-route/auto",
+                    "messages": [
+                        {"role": "user", "content": "Run the tests and fix the bug."},
+                        {
+                            "role": "assistant",
+                            "tool_calls": [{
+                                "id": "call_1",
+                                "type": "function",
+                                "function": {
+                                    "name": "run_tests",
+                                    "arguments": json.dumps({"command": "pytest"}),
+                                },
+                            }],
+                        },
+                        {
+                            "role": "tool",
+                            "tool_call_id": "call_1",
+                            "content": (
+                                "pytest verification failed: 1 failed\n"
+                                "AssertionError: expected 2 actual 3\n"
+                                "<returncode>1</returncode>"
+                            ),
+                        },
+                    ],
+                    "tools": [{
+                        "type": "function",
+                        "function": {"name": "run_tests", "parameters": {"type": "object"}},
+                    }],
+                },
+                headers={"x-session-id": "agent-session"},
+            )
+
+            assert resp.status_code == 200
+            assert set(routed["available_models"]) == {
+                "google/gemini-2.5-pro",
+                "anthropic/claude-opus-4-6",
+                "openai/gpt-5.4-2026-03-05",
+            }
+            assert "google/gemini-2.5-pro" in routed["available_models"]
+            assert captured["body"]["model"] == routed["available_models"][0]
+            trace = traces.find(resp.headers["x-uncommon-route-request-id"])
+            assert trace is not None
+            assert "session-sticky" not in trace["route_reasoning"]
+            assert "session-retry" not in trace["route_reasoning"]
+            assert trace["routing_features_payload"]["verification_failed"] is True
+            assert trace["routing_features_payload"]["failure_kind"] == "semantic"
         finally:
             asyncio.run(async_client.aclose())
 

uncommon_route/proxy.py

@@ -2269,61 +2269,6 @@ def _merge_available_models(
     return merged
 
 
-def _latest_successful_session_model(
-    *,
-    session_id: str | None,
-    trace_store: TraceStore,
-    step_types: tuple[str, ...] = ("tool-selection", "tool-result-followup", "general"),
-) -> str | None:
-    previous_trace = trace_store.latest_for_session(
-        session_id,
-        step_types=step_types,
-    ) if session_id else None
-    if (
-        previous_trace is None
-        or previous_trace.status_code >= 400
-    ):
-        return None
-    previous_model = str(previous_trace.model or "").strip()
-    if not previous_model or _is_virtual_model_name(previous_model):
-        return None
-    return previous_model
-
-
-def _should_use_session_sticky_model(features: RoutingFeatures) -> bool:
-    if not features.session_present:
-        return False
-    if features.step_type in {"tool-selection", "tool-result-followup"}:
-        return True
-    if features.has_tool_results:
-        return True
-    if features.agent_step_count >= 2:
-        return True
-    return bool(features.is_agentic and (features.needs_tool_calling or features.is_coding))
-
-
-def _filter_session_sticky_context(
-    *,
-    available_models: list[str],
-    session_id: str | None,
-    routing_features: RoutingFeatures,
-    trace_store: TraceStore,
-) -> tuple[list[str], str]:
-    if len(available_models) <= 1:
-        return list(available_models), ""
-    if not _should_use_session_sticky_model(routing_features):
-        return list(available_models), ""
-    previous_model = _latest_successful_session_model(
-        session_id=session_id,
-        trace_store=trace_store,
-    )
-    if not previous_model:
-        return list(available_models), ""
-    if previous_model in available_models:
-        return [previous_model], f"session-sticky=previous-model={previous_model}"
-    return list(available_models), f"session-sticky=previous-unavailable={previous_model}"
-
-
 def _reuse_anthropic_source_body(
     *,
     source_body: dict[str, Any],
@@ -2481,6 +2426,8 @@ def _serialize_routing_features(features: RoutingFeatures) -> dict[str, object]:
         "capability_lane": features.capability_lane.value if features.capability_lane is not None else None,
         "previous_served_quality": features.previous_served_quality.value if features.previous_served_quality is not None else None,
         "continuity_quality_floor": features.continuity_quality_floor.value if features.continuity_quality_floor is not None else None,
+        "verification_failed": features.verification_failed,
+        "failure_kind": features.failure_kind,
         "tags": list(features.tags()),
     }
 
@@ -4118,7 +4065,6 @@ async def _handle_chat_core(
             hints = routing_features.workload_hints()
             step_type = routing_features.step_type
             user_keyed = _providers.keyed_models() or None
-            route_pool_notes: list[str] = []
             try:
                 base_available_models = _mapper.routable_models if _mapper.discovered else list(DEFAULT_MODEL_PRICING.keys())
                 if user_keyed:
@@ -4128,14 +4074,6 @@ async def _handle_chat_core(
                     scene_pool = _active_scene.model_pool()
                     available_scene_models = [m for m in scene_pool if m in route_available_models]
                     route_available_models = available_scene_models or scene_pool
-                route_available_models, session_sticky_note = _filter_session_sticky_context(
-                    available_models=route_available_models,
-                    session_id=session_id,
-                    routing_features=routing_features,
-                    trace_store=_traces,
-                )
-                if session_sticky_note:
-                    route_pool_notes.append(session_sticky_note)
 
                 if _active_scene and _active_scene.hard_pin:
                     from uncommon_route.router.types import (
@@ -4351,9 +4289,6 @@ async def _handle_chat_core(
                 )
             reasoning = decision.reasoning
             route_reasoning = decision.reasoning
-            if route_pool_notes:
-                route_reasoning = f"{route_reasoning} | {' | '.join(route_pool_notes)}"
-                reasoning = route_reasoning
             estimated_cost = decision.cost_estimate
             baseline_cost = decision.baseline_cost
             confidence = decision.confidence