@oneciel-ai/ciel-runtime 0.2.2 → 0.2.3

package/ciel_runtime_support/streaming_anthropic.py

@@ -10,6 +10,14 @@ from dataclasses import dataclass
 from http.server import BaseHTTPRequestHandler
 from typing import Any, Callable, Iterable
 
+from .runaway_output_guard import (
+    STOPPED,
+    RunawayOutputDetector,
+    RunawayVerdict,
+    policy_from_env,
+    recent_runaway_notices,
+)
+
 
 @dataclass(frozen=True, slots=True)
 class AnthropicStreamIO:
@@ -157,10 +165,19 @@ def rebatch_anthropic_sse_text(
         and (has_tool(source_body, "Workflow") or body_ultracode_runtime_enabled(source_body))
     )
     visible_tool_call_artifact_filters: dict[int, VisibleToolCallArtifactFilter] = {}
+    runaway_policy = policy_from_env(os.environ.get)
+    text_runaway = RunawayOutputDetector(runaway_policy)
+    thinking_runaway = RunawayOutputDetector(runaway_policy)
+    runaway_verdict: RunawayVerdict | None = None
 
     class ClientStreamDisconnected(Exception):
         pass
 
+    def note_runaway(detector: RunawayOutputDetector, text: str) -> None:
+        nonlocal runaway_verdict
+        if runaway_verdict is None:
+            runaway_verdict = detector.feed(text)
+
     def downstream_keepalive_interval() -> float:
         raw = os.environ.get("CIEL_RUNTIME_ANTHROPIC_STREAM_KEEPALIVE_SECONDS")
         if raw is None:
@@ -430,6 +447,44 @@ def rebatch_anthropic_sse_text(
             pending_message_stop[1] if pending_message_stop is not None else "{\"type\":\"message_stop\"}",
         )
 
+    def emit_runaway_stop() -> None:
+        """Close a looping turn instead of relaying the rest of the loop."""
+
+        nonlocal next_content_index
+        if runaway_verdict is None:
+            return
+        router_log(
+            "WARN",
+            f"anthropic_stream_runaway_repetition provider={provider} model={model} "
+            f"text_len={len(text_so_far)} {runaway_verdict.log_fields()}",
+        )
+        for index in sorted(open_content_blocks):
+            finish_visible_tool_call_artifact_filter(index)
+            emit_raw(
+                "content_block_stop",
+                json.dumps({"type": "content_block_stop", "index": index}, ensure_ascii=False),
+            )
+        open_content_blocks.clear()
+        notice_index = next_content_index
+        next_content_index += 1
+        emit_text_block(notice_index, runaway_verdict.notice(STOPPED))
+        stop_reason = "max_tokens"
+        if (
+            not emitted_tool_use
+            and runaway_policy.recover
+            and recent_runaway_notices(source_body) == 0
+        ):
+            # Cutting the loop should not cost the user the turn. A tool call
+            # brings the CLI back for a fresh one; the history check above stops
+            # the recovery from becoming a loop of its own.
+            router_log("WARN", f"anthropic_stream_runaway_recovery provider={provider} model={model}")
+            tool_index = next_content_index
+            next_content_index += 1
+            emit_tasklist_tool(tool_index)
+            stop_reason = "tool_use"
+        emit_raw("message_delta", patched_message_delta(stop_reason))
+        emit_raw("message_stop", "{\"type\":\"message_stop\"}")
+
     def recover_hidden_only_response_if_needed() -> None:
         nonlocal next_content_index, saw_tool_use, emitted_tool_use, text_so_far, pending_message_delta
         recovery_reason = ""
@@ -517,6 +572,7 @@ def rebatch_anthropic_sse_text(
         matched_name = resolve_emitted_tool_name(raw_name, source_body)
         if not matched_name:
             matched_name = infer_tool_name_from_args(parsed_args)
+        emitted_name = matched_name
         fixed_input = _validate_and_fix_tool_input(matched_name, parsed_args, source_body)
         if isinstance(source_body, dict):
             mapped_name, mapped_input = plan_mode_tool_name_for_emit(source_body, matched_name, fixed_input)
@@ -528,9 +584,12 @@ def rebatch_anthropic_sse_text(
                 return
             matched_name, fixed_input = mapped_name, mapped_input
         fixed_input = cap_mcp_notification_wait_tool_input(matched_name, fixed_input)
-        if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body):
+        # Plan mode can retarget the call at a different tool, and then the
+        # original arguments no longer describe the schema being checked.
+        supplied_input = parsed_args if matched_name == emitted_name else None
+        if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body, supplied_input):
             return
-        if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name):
+        if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name, source_body):
             return
         tool_id = str(tool_state.get("id") or f"toolu_anthropic_{int(time.time() * 1000)}_{index}")
         _remember_channel_injected_tool_use(source_body, tool_id, matched_name, fixed_input)
@@ -820,11 +879,14 @@ def rebatch_anthropic_sse_text(
                 patched["index"] = mapped_index
                 event = patched
                 data_str = json.dumps(event, ensure_ascii=False)
+            if delta.get("type") == "thinking_delta":
+                note_runaway(thinking_runaway, str(delta.get("thinking") or ""))
             if isinstance(mapped_index, int) and delta.get("type") == "text_delta":
                 text = delta.get("text") or ""
                 if not text:
                     return
                 text_so_far += text
+                note_runaway(text_runaway, text)
                 if provider != "anthropic" and mapped_index in held_pseudo_tool_text:
                     held_pseudo_tool_text[mapped_index] += text
                     return
@@ -882,6 +944,10 @@ def rebatch_anthropic_sse_text(
                     process_event(pending_event_type, data_str)
                 pending_event_type = None
                 pending_event_lines = []
+                if runaway_verdict is not None:
+                    # Stop reading upstream; the finally block closes the
+                    # response so the loop stops being generated and billed.
+                    break
                 continue
             if stripped.startswith("event:"):
                 pending_event_type = stripped[len("event:"):].strip() or None
@@ -896,6 +962,10 @@ def rebatch_anthropic_sse_text(
             flush_buffer(index, force=True)
         for index in list(suppressed_thinking_blocks.keys()):
             finish_suppressed_thinking_block(index)
+        if runaway_verdict is not None:
+            emit_runaway_stop()
+            stream_success = True
+            return
         recover_hidden_only_response_if_needed()
         flush_suppressed_thinking_passback()
         if pending_message_delta is not None or pending_message_stop is not None:
@@ -1007,6 +1077,7 @@ class OllamaToolProjection:
 @dataclass(frozen=True, slots=True)
 class OllamaContinuationPolicy:
     empty_end_turn_notice_for_body: Callable[..., Any]
+    reasoning_only_notice: Callable[..., Any]
     should_auto_continue_choice_question_with_tasklist: Callable[..., Any]
     should_auto_enter_plan_mode: Callable[..., Any]
     should_keep_work_alive_with_tasklist: Callable[..., Any]
@@ -1057,6 +1128,7 @@ def ollama_stream_to_anthropic_sse(
     should_drop_duplicate_side_effect_tool_call = services.tool_projection.should_drop_duplicate_side_effect_tool_call
     should_drop_emitted_tool_call = services.tool_projection.should_drop_emitted_tool_call
     empty_end_turn_notice_for_body = services.continuation.empty_end_turn_notice_for_body
+    reasoning_only_notice = services.continuation.reasoning_only_notice
     should_auto_continue_choice_question_with_tasklist = services.continuation.should_auto_continue_choice_question_with_tasklist
     should_auto_enter_plan_mode = services.continuation.should_auto_enter_plan_mode
     should_keep_work_alive_with_tasklist = services.continuation.should_keep_work_alive_with_tasklist
@@ -1068,11 +1140,16 @@ def ollama_stream_to_anthropic_sse(
     handler.end_headers()
     msg_id = f"msg_ollama_{int(time.time() * 1000)}"
     started = False
+    thinking_started = False
     text_started = False
     text_suppressed_for_plan = False
     next_content_index = 0
     text_index: int | None = None
     text_block_open = False
+    thinking_index: int | None = None
+    thinking_block_open = False
+    thinking_block_text = ""
+    thinking_so_far = ""
     text_so_far = ""
     text_buffer = ""
     tool_calls: list[dict[str, Any]] = []
@@ -1085,6 +1162,11 @@ def ollama_stream_to_anthropic_sse(
     last_activity_update = 0.0
     thinking_markup_filter = VisibleThinkingMarkupFilter()
     thinking_markup_suppressed = False
+    repeated_completed_tool_dropped = False
+    runaway_policy = policy_from_env(os.environ.get)
+    text_runaway = RunawayOutputDetector(runaway_policy)
+    thinking_runaway = RunawayOutputDetector(runaway_policy)
+    runaway_verdict: RunawayVerdict | None = None
     sse_trace = make_outgoing_sse_trace(provider, model, "ollama_stream", source_body)
     sse_trace_outcome = "started"
     sse_trace_error: str | None = None
@@ -1187,13 +1269,56 @@ def ollama_stream_to_anthropic_sse(
         emit("content_block_stop", {"type": "content_block_stop", "index": text_index})
         text_block_open = False
 
+    def open_thinking_block() -> int:
+        nonlocal next_content_index, thinking_block_open, thinking_block_text
+        nonlocal thinking_index, thinking_started
+        if thinking_block_open and thinking_index is not None:
+            return thinking_index
+        thinking_index = next_content_index
+        next_content_index += 1
+        thinking_started = True
+        thinking_block_open = True
+        thinking_block_text = ""
+        emit(
+            "content_block_start",
+            {
+                "type": "content_block_start",
+                "index": thinking_index,
+                "content_block": {"type": "thinking", "thinking": ""},
+            },
+        )
+        return thinking_index
+
+    def close_thinking_block() -> None:
+        nonlocal thinking_block_open
+        if not thinking_block_open or thinking_index is None:
+            return
+        digest = hashlib.sha256(
+            thinking_block_text.encode("utf-8", errors="replace")
+        ).hexdigest()[:24]
+        emit(
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": thinking_index,
+                "delta": {
+                    "type": "signature_delta",
+                    "signature": f"ciel-runtime-ollama-thinking-{digest}",
+                },
+            },
+        )
+        emit("content_block_stop", {"type": "content_block_stop", "index": thinking_index})
+        thinking_block_open = False
+
     def update_stream_activity(force: bool = False) -> None:
         nonlocal last_activity_update
         now = time.time()
         if not force and now - last_activity_update < 0.5:
             return
         last_activity_update = now
-        estimated_output = output_tokens or max(0, len(text_so_far) // 4)
+        estimated_output = output_tokens or max(
+            0, (len(thinking_so_far) + len(text_so_far)) // 4
+        )
         write_router_activity(
             "request",
             provider,
@@ -1205,9 +1330,12 @@ def ollama_stream_to_anthropic_sse(
         )
 
     def handle_text_chunk(text_chunk: str) -> None:
-        nonlocal text_buffer, text_so_far, text_suppressed_for_plan
+        nonlocal text_buffer, text_so_far, text_suppressed_for_plan, runaway_verdict
         if not text_chunk:
             return
+        if runaway_verdict is None:
+            runaway_verdict = text_runaway.feed(text_chunk)
+        close_thinking_block()
         if source_body is not None and not text_started and not tool_calls and should_auto_enter_plan_mode(source_body, text_so_far + text_chunk, []):
             text_so_far += text_chunk
             text_suppressed_for_plan = True
@@ -1257,6 +1385,26 @@ def ollama_stream_to_anthropic_sse(
             emit("content_block_delta", event)
         update_stream_activity()
 
+    def handle_thinking_chunk(thinking_chunk: str) -> None:
+        nonlocal thinking_block_text, thinking_so_far, runaway_verdict
+        if not thinking_chunk:
+            return
+        if runaway_verdict is None:
+            runaway_verdict = thinking_runaway.feed(thinking_chunk)
+        close_text_block()
+        active_thinking_index = open_thinking_block()
+        thinking_block_text += thinking_chunk
+        thinking_so_far += thinking_chunk
+        emit(
+            "content_block_delta",
+            {
+                "type": "content_block_delta",
+                "index": active_thinking_index,
+                "delta": {"type": "thinking_delta", "thinking": thinking_chunk},
+            },
+        )
+        update_stream_activity()
+
     try:
         for line in iter_upstream_lines_until_client_disconnect(handler, resp, idle_timeout):
             chunks_seen += 1
@@ -1274,6 +1422,8 @@ def ollama_stream_to_anthropic_sse(
             output_tokens = max(output_tokens, int(chunk.get("eval_count") or 0))
             if not started:
                 ensure_message_started()
+            # Native Ollama thinking is a distinct field, not visible answer text.
+            handle_thinking_chunk(str(message.get("thinking") or ""))
             # Handle text content
             raw_text_chunk = str(message.get("content") or "")
             text_chunk = thinking_markup_filter.feed(raw_text_chunk)
@@ -1290,16 +1440,20 @@ def ollama_stream_to_anthropic_sse(
                 matched_name = resolve_emitted_tool_name(raw_name, source_body)
                 raw_args = fn.get("arguments")
                 normalized_args = normalize_tool_arguments(matched_name, raw_args)
+                emitted_name = matched_name
                 fixed_input = _validate_and_fix_tool_input(matched_name, normalized_args)
                 if source_body is not None:
                     matched_name, fixed_input = plan_mode_tool_name_for_emit(source_body, matched_name, fixed_input)
                     if matched_name is None:
                         continue
                 fixed_input = cap_mcp_notification_wait_tool_input(matched_name, fixed_input)
-                if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body):
+                supplied_input = normalized_args if matched_name == emitted_name else None
+                if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body, supplied_input):
                     continue
-                if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name):
+                if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name, source_body):
+                    repeated_completed_tool_dropped = True
                     continue
+                close_thinking_block()
                 close_text_block()
                 tool_calls.append({"function": {"name": matched_name, "arguments": fixed_input}})
                 tool_id = f"toolu_ollama_{int(time.time() * 1000)}_{len(tool_calls) - 1}"
@@ -1322,14 +1476,37 @@ def ollama_stream_to_anthropic_sse(
                 emit_tool_block(tool_index, tool_id, matched_name, fixed_input)
                 update_stream_activity()
             update_stream_activity()
+            if runaway_verdict is not None:
+                # Stop reading upstream. The finally block closes the response,
+                # which ends generation instead of paying for the whole loop.
+                router_log(
+                    "WARN",
+                    f"ollama_stream_runaway_repetition provider={provider} model={model} "
+                    f"chunks={chunks_seen} {runaway_verdict.log_fields()}",
+                )
+                write_router_activity(
+                    "error", provider, model, error="runaway_repetition", stream=True
+                )
+                break
+        runaway_stopped = runaway_verdict is not None
         trailing_text = thinking_markup_filter.finish()
-        if trailing_text:
+        if trailing_text and not runaway_stopped:
             handle_text_chunk(trailing_text)
         if thinking_markup_suppressed:
             router_log("WARN", f"suppressed visible Ollama thinking markup from stream model={model}")
         update_stream_activity(force=True)
+        close_thinking_block()
+        if not runaway_stopped and repeated_completed_tool_dropped and not text_so_far.strip() and not tool_calls:
+            handle_text_chunk(
+                "[ciel-runtime] Stopped an identical completed tool call from repeating. "
+                "The previous result is already in context; choose a different action or finish the turn."
+            )
+        reasoning_only = thinking_started and not text_so_far.strip() and not tool_calls and not runaway_stopped
+        # A looping turn must not be continued for the model. Every synthesis
+        # below exists to keep work moving, which is the opposite of what a
+        # runaway needs, so they are all skipped once the guard has fired.
         # Flush any remaining buffered text when word-chunking is active
-        if source_body is not None and should_auto_enter_plan_mode(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and not reasoning_only and source_body is not None and should_auto_enter_plan_mode(source_body, text_so_far, tool_calls):
             ensure_message_started()
             close_text_block()
             router_log("WARN", "auto-synthesized EnterPlanMode from short/empty upstream stream")
@@ -1339,7 +1516,7 @@ def ollama_stream_to_anthropic_sse(
             next_content_index += 1
             tool_indices.append(tool_index)
             emit_tool_block(tool_index, tool_id, "EnterPlanMode", {})
-        elif source_body is not None and should_recover_empty_end_turn_with_tasklist(source_body, text_so_far, tool_calls):
+        elif not runaway_stopped and not reasoning_only and source_body is not None and should_recover_empty_end_turn_with_tasklist(source_body, text_so_far, tool_calls):
             ensure_message_started()
             close_text_block()
             router_log("WARN", "auto-synthesized TaskList from empty upstream end_turn stream")
@@ -1357,7 +1534,7 @@ def ollama_stream_to_anthropic_sse(
                 "delta": {"type": "text_delta", "text": text_so_far},
             }
             emit("content_block_delta", event)
-        if source_body is not None and should_keep_work_alive_with_tasklist(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and not reasoning_only and source_body is not None and should_keep_work_alive_with_tasklist(source_body, text_so_far, tool_calls):
             ensure_message_started()
             close_text_block()
             router_log("WARN", "auto-synthesized TaskList to keep work moving after tool result stream")
@@ -1367,7 +1544,7 @@ def ollama_stream_to_anthropic_sse(
             next_content_index += 1
             tool_indices.append(tool_index)
             emit_tool_block(tool_index, tool_id, "TaskList", {})
-        if source_body is not None and should_auto_continue_choice_question_with_tasklist(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and not reasoning_only and source_body is not None and should_auto_continue_choice_question_with_tasklist(source_body, text_so_far, tool_calls):
             ensure_message_started()
             close_text_block()
             router_log("WARN", "auto-synthesized TaskList after clarification question stream")
@@ -1388,7 +1565,41 @@ def ollama_stream_to_anthropic_sse(
             stopped_tool_indices.add(tool_index)
         if not started:
             ensure_message_started()
-        if not text_started and not tool_indices:
+        if runaway_stopped and runaway_verdict is not None:
+            notice = runaway_verdict.notice(STOPPED)
+            text_so_far += notice
+            notice_index = next_content_index
+            next_content_index += 1
+            emit_text_block(notice_index, notice)
+            # Cutting the loop should not cost the user the turn. Hand the agent
+            # a tool call so the CLI comes back for a fresh one -- unless a
+            # recent turn already carries this notice, which would mean the
+            # recovery itself is looping.
+            if (
+                not tool_calls
+                and runaway_policy.recover
+                and recent_runaway_notices(source_body) == 0
+            ):
+                router_log("WARN", f"ollama_stream_runaway_recovery provider={provider} model={model}")
+                tool_calls.append({"function": {"name": "TaskList", "arguments": {}}})
+                tool_id = f"toolu_ollama_runaway_{int(time.time() * 1000)}"
+                tool_index = next_content_index
+                next_content_index += 1
+                tool_indices.append(tool_index)
+                emit_tool_block(tool_index, tool_id, "TaskList", {})
+        elif reasoning_only:
+            router_log(
+                "WARN",
+                f"ollama_reasoning_only_stream provider={provider} model={model} "
+                f"chunks={chunks_seen} thinking_chars={len(thinking_so_far)} "
+                f"done_reason={str(chunk.get('done_reason') or '-')}",
+            )
+            notice = reasoning_only_notice(str(chunk.get("done_reason") or ""))
+            text_so_far = notice
+            notice_index = next_content_index
+            next_content_index += 1
+            emit_text_block(notice_index, notice)
+        elif not text_started and not tool_indices:
             router_log("WARN", f"ollama_empty_stream provider={provider} model={model} chunks={chunks_seen}")
             write_router_activity("error", provider, model, error="empty_stream", stream=True)
             empty_index = next_content_index
@@ -1401,6 +1612,10 @@ def ollama_stream_to_anthropic_sse(
         stop_reason = "tool_use" if tool_calls else "end_turn"
         if chunk.get("done_reason") == "length":
             stop_reason = "max_tokens"
+        if runaway_stopped and not tool_calls:
+            # No continuation was synthesized, so the turn really does end here
+            # with output the router truncated.
+            stop_reason = "max_tokens"
         # Send message_delta with final stop_reason
         event = {
             "type": "message_delta",
@@ -1411,13 +1626,14 @@ def ollama_stream_to_anthropic_sse(
         # Send message_stop
         emit("message_stop", {"type": "message_stop"})
         sse_trace_outcome = "success"
-        if text_started or tool_indices:
+        if thinking_started or text_started or tool_indices:
             write_router_activity(
                 "success",
                 provider,
                 model,
                 tokens=input_tokens,
-                output_tokens=output_tokens or max(1, len(text_so_far) // 4),
+                output_tokens=output_tokens
+                or max(1, (len(thinking_so_far) + len(text_so_far)) // 4),
                 chunks=chunks_seen,
                 stream=True,
             )
@@ -1429,7 +1645,8 @@ def ollama_stream_to_anthropic_sse(
         router_log(
             "WARN",
             f"ollama_stream_client_disconnected provider={provider} model={model} "
-            f"chunks={chunks_seen} text_len={len(text_so_far)} error={exc}",
+            f"chunks={chunks_seen} thinking_len={len(thinking_so_far)} "
+            f"text_len={len(text_so_far)} error={exc}",
         )
         write_router_activity(
             "cancel",
@@ -1437,7 +1654,8 @@ def ollama_stream_to_anthropic_sse(
             model,
             error=type(exc).__name__,
             tokens=input_tokens,
-            output_tokens=output_tokens or max(0, len(text_so_far) // 4),
+            output_tokens=output_tokens
+            or max(0, (len(thinking_so_far) + len(text_so_far)) // 4),
             chunks=chunks_seen,
             stream=True,
         )
@@ -1449,6 +1667,8 @@ def ollama_stream_to_anthropic_sse(
         write_router_activity("error", provider, model, error=type(exc).__name__, stream=True)
         try:
             ensure_message_started()
+            if thinking_block_open:
+                close_thinking_block()
             if text_block_open:
                 close_text_block()
             if not text_started and not tool_indices:
@@ -1594,9 +1814,17 @@ def forward_openai_chat_to_anthropic_sse(
     reasoning_so_far = ""
     tool_fragments: dict[int, dict[str, Any]] = {}
     output_tokens = 0
+    reported_input_tokens = max(0, int(input_tokens or 0))
+    cache_read_tokens = 0
+    cache_creation_tokens = 0
     finish_reason = "stop"
     chunks_seen = 0
     last_activity_update = 0.0
+    runaway_policy = policy_from_env(os.environ.get)
+    text_runaway = RunawayOutputDetector(runaway_policy)
+    reasoning_runaway = RunawayOutputDetector(runaway_policy)
+    runaway_verdict: RunawayVerdict | None = None
+    runaway_stopped = False
 
     def emit(event_name: str, payload: dict[str, Any]) -> None:
         handler.wfile.write(f"event: {event_name}\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n".encode())
@@ -1708,19 +1936,70 @@ def forward_openai_chat_to_anthropic_sse(
             usage = event.get("usage")
             if isinstance(usage, dict):
                 output_tokens = max(output_tokens, positive_int(usage.get("completion_tokens")) or 0)
+                prompt_tokens = positive_int(usage.get("prompt_tokens")) or 0
+                details = usage.get("prompt_tokens_details")
+                details = details if isinstance(details, dict) else {}
+                cache_read_tokens = max(
+                    cache_read_tokens,
+                    positive_int(usage.get("prompt_cache_hit_tokens"))
+                    or positive_int(usage.get("cache_read_input_tokens"))
+                    or positive_int(details.get("cached_tokens"))
+                    or 0,
+                )
+                cache_creation_tokens = max(
+                    cache_creation_tokens,
+                    positive_int(usage.get("cache_creation_input_tokens"))
+                    or positive_int(details.get("cache_write_tokens"))
+                    or 0,
+                )
+                if prompt_tokens:
+                    reported_input_tokens = max(
+                        0,
+                        prompt_tokens - cache_read_tokens - cache_creation_tokens,
+                    )
             choices = event.get("choices")
             if not isinstance(choices, list) or not choices:
                 continue
             choice = choices[0] if isinstance(choices[0], dict) else {}
+            choice_usage = choice.get("usage")
+            if isinstance(choice_usage, dict):
+                output_tokens = max(
+                    output_tokens,
+                    positive_int(choice_usage.get("completion_tokens")) or 0,
+                )
+                prompt_tokens = positive_int(choice_usage.get("prompt_tokens")) or 0
+                details = choice_usage.get("prompt_tokens_details")
+                details = details if isinstance(details, dict) else {}
+                cache_read_tokens = max(
+                    cache_read_tokens,
+                    positive_int(choice_usage.get("prompt_cache_hit_tokens"))
+                    or positive_int(choice_usage.get("cache_read_input_tokens"))
+                    or positive_int(details.get("cached_tokens"))
+                    or 0,
+                )
+                if prompt_tokens:
+                    reported_input_tokens = max(0, prompt_tokens - cache_read_tokens)
             if choice.get("finish_reason"):
                 finish_reason = str(choice.get("finish_reason"))
             delta = choice.get("delta") if isinstance(choice.get("delta"), dict) else {}
             reasoning_chunk = delta.get("reasoning_content") or ""
             if reasoning_chunk:
                 reasoning_so_far += str(reasoning_chunk)
+                runaway_verdict = runaway_verdict or reasoning_runaway.feed(str(reasoning_chunk))
                 emit_reasoning_delta(str(reasoning_chunk))
                 update_stream_activity()
             text_chunk = delta.get("content") or ""
+            if text_chunk:
+                runaway_verdict = runaway_verdict or text_runaway.feed(str(text_chunk))
+            if runaway_verdict is not None:
+                # Stop reading upstream; the finally block closes the response.
+                runaway_stopped = True
+                router_log(
+                    "WARN",
+                    f"openai_stream_runaway_repetition provider={provider} model={model} "
+                    f"chunks={chunks_seen} {runaway_verdict.log_fields()}",
+                )
+                break
             if text_chunk:
                 close_reasoning_block()
                 if pseudo_mode or PSEUDO_TOOL_START in text_chunk:
@@ -1800,15 +2079,17 @@ def forward_openai_chat_to_anthropic_sse(
                 continue
             matched_name = resolve_emitted_tool_name(raw_name, source_body)
             normalized_args = normalize_tool_arguments(matched_name, fragment.get("arguments") or {})
+            emitted_name = matched_name
             fixed_input = _validate_and_fix_tool_input(matched_name, normalized_args)
             if source_body is not None:
                 matched_name, fixed_input = plan_mode_tool_name_for_emit(source_body, matched_name, fixed_input)
                 if matched_name is None:
                     continue
             fixed_input = cap_mcp_notification_wait_tool_input(matched_name, fixed_input)
-            if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body):
+            supplied_input = normalized_args if matched_name == emitted_name else None
+            if should_drop_emitted_tool_call(matched_name, fixed_input, raw_name, source_body, supplied_input):
                 continue
-            if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name):
+            if should_drop_duplicate_side_effect_tool_call(matched_name, fixed_input, raw_name, source_body):
                 continue
             tool_calls.append({"function": {"name": matched_name, "arguments": fixed_input}})
             tool_index = next_content_index
@@ -1844,7 +2125,7 @@ def forward_openai_chat_to_anthropic_sse(
             )
             emit("content_block_stop", {"type": "content_block_stop", "index": tool_index})
 
-        if source_body is not None and should_auto_enter_plan_mode(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and source_body is not None and should_auto_enter_plan_mode(source_body, text_so_far, tool_calls):
             router_log("WARN", "auto-synthesized EnterPlanMode from short/empty upstream OpenAI stream")
             tool_index = next_content_index
             next_content_index += 1
@@ -1859,7 +2140,7 @@ def forward_openai_chat_to_anthropic_sse(
             )
             emit("content_block_delta", {"type": "content_block_delta", "index": tool_index, "delta": {"type": "input_json_delta", "partial_json": "{}"}})
             emit("content_block_stop", {"type": "content_block_stop", "index": tool_index})
-        elif source_body is not None and should_recover_empty_end_turn_with_tasklist(source_body, text_so_far, tool_calls):
+        elif not runaway_stopped and source_body is not None and should_recover_empty_end_turn_with_tasklist(source_body, text_so_far, tool_calls):
             router_log("WARN", "auto-synthesized TaskList from empty upstream end_turn OpenAI stream")
             tool_index = next_content_index
             next_content_index += 1
@@ -1877,7 +2158,7 @@ def forward_openai_chat_to_anthropic_sse(
         elif text_suppressed_for_plan and not text_started and text_so_far:
             emit_text_delta(text_so_far)
 
-        if source_body is not None and should_keep_work_alive_with_tasklist(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and source_body is not None and should_keep_work_alive_with_tasklist(source_body, text_so_far, tool_calls):
             router_log("WARN", "auto-synthesized TaskList to keep work moving after OpenAI stream")
             tool_index = next_content_index
             next_content_index += 1
@@ -1893,7 +2174,7 @@ def forward_openai_chat_to_anthropic_sse(
             emit("content_block_delta", {"type": "content_block_delta", "index": tool_index, "delta": {"type": "input_json_delta", "partial_json": "{}"}})
             emit("content_block_stop", {"type": "content_block_stop", "index": tool_index})
 
-        if source_body is not None and should_auto_continue_choice_question_with_tasklist(source_body, text_so_far, tool_calls):
+        if not runaway_stopped and source_body is not None and should_auto_continue_choice_question_with_tasklist(source_body, text_so_far, tool_calls):
             router_log("WARN", "auto-synthesized TaskList after clarification question OpenAI stream")
             tool_index = next_content_index
             next_content_index += 1
@@ -1909,10 +2190,40 @@ def forward_openai_chat_to_anthropic_sse(
             emit("content_block_delta", {"type": "content_block_delta", "index": tool_index, "delta": {"type": "input_json_delta", "partial_json": "{}"}})
             emit("content_block_stop", {"type": "content_block_stop", "index": tool_index})
 
+        if runaway_stopped and runaway_verdict is not None:
+            notice = ("\n\n" if text_started else "") + runaway_verdict.notice(STOPPED)
+            text_so_far += notice
+            emit_text_delta(notice)
         if text_started and text_index is not None:
             emit("content_block_stop", {"type": "content_block_stop", "index": text_index})
             text_stopped = True
-        if not text_started and not tool_calls:
+        if (
+            runaway_stopped
+            and not tool_calls
+            and runaway_policy.recover
+            and recent_runaway_notices(source_body) == 0
+        ):
+            # Give the agent another turn instead of ending on a cut-off answer.
+            router_log("WARN", f"openai_stream_runaway_recovery provider={provider} model={model}")
+            tool_index = next_content_index
+            next_content_index += 1
+            tool_calls.append({"function": {"name": "TaskList", "arguments": {}}})
+            emit(
+                "content_block_start",
+                {
+                    "type": "content_block_start",
+                    "index": tool_index,
+                    "content_block": {
+                        "type": "tool_use",
+                        "id": f"toolu_openai_runaway_{int(time.time() * 1000)}",
+                        "name": "TaskList",
+                        "input": {},
+                    },
+                },
+            )
+            emit("content_block_delta", {"type": "content_block_delta", "index": tool_index, "delta": {"type": "input_json_delta", "partial_json": "{}"}})
+            emit("content_block_stop", {"type": "content_block_stop", "index": tool_index})
+        if not runaway_stopped and not text_started and not tool_calls:
             text_so_far = empty_end_turn_notice_for_body(source_body) if source_body is not None else ""
             if source_body is not None:
                 router_log(
@@ -1925,7 +2236,33 @@ def forward_openai_chat_to_anthropic_sse(
                 emit("content_block_stop", {"type": "content_block_stop", "index": text_index})
                 text_stopped = True
         stop_reason = "tool_use" if tool_calls else ("max_tokens" if finish_reason == "length" else "end_turn")
-        write_anthropic_open_stream_stop(handler, {"stop_reason": stop_reason, "usage": {"output_tokens": output_tokens or max(1, len(text_so_far) // 4)}})
+        if runaway_stopped and not tool_calls:
+            # No continuation was synthesized, so the turn ends on truncated output.
+            stop_reason = "max_tokens"
+        final_output_tokens = output_tokens or max(1, len(text_so_far) // 4)
+        final_usage = {
+            "input_tokens": reported_input_tokens,
+            "output_tokens": final_output_tokens,
+        }
+        if cache_read_tokens:
+            final_usage["cache_read_input_tokens"] = cache_read_tokens
+        if cache_creation_tokens:
+            final_usage["cache_creation_input_tokens"] = cache_creation_tokens
+        write_anthropic_open_stream_stop(
+            handler,
+            {"stop_reason": stop_reason, "usage": final_usage},
+        )
+        write_router_activity(
+            "success",
+            provider,
+            model,
+            input_tokens=reported_input_tokens,
+            output_tokens=final_output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_creation_tokens=cache_creation_tokens,
+            chunks=chunks_seen,
+            stream=True,
+        )
         return True
     except Exception as exc:
         router_log("ERROR", f"openai_stream_error provider={provider} model={model} error={type(exc).__name__}: {exc}")