tau-coding-agent 0.7.1__tar.gz → 0.7.2__tar.gz

{tau_coding_agent-0.7.1/tau_coding_agent.egg-info → tau_coding_agent-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.7.1
+Version: 0.7.2
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.7.1 → tau_coding_agent-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.7.1"
+version = "0.7.2"
 description = "A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands"
 readme = "README.md"
 requires-python = ">=3.12"

{tau_coding_agent-0.7.1 → tau_coding_agent-0.7.2}/tau/inference/api/text/google_antigravity.py

@@ -232,6 +232,10 @@ def _messages_to_contents(
 ) -> tuple[str | None, list[dict[str, Any]]]:
     system: str | None = None
     raw: list[dict[str, Any]] = []
+    # Tool call ids whose functionCall was downgraded to plain text below (no
+    # thoughtSignature) — their matching ToolResultContent must be downgraded
+    # too, or the backend sees a tool_result with no corresponding tool_use.
+    downgraded_call_ids: set[str] = set()
 
     for msg in messages:
         match msg:
@@ -257,6 +261,13 @@ def _messages_to_contents(
                         case TextContent():
                             parts.append({"text": item.content})
                         case ThinkingContent():
+                            if not item.content:
+                                # Claude's backend behind this API rejects a
+                                # thought part with no text ("thinking.thinking:
+                                # Field required") — drop no-op blocks left
+                                # over from a provider/model switch instead of
+                                # replaying them verbatim.
+                                continue
                             tp: dict[str, Any] = {"thought": True, "text": item.content}
                             if item.signature and not distrust_thought_signatures:
                                 tp["thoughtSignature"] = item.signature
@@ -279,6 +290,8 @@ def _messages_to_contents(
                                 parts.append(
                                     {"text": f"[Tool Call: {item.name}]\nArguments: {args_str}"}
                                 )
+                                if item.id:
+                                    downgraded_call_ids.add(item.id)
                             else:
                                 function_call: dict[str, Any] = {
                                     "name": item.name,
@@ -296,6 +309,15 @@ def _messages_to_contents(
                 parts = []
                 for content in msg.contents:
                     if isinstance(content, ToolResultContent):
+                        if content.id and content.id in downgraded_call_ids:
+                            # Matching functionCall was downgraded to text above
+                            # (no thoughtSignature) — sending this as a
+                            # functionResponse would reference a tool_use the
+                            # backend never saw, so downgrade it too.
+                            parts.append(
+                                {"text": f"[Tool Result: {content.tool_name}]\n{tool_result_text(content)}"}
+                            )
+                            continue
                         # functionResponse correlates to its functionCall by name (the
                         # tool name, matching the functionCall.name above) — not by the
                         # per-call id, which lives in its own "id" field.
@@ -422,18 +444,36 @@ class GoogleAntigravityAPI(BaseAPI):
         if schema is not None:
             generation_config["responseMimeType"] = "application/json"
             generation_config["responseSchema"] = schema
+        is_claude = "claude" in model.id
         if self.options.thinking_level is not None:
             from tau.inference.types import ThinkingBudgets
             from tau.inference.types import ThinkingLevel as _TL
 
             if self.options.thinking_level == _TL.Off:
-                generation_config["thinkingConfig"] = {"thinkingBudget": 0}
+                generation_config["thinkingConfig"] = (
+                    {"thinking_budget": 0} if is_claude else {"thinkingBudget": 0}
+                )
             else:
                 budgets = self.options.thinking_budgets or ThinkingBudgets()
-                generation_config["thinkingConfig"] = {
-                    "thinkingBudget": budgets.get(self.options.thinking_level),
-                    "includeThoughts": True,
-                }
+                budget = budgets.get(self.options.thinking_level)
+                if is_claude:
+                    # Antigravity's Claude backend only reliably returns thought
+                    # parts when thinkingConfig is snake_case, and requires
+                    # maxOutputTokens to exceed the thinking budget.
+                    generation_config["thinkingConfig"] = {
+                        "thinking_budget": budget,
+                        "include_thoughts": True,
+                    }
+                    current_max = generation_config.get("maxOutputTokens")
+                    if not current_max or current_max <= budget:
+                        generation_config["maxOutputTokens"] = max(
+                            budget + 8_192, model.max_output_tokens or 0
+                        )
+                else:
+                    generation_config["thinkingConfig"] = {
+                        "thinkingBudget": budget,
+                        "includeThoughts": True,
+                    }
 
         inner: dict[str, Any] = {"contents": contents}
         if system:

{tau_coding_agent-0.7.1 → tau_coding_agent-0.7.2}/tau/inference/api/text/utils.py

@@ -400,13 +400,19 @@ def anthropic_messages_to_list(
                                 text_parts_asst.append(item.content)
                         case ThinkingContent():
                             if supports_thinking:
-                                parts.append(
-                                    {
-                                        "type": "thinking",
-                                        "thinking": item.content,
-                                        "signature": item.signature,
-                                    }
-                                )
+                                # Anthropic rejects a "thinking" block with an
+                                # empty thinking field ("each thinking block
+                                # must contain thinking") — drop no-op blocks
+                                # (e.g. left over from a provider/model switch)
+                                # instead of replaying them verbatim.
+                                if item.content:
+                                    parts.append(
+                                        {
+                                            "type": "thinking",
+                                            "thinking": item.content,
+                                            "signature": item.signature,
+                                        }
+                                    )
                             else:
                                 thinking_parts.append(item.content)
                         case ToolCallContent():

{tau_coding_agent-0.7.1 → tau_coding_agent-0.7.2/tau_coding_agent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.7.1
+Version: 0.7.2
 Summary: A self-extensible agent CLI with terminal UI, multi-provider LLM support, session management with branching, and a plugin system for tools and commands
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown

{tau_coding_agent-0.7.1 → tau_coding_agent-0.7.2}/tests/test_google_antigravity.py

@@ -14,12 +14,23 @@ Covers four related fixes to _messages_to_contents:
    back to a text part instead, for every model behind this API.
 4. thoughtSignature must not be replayed across a model switch mid-session,
    since it may not be valid bytes for whichever backend is now active.
+5. An empty ThinkingContent block (no text) must be dropped, not replayed as
+   a thought part with empty text — Claude's backend behind this API rejects
+   that with "thinking.thinking: Field required".
 """
 
 from __future__ import annotations
 
 from tau.inference.api.text.google_antigravity import _messages_to_contents
-from tau.message.types import AssistantMessage, ToolCallContent, ToolMessage, ToolResultContent, UserMessage
+from tau.message.types import (
+    AssistantMessage,
+    TextContent,
+    ThinkingContent,
+    ToolCallContent,
+    ToolMessage,
+    ToolResultContent,
+    UserMessage,
+)
 
 _SIGNATURE = {"thoughtSignature": "sig"}
 
@@ -52,7 +63,9 @@ def test_function_response_error_uses_error_key() -> None:
     # "result"/"isError") — older Gemini models tolerated the wrong shape.
     messages = [
         UserMessage.from_text("hi"),
-        AssistantMessage(contents=[ToolCallContent(id="tc1", name="read_file", args={})]),
+        AssistantMessage(
+            contents=[ToolCallContent(id="tc1", name="read_file", args={}, metadata=_SIGNATURE)]
+        ),
         ToolMessage(
             contents=[
                 ToolResultContent(
@@ -89,6 +102,44 @@ def test_gemini_model_omits_tool_call_id() -> None:
     assert "id" not in call
 
 
+def test_unsigned_tool_call_downgrades_matching_result_too() -> None:
+    # If the functionCall has no thoughtSignature it's downgraded to plain
+    # text (see module docstring, point 3). Sending the paired
+    # ToolResultContent as a functionResponse in that case leaves a
+    # tool_result with no matching tool_use, which Claude rejects with
+    # "unexpected `tool_use_id` found in `tool_result` blocks". The result
+    # must be downgraded to text alongside its call.
+    messages = [
+        UserMessage.from_text("hi"),
+        AssistantMessage(contents=[ToolCallContent(id="tc1", name="read_file", args={"path": "x"})]),
+        ToolMessage(
+            contents=[ToolResultContent(id="tc1", content="file contents", tool_name="read_file")]
+        ),
+    ]
+
+    _, contents = _messages_to_contents(messages, "claude-sonnet-4-6")
+
+    for content in contents:
+        for part in content["parts"]:
+            assert "functionCall" not in part
+            assert "functionResponse" not in part
+
+
+def test_empty_thinking_content_is_dropped() -> None:
+    messages = [
+        UserMessage.from_text("hi"),
+        AssistantMessage(
+            contents=[ThinkingContent(content=""), TextContent(content="hello there")]
+        ),
+    ]
+
+    _, contents = _messages_to_contents(messages, "claude-sonnet-4-6")
+
+    model_turn = next(c for c in contents if c["role"] == "model")
+    assert not any(p.get("thought") for p in model_turn["parts"])
+    assert {"text": "hello there"} in model_turn["parts"]
+
+
 def test_unsigned_tool_call_falls_back_to_text_on_gemini3() -> None:
     messages = [
         UserMessage.from_text("hi"),