Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)
Python
patch: Remove obsolete Task foreground interception (#1925)
Ali Khokhar8296b09ee7d8
diff --git a/smoke/capabilities.py b/smoke/capabilities.pyindex 957ce7a6..69a1fbbc 100644--- a/smoke/capabilities.py+++ b/smoke/capabilities.py@@ -285,10 +285,10 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("streaming_conversion","subagent_task_control","subagent_control",- "free_claude_code.core.anthropic.streaming.AnthropicStreamLedger",+ "free_claude_code.providers.openai_chat.tool_calls","Task tool call arguments",- "run_in_background=false",- "invalid JSON flushed as safe object",+ "arguments preserved with normal alias restoration",+ "ordinary tool validation and recovery",("tests/providers/test_subagent_interception.py",),),CapabilityContract(diff --git a/smoke/features.py b/smoke/features.pyindex f1919eeb..1df16014 100644--- a/smoke/features.py+++ b/smoke/features.py@@ -405,7 +405,7 @@ FEATURE_INVENTORY: tuple[FeatureCoverage, ...] = (),FeatureCoverage("subagent_control",- "Task-like tool output is rendered and controlled as foreground work",+ "Task arguments are preserved and tool output is rendered in transcripts",("tests/providers/test_subagent_interception.py",),(),("test_messaging_subagent_control_e2e",),diff --git a/src/free_claude_code/core/anthropic/streaming/ledger.py b/src/free_claude_code/core/anthropic/streaming/ledger.pyindex 77dd9d2b..4d6a7eae 100644--- a/src/free_claude_code/core/anthropic/streaming/ledger.py+++ b/src/free_claude_code/core/anthropic/streaming/ledger.py@@ -1,15 +1,11 @@"""Anthropic stream state ledger."""-import hashlib-import jsonimport uuidfrom collections.abc import Iterator, Mappingfrom contextlib import suppressfrom dataclasses import dataclass, fieldfrom typing import Any-from loguru import logger-from free_claude_code.core.token_estimation import estimate_text_tokensfrom .emitter import AnthropicSseEmitter@@ -32,8 +28,6 @@ class ToolBlockState:name: strextra_content: dict[str, Any] | None = Nonestarted: bool = False- task_arg_buffer: str = ""- task_args_emitted: bool = Falsepre_start_args: str = ""@@ -99,53 +93,6 @@ class StreamBlockLedger:elif not prev.startswith(name):state.name = prev + name- def buffer_task_args(self, index: int, args: str) -> dict[str, Any] | None:- state = self.tool_states.get(index)- if state is None or state.task_args_emitted:- return None-- state.task_arg_buffer += args- try:- args_json = json.loads(state.task_arg_buffer)- except Exception:- return None- if not isinstance(args_json, dict):- return None-- _normalize_task_run_in_background(args_json)- state.task_args_emitted = True- state.task_arg_buffer = ""- return args_json-- def flush_task_arg_buffers(self) -> list[tuple[int, str]]:- results: list[tuple[int, str]] = []- for tool_index, state in list(self.tool_states.items()):- if not state.task_arg_buffer or state.task_args_emitted:- continue-- out = "{}"- try:- args_json = json.loads(state.task_arg_buffer)- if isinstance(args_json, dict):- _normalize_task_run_in_background(args_json)- out = json.dumps(args_json)- except (json.JSONDecodeError, TypeError, ValueError) as exc:- digest = hashlib.sha256(- state.task_arg_buffer.encode("utf-8", errors="replace")- ).hexdigest()[:16]- logger.warning(- "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",- state.tool_id or "unknown",- len(state.task_arg_buffer),- digest,- exc,- )-- state.task_args_emitted = True- state.task_arg_buffer = ""- results.append((tool_index, out))- return results-class AnthropicStreamLedger:"""Own mutable Anthropic stream state and produce serialized SSE events."""@@ -531,8 +478,3 @@ class AnthropicStreamLedger:state.block_type == "thinking" and self.blocks.thinking_index == state.index):self.blocks.thinking_started = False---def _normalize_task_run_in_background(args_json: dict[str, Any]) -> None:- if args_json.get("run_in_background") is not False:- args_json["run_in_background"] = Falsediff --git a/src/free_claude_code/providers/openai_chat/stream_output.py b/src/free_claude_code/providers/openai_chat/stream_output.pyindex 1b98d0d0..86ad9ed1 100644--- a/src/free_claude_code/providers/openai_chat/stream_output.py+++ b/src/free_claude_code/providers/openai_chat/stream_output.py@@ -1,6 +1,5 @@"""Chat-source output writers for Anthropic Messages and OpenAI Responses."""-import hashlibimport jsonimport timeimport uuid@@ -8,8 +7,6 @@ from abc import ABC, abstractmethodfrom collections.abc import Callable, Iterator, Mappingfrom dataclasses import dataclass, field-from loguru import logger-from free_claude_code.core.anthropic.streaming import (AnthropicStreamLedger,ToolSchema,@@ -65,8 +62,6 @@ class ChatToolState:extra_content: JsonObject | None = Nonestarted: bool = Falseopen: bool = False- task_arg_buffer: str = ""- task_args_emitted: bool = Falsepre_start_args: str = ""argument_parts: list[str] = field(default_factory=list)@@ -259,51 +254,6 @@ class ChatStreamOutput(ABC):for state in states)- def buffer_task_args(- self, tool_index: int, arguments: str- ) -> dict[str, object] | None:- state = self.tool_states.get(tool_index)- if state is None or state.task_args_emitted:- return None- state.task_arg_buffer += arguments- try:- parsed = json.loads(state.task_arg_buffer)- except json.JSONDecodeError:- return None- if not isinstance(parsed, dict):- return None- _normalize_task_args(parsed)- state.task_args_emitted = True- state.task_arg_buffer = ""- return parsed-- def flush_task_arg_buffers(self) -> list[tuple[int, str]]:- results: list[tuple[int, str]] = []- for tool_index, state in self.tool_states.items():- if not state.task_arg_buffer or state.task_args_emitted:- continue- output = "{}"- try:- parsed = json.loads(state.task_arg_buffer)- if isinstance(parsed, dict):- _normalize_task_args(parsed)- output = json.dumps(parsed)- except (json.JSONDecodeError, TypeError, ValueError) as exc:- digest = hashlib.sha256(- state.task_arg_buffer.encode("utf-8", errors="replace")- ).hexdigest()[:16]- logger.warning(- "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",- state.tool_id or "unknown",- len(state.task_arg_buffer),- digest,- exc,- )- state.task_args_emitted = True- state.task_arg_buffer = ""- results.append((tool_index, output))- return results-def estimate_output_tokens(self) -> int:tool_tokens = sum(estimate_text_tokens(state.name) + estimate_text_tokens(state.content) + 15@@ -745,8 +695,3 @@ def _responses_usage(usage: ChatStreamUsage) -> dict[str, object]:"output_tokens_details": {"reasoning_tokens": reasoning_tokens},"total_tokens": usage.input_tokens + usage.output_tokens,}---def _normalize_task_args(arguments: dict[str, object]) -> None:- if arguments.get("run_in_background") is not False:- arguments["run_in_background"] = Falsediff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.pyindex 498d0ea8..363f4b3f 100644--- a/src/free_claude_code/providers/openai_chat/tool_calls.py+++ b/src/free_claude_code/providers/openai_chat/tool_calls.py@@ -129,10 +129,6 @@ def iter_heuristic_tool_use_events(decoded_name = tool_names.decode(name)if decoded_name != name:tool_use = {**tool_use, "name": decoded_name}- if tool_use.get("name") == "Task" and isinstance(tool_use.get("input"), dict):- task_input = tool_use["input"]- if task_input.get("run_in_background") is not False:- task_input["run_in_background"] = Falseyield from output.close_content_blocks()tool_index = len(output.tool_states)output.ensure_tool_state(tool_index)@@ -299,11 +295,6 @@ class OpenAIToolCallAssembler:self._public_tool_ids[tool_index] = public_idreturn public_id- def flush_task_arg_buffers(self, output: ChatStreamOutput) -> Iterator[str]:- """Emit buffered Task args as a single JSON delta."""- for tool_index, out in output.flush_task_arg_buffers():- yield output.emit_tool_delta(tool_index, out)-def flush_tool_name_buffers(self,output: ChatStreamOutput,@@ -339,7 +330,7 @@ class OpenAIToolCallAssembler:tool_argument_alias_buffers.pop(tool_index, None)continuestate = output.tool_states.get(tool_index)- if state is None or state.name == "Task":+ if state is None:continuealiases = tool_argument_aliases.get(state.name, {})if not aliases:@@ -366,11 +357,6 @@ class OpenAIToolCallAssembler:state = output.tool_states.get(tc_index)if state is None:return- if state.name == "Task":- parsed = output.buffer_task_args(tc_index, args)- if parsed is not None:- yield output.emit_tool_delta(tc_index, json.dumps(parsed))- returnaliases = (tool_argument_aliases.get(state.name, {}) if tool_argument_aliases else {})diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex c164f24a..112fdb26 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -488,7 +488,6 @@ class _OpenAIChatStreamAssembler:self._tool_argument_aliases,self._tool_argument_alias_buffers,)- yield from self._tool_calls.flush_task_arg_buffers(self._output)yield from self._output.close_all_blocks()completion = usage_int(self._usage_info, "completion_tokens")@@ -1552,8 +1551,6 @@ class _OpenAIChatStreamRunner:block = output.tool_block_for_tool_index(tool_index)emitted_prefix = block.content if block is not None else ""repair_prefix = emitted_prefix- if not repair_prefix and state.name == "Task" and state.task_arg_buffer:- repair_prefix = state.task_arg_bufferif not repair_prefix and tool_index in tool_argument_alias_buffers:repair_prefix = tool_argument_alias_buffers[tool_index]if (diff --git a/tests/contracts/test_stream_contracts.py b/tests/contracts/test_stream_contracts.pyindex 4c164558..0b4a7d8e 100644--- a/tests/contracts/test_stream_contracts.py+++ b/tests/contracts/test_stream_contracts.py@@ -116,7 +116,7 @@ def test_enable_thinking_false_suppresses_reasoning_only() -> None:assert text_content(events) == "hello world"-def test_task_tool_arguments_force_foreground_execution() -> None:+def test_task_tool_parser_preserves_background_argument() -> None:parser = HeuristicToolParser()filtered, detected = parser.feed("● <function=Task><parameter=description>Inspect</parameter>"@@ -126,9 +126,7 @@ def test_task_tool_arguments_force_foreground_execution() -> None:assert "trailing" in filteredtask = detected[0]assert task["name"] == "Task"- if isinstance(task.get("input"), dict):- task["input"]["run_in_background"] = False- assert task["input"]["run_in_background"] is False+ assert task["input"]["run_in_background"] == "true"def _interleaved_thinking_text_events(diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex fe91fe1b..4b624381 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -1275,7 +1275,7 @@ async def test_stream_messages_restores_nested_aliased_tool_arguments(nim_provid@pytest.mark.asyncio-async def test_stream_messages_task_tool_still_forces_background_false(nim_provider):+async def test_stream_messages_task_tool_preserves_background_true(nim_provider):req = make_request(tools=[tool(@@ -1317,7 +1317,7 @@ async def test_stream_messages_task_tool_still_forces_background_false(nim_provideltas = _input_json_deltas(events)assert len(deltas) == 1- assert json.loads(deltas[0])["run_in_background"] is False+ assert json.loads(deltas[0])["run_in_background"] is True@pytest.mark.asynciodiff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 6b05a5d8..2a34affa 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -2415,17 +2415,23 @@ class TestStreamingExceptionHandling:)@pytest.mark.asyncio- async def test_incomplete_tool_call_repair_appends_schema_valid_suffix(self):+ @pytest.mark.parametrize("tool_name", ["echo_smoke", "Task"])+ async def test_incomplete_tool_call_repair_appends_schema_valid_suffix(+ self, tool_name+ ):"""A truncated tool JSON prefix is repaired append-only before tool_use tail."""provider = _make_provider()request = _make_request(tools=[{- "name": "echo_smoke",+ "name": tool_name,"description": "Echo","input_schema": {"type": "object",- "properties": {"message": {"type": "string"}},+ "properties": {+ "message": {"type": "string"},+ "run_in_background": {"type": "boolean"},+ },"required": ["message"],"additionalProperties": False,},@@ -2433,7 +2439,9 @@ class TestStreamingExceptionHandling:])tool_chunk = _make_tool_calls_chunk(- name="echo_smoke", arguments='{"message":', tool_id="call_repair"+ name=tool_name,+ arguments='{"run_in_background":true,"message":',+ tool_id="call_repair",)with (patch.object(@@ -2460,6 +2468,12 @@ class TestStreamingExceptionHandling:for event in parsed)assert not any(event.event == "error" for event in parsed)+ arguments = [+ event.data["delta"]["partial_json"]+ for event in parsed+ if event.data.get("delta", {}).get("type") == "input_json_delta"+ ]+ assert arguments == ['{"run_in_background":true,"message":', '"ok"}']@pytest.mark.asyncioasync def test_stream_rate_limit_uses_the_execution_retry_session(self):@@ -2951,8 +2965,8 @@ class TestProcessToolCall:assert later == []assert sse.tool_states[0].tool_id == generated_id- def test_task_tool_forces_background_false(self):- """Task tool with run_in_background=true is forced to false."""+ def test_task_tool_preserves_background_true(self):+ """Task tool preserves run_in_background=true."""provider = _make_provider()sse = _make_anthropic_output()args = json.dumps({"run_in_background": True, "prompt": "test"})@@ -2963,11 +2977,11 @@ class TestProcessToolCall:}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))event_text = "".join(events)- # The intercepted args should have run_in_background=false- assert "false" in event_text.lower()+ assert sse.tool_states[0].content == args+ assert "true" in event_text.lower()- def test_task_tool_chunked_args_forces_background_false(self):- """Chunked Task args are buffered until valid JSON, then forced to false."""+ def test_task_tool_streams_chunked_args(self):+ """Chunked Task args stream without changing the requested execution mode."""provider = _make_provider()sse = _make_anthropic_output()tc1 = {@@ -2984,14 +2998,18 @@ class TestProcessToolCall:assembler = _make_tool_assembler(provider)events1 = list(assembler.process_tool_call(tc1, sse))assert len(events1) > 0- assert "false" not in "".join(events1).lower()+ assert sse.tool_states[0].content == tc1["function"]["arguments"]events2 = list(assembler.process_tool_call(tc2, sse))event_text = "".join(events1 + events2)- assert "false" in event_text.lower()+ assert "true" in event_text.lower()+ assert json.loads(sse.tool_states[0].content) == {+ "run_in_background": True,+ "prompt": "test",+ }- def test_task_tool_invalid_json_logs_warning_on_flush(self, caplog):- """Invalid JSON args for Task tool emits {} on flush and logs a warning."""+ def test_task_tool_invalid_json_is_not_replaced(self):+ """Invalid Task arguments remain available to generic validation and repair."""provider = _make_provider()sse = _make_anthropic_output()tc = {@@ -3003,11 +3021,7 @@ class TestProcessToolCall:events = list(assembler.process_tool_call(tc, sse))assert len(events) > 0- with caplog.at_level("WARNING"):- flushed = list(assembler.flush_task_arg_buffers(sse))- assert len(flushed) > 0- assert "{}" in "".join(flushed)- assert any("Task args invalid JSON" in r.message for r in caplog.records)+ assert sse.tool_states[0].content == "not json"def test_negative_tool_index_fallback(self):"""tc_index < 0 uses len(tool_indices) as fallback."""@@ -3135,7 +3149,7 @@ class TestStreamChunkEdgeCases:assert "Connection reset" in error.messagedef test_stream_malformed_tool_args_chunked(self):- """Chunked tool args that never form valid JSON are flushed with {}."""+ """Malformed chunks are retained without a Task-specific fallback."""provider = _make_provider()sse = _make_anthropic_output()tc1 = {@@ -3152,11 +3166,9 @@ class TestStreamChunkEdgeCases:assembler = _make_tool_assembler(provider)events1 = list(assembler.process_tool_call(tc1, sse))events2 = list(assembler.process_tool_call(tc2, sse))- flushed = list(assembler.flush_task_arg_buffers(sse))-- event_text = "".join(events1 + events2 + flushed)+ event_text = "".join(events1 + events2)assert "tool_use" in event_text- assert "{}" in event_text+ assert sse.tool_states[0].content == '{"broken": never valid }'@pytest.mark.asynciodiff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.pyindex 68cefef3..51f40f84 100644--- a/tests/providers/test_subagent_interception.py+++ b/tests/providers/test_subagent_interception.py@@ -1,32 +1,159 @@+import copyimport json+import pytest++from free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.openai_responses import (+ OpenAIResponsesRequest,+ build_responses_chat_request,+)from free_claude_code.providers.openai_chat.stream_output import (AnthropicChatStreamOutput,+ ChatStreamOutput,+ ChatStreamUsage,+ ResponsesChatStreamOutput,)from free_claude_code.providers.openai_chat.tool_calls import (+ OpenAIToolCallAssembler,iter_heuristic_tool_use_events,)-def test_task_tool_interception() -> None:- output = AnthropicChatStreamOutput(- message_id="msg_test",- model="test-model",- input_tokens=1,[email protected](params=["messages", "responses"])+def output(request) -> ChatStreamOutput:+ if request.param == "messages":+ return AnthropicChatStreamOutput(+ message_id="msg_test", model="test-model", input_tokens=1+ )+ prepared = build_responses_chat_request(+ OpenAIResponsesRequest(model="test-model", input="hello"),+ reasoning_replay=ReasoningReplayMode.DISABLED,)+ return ResponsesChatStreamOutput(prepared.tool_adapter, input_tokens=1)+++def _argument_deltas(frames: list[str]) -> list[str]:+ parts = []+ for event in parse_sse_text("".join(frames)):+ if event.event == "response.function_call_arguments.delta":+ parts.append(event.data["delta"])+ elif event.data.get("delta", {}).get("type") == "input_json_delta":+ parts.append(event.data["delta"]["partial_json"])+ return parts+++ "arguments",+ [+ {"run_in_background": True},+ {"run_in_background": False},+ {"run_in_background": None},+ {"prompt": "inspect"},+ ],+)+def test_heuristic_task_preserves_arguments(output, arguments):tool_use = {"type": "tool_use",- "id": "tool_123",+ "id": "call_task","name": "Task",- "input": {- "description": "test task",- "prompt": "do something",- "run_in_background": True,- },+ "input": {**arguments, "nested": {"items": [1, 2]}},}+ original = copy.deepcopy(tool_use)+ frames = list(iter_heuristic_tool_use_events(output, tool_use))+ assert json.loads("".join(_argument_deltas(frames))) == original["input"]+ assert tool_use == original- events = list(iter_heuristic_tool_use_events(output, tool_use))- delta = next(event for event in events if '"type": "input_json_delta"' in event)- payload = json.loads(delta.split("data: ", 1)[1])- args_passed = json.loads(payload["delta"]["partial_json"])- assert args_passed["run_in_background"] is False+[email protected]("name", ["Task", "ordinary_tool"])+ "arguments",+ [+ '{"run_in_background":true,"prompt":"inspect"}',+ "{}",+ '{"run_in_background":null}',+ "[]",+ "not json",+ '{"broken":',+ "",+ ],+)+def test_tool_arguments_stream_without_name_specific_rewrites(output, name, arguments):+ assembler = OpenAIToolCallAssembler(reserved_tool_ids=())+ frames = output.start_events()+ split = len(arguments) // 2+ for part, tool_name in [(arguments[:split], name), (arguments[split:], None)]:+ emitted = list(+ assembler.process_tool_call(+ {+ "index": 0,+ "id": "call_task",+ "function": {"name": tool_name, "arguments": part},+ },+ output,+ )+ )+ if isinstance(output, AnthropicChatStreamOutput):+ assert _argument_deltas(emitted) == ([part] if part else [])+ frames.extend(emitted)+ frames.extend(+ output.finish_success(+ stop_reason="tool_use",+ usage=ChatStreamUsage(input_tokens=1, output_tokens=1),+ )+ )+ assert output.tool_states[0].content == arguments+ assert output.tool_states[0].tool_id == "call_task"+ events = parse_sse_text("".join(frames))+ if isinstance(output, ResponsesChatStreamOutput):+ valid = arguments in (+ '{"run_in_background":true,"prompt":"inspect"}',+ "{}",+ '{"run_in_background":null}',+ )+ assert any(e.event == "response.completed" for e in events) == valid+ assert any(e.event == "response.failed" for e in events) != valid+ if valid:+ assert json.loads("".join(_argument_deltas(frames))) == json.loads(+ arguments+ )+ else:+ assert not _argument_deltas(frames)+ else:+ assert events[-1].event == "message_stop"+ assert "".join(_argument_deltas(frames)) == arguments+++def test_task_argument_aliases_are_restored_recursively(output):+ assembler = OpenAIToolCallAssembler(reserved_tool_ids=())+ buffers = {}+ frames = []+ for name, part in [+ ("Task", '{"run_in_background":true,"wire_prompt":"inspect",'),+ (None, '"nested":[{"wire_prompt":"child"}]}'),+ ]:+ frames.extend(+ assembler.process_tool_call(+ {+ "index": 0,+ "id": "call_task",+ "function": {"name": name, "arguments": part},+ },+ output,+ tool_argument_aliases={"Task": {"wire_prompt": "prompt"}},+ tool_argument_alias_buffers=buffers,+ )+ )+ frames.extend(+ assembler.flush_tool_argument_alias_buffers(+ output, {"Task": {"wire_prompt": "prompt"}}, buffers+ )+ )+ frames.extend(output.close_all_blocks())+ assert json.loads("".join(_argument_deltas(frames))) == {+ "run_in_background": True,+ "prompt": "inspect",+ "nested": [{"prompt": "child"}],+ }+ assert not buffers