Skip to content

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.py
index 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.py
index 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.py
index 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 json
import uuid
from collections.abc import Iterator, Mapping
from contextlib import suppress
from dataclasses import dataclass, field
from typing import Any
-from loguru import logger
-
from free_claude_code.core.token_estimation import estimate_text_tokens
from .emitter import AnthropicSseEmitter
@@ -32,8 +28,6 @@ class ToolBlockState:
name: str
extra_content: dict[str, Any] | None = None
started: bool = False
- task_arg_buffer: str = ""
- task_args_emitted: bool = False
pre_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"] = False
diff --git a/src/free_claude_code/providers/openai_chat/stream_output.py b/src/free_claude_code/providers/openai_chat/stream_output.py
index 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 hashlib
import json
import time
import uuid
@@ -8,8 +7,6 @@ from abc import ABC, abstractmethod
from collections.abc import Callable, Iterator, Mapping
from 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 = None
started: bool = False
open: bool = False
- task_arg_buffer: str = ""
- task_args_emitted: bool = False
pre_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"] = False
diff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.py
index 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"] = False
yield 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_id
return 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)
continue
state = output.tool_states.get(tool_index)
- if state is None or state.name == "Task":
+ if state is None:
continue
aliases = 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))
- return
aliases = (
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.py
index 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_buffer
if 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.py
index 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 filtered
task = 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.py
index 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_provi
deltas = _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.asyncio
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index 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.asyncio
async 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.message
def 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.asyncio
diff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.py
index 68cefef3..51f40f84 100644
--- a/tests/providers/test_subagent_interception.py
+++ b/tests/providers/test_subagent_interception.py
@@ -1,32 +1,159 @@
+import copy
import 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