tau-coding-agent 0.6.7__tar.gz → 0.6.9__tar.gz

{tau_coding_agent-0.6.7/tau_coding_agent.egg-info → tau_coding_agent-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.7
+Version: 0.6.9
 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
@@ -31,9 +31,9 @@ Requires-Dist: grapheme==0.6.0
 Requires-Dist: arrow==1.4.0
 Requires-Dist: kiwisolver==1.5.0
 Requires-Dist: tiktoken==0.13.0
+Requires-Dist: rapidfuzz==3.14.3
 Provides-Extra: tools
 Requires-Dist: ripgrep>=14.0.0; extra == "tools"
-Requires-Dist: ast-grep-cli>=0.44.0; extra == "tools"
 Dynamic: license-file
 
 <div align="center">

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.6.7"
+version = "0.6.9"
 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"
@@ -35,6 +35,7 @@ dependencies = [
     "arrow==1.4.0",
     "kiwisolver==1.5.0",
     "tiktoken==0.13.0",
+    "rapidfuzz==3.14.3",
 ]
 
 [project.scripts]
@@ -74,7 +75,7 @@ tau = [
 testpaths = ["tests"]
 
 [project.optional-dependencies]
-tools = ["ripgrep>=14.0.0", "ast-grep-cli>=0.44.0"]
+tools = ["ripgrep>=14.0.0"]
 
 [dependency-groups]
 dev = [

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/agent/prompt/builder.py

@@ -212,10 +212,23 @@ def _detect_machine() -> str:
 
 
 def _detect_shell() -> str:
-    """Detect the user's shell from $SHELL, falling back to common shells on PATH."""
+    """Detect the user's shell from $SHELL, falling back to common shells on PATH.
+
+    On Windows, ``$SHELL`` is a POSIX convention and is essentially never set,
+    so this used to fall through to up to 4 ``shutil.which()`` calls, each
+    scanning every ``PATH`` entry against every ``PATHEXT`` suffix for shells
+    (zsh, fish, sh) that don't exist on Windows. We instead resolve the native
+    shell directly from environment variables the OS always sets, with no
+    PATH scan.
+    """
     shell = os.environ.get("SHELL", "")
     if shell:
         return Path(shell).name
+    if sys.platform == "win32":
+        if os.environ.get("PSModulePath"):
+            return "powershell"
+        comspec = os.environ.get("COMSPEC", "")
+        return Path(comspec).stem if comspec else "cmd"
     for candidate in ("bash", "zsh", "fish", "sh"):
         if shutil.which(candidate):
             return candidate

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/builtins/models/text.py

@@ -1008,6 +1008,16 @@ models = [
         output=_TEXT,
     ),
     # xAI
+    Model(
+        id="grok-4.5",
+        name="Grok 4.5",
+        provider="xai",
+        cost=Cost(input=2.00, output=6.00),
+        thinking=True,
+        context_window=500_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
     Model(
         id="grok-4.3",
         name="Grok 4.3",
@@ -1028,6 +1038,42 @@ models = [
         input=_TEXT_IMAGE,
         output=_TEXT,
     ),
+    # xAI Grok CLI (OAuth — SuperGrok/X Premium+ subscription quota via
+    # cli-chat-proxy.grok.com, the same backend the official Grok CLI uses).
+    # grok-4.3 and grok-build are recognized by the proxy alongside grok-4.5
+    # (confirmed live: HTTP 402 "need subscription" rather than 404/401 when
+    # the account isn't entitled to them) — same models as the "xai" API-key
+    # provider, just billed against subscription quota instead of per-token.
+    Model(
+        id="grok-4.5",
+        name="Grok 4.5",
+        provider="xai-grok",
+        cost=Cost(),
+        thinking=True,
+        context_window=500_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
+    Model(
+        id="grok-4.3",
+        name="Grok 4.3",
+        provider="xai-grok",
+        cost=Cost(),
+        thinking=True,
+        context_window=1_000_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
+    Model(
+        id="grok-build",
+        name="Grok Build",
+        provider="xai-grok",
+        cost=Cost(),
+        thinking=True,
+        context_window=256_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
     # AWS Bedrock
     Model(
         id="openai.gpt-oss-120b",
@@ -1552,7 +1598,8 @@ models = [
         input=_TEXT,
         output=_TEXT,
     ),
-    # Mistral
+    # Mistral. Magistral (reasoning-only line) is deprecated — Medium 3.5 and
+    # Small 4 absorbed its reasoning mode behind the reasoning_effort param.
     Model(
         id="mistral-large-latest",
         name="Mistral Large 3",
@@ -1566,8 +1613,9 @@ models = [
         id="mistral-medium-latest",
         name="Mistral Medium 3.5",
         provider="mistral",
-        cost=Cost(input=0.40, output=2.0),
-        context_window=131_072,
+        cost=Cost(input=1.50, output=7.50),
+        thinking=True,
+        context_window=262_144,
         input=_TEXT_IMAGE,
         output=_TEXT,
     ),
@@ -1575,27 +1623,26 @@ models = [
         id="mistral-small-latest",
         name="Mistral Small 4",
         provider="mistral",
-        cost=Cost(input=0.10, output=0.30),
+        cost=Cost(input=0.15, output=0.60),
         thinking=True,
-        context_window=131_072,
+        context_window=262_144,
         input=_TEXT_IMAGE,
         output=_TEXT,
     ),
     Model(
-        id="magistral-medium-latest",
-        name="Magistral Medium 1.2",
+        id="devstral-medium-latest",
+        name="Devstral 2",
         provider="mistral",
-        cost=Cost(input=2.0, output=5.0),
-        thinking=True,
-        context_window=128_000,
-        input=_TEXT_IMAGE,
+        cost=Cost(input=0.40, output=2.0),
+        context_window=262_144,
+        input=_TEXT,
         output=_TEXT,
     ),
     Model(
-        id="devstral-latest",
-        name="Devstral 2",
+        id="devstral-small-latest",
+        name="Devstral Small 2",
         provider="mistral",
-        cost=Cost(input=0.40, output=2.0),
+        cost=Cost(input=0.10, output=0.30),
         context_window=262_144,
         input=_TEXT,
         output=_TEXT,
@@ -1609,6 +1656,45 @@ models = [
         input=_TEXT,
         output=_TEXT,
     ),
+    # Labs (free/experimental) — code agent for Lean 4 formal proof engineering
+    # and automated theorem proving, not a general chat model.
+    Model(
+        id="labs-leanstral-1-5",
+        name="Leanstral 1.5",
+        provider="mistral",
+        cost=Cost(),
+        thinking=True,
+        context_window=256_000,
+        input=_TEXT,
+        output=_TEXT,
+    ),
+    Model(
+        id="ministral-3-14b-2512",
+        name="Ministral 3 14B",
+        provider="mistral",
+        cost=Cost(input=0.20, output=0.20),
+        context_window=128_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
+    Model(
+        id="ministral-3-8b-2512",
+        name="Ministral 3 8B",
+        provider="mistral",
+        cost=Cost(input=0.15, output=0.15),
+        context_window=128_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
+    Model(
+        id="ministral-3-3b-2512",
+        name="Ministral 3 3B",
+        provider="mistral",
+        cost=Cost(input=0.10, output=0.10),
+        context_window=128_000,
+        input=_TEXT_IMAGE,
+        output=_TEXT,
+    ),
     # Ollama Cloud (catalog from models.dev / ollama-cloud — https://ollama.com/v1)
     Model(
         id="cogito-2.1:671b-cloud",

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/builtins/providers/text.py

@@ -4,6 +4,7 @@ from tau.inference.provider.oauth.anthropic_claude_code import AnthropicClaudeCo
 from tau.inference.provider.oauth.github_copilot import GitHubCopilotOAuthProvider
 from tau.inference.provider.oauth.google_antigravity import GoogleAntigravityOAuthProvider
 from tau.inference.provider.oauth.openai_codex import OpenAICodexOAuthProvider
+from tau.inference.provider.oauth.xai_grok import XAIGrokOAuthProvider
 from tau.inference.provider.types import APIProvider
 from tau.inference.types import AuthType, LLMOptions
 
@@ -129,6 +130,7 @@ oauth_providers = [
     AnthropicClaudeCodeOAuthProvider(),
     GitHubCopilotOAuthProvider(),
     GoogleAntigravityOAuthProvider(),
+    XAIGrokOAuthProvider(),
 ]
 
 providers = api_providers + oauth_providers

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/console/cli.py

@@ -5,15 +5,18 @@ import logging
 import os
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 
 from tau.console.commands.auth import auth
 from tau.console.commands.packages import install, list_packages, remove
 from tau.console.commands.update import update
-from tau.runtime.service import Runtime
 from tau.settings.paths import get_app_version
 
+if TYPE_CHECKING:
+    from tau.runtime.service import Runtime
+
 _MODES = ("interactive", "print", "json", "rpc")
 _OUTPUT_FORMATS = ("text", "json")
 

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/extensions/loader.py

@@ -409,7 +409,11 @@ class ExtensionLoader:
         """Install an extension's declared dependencies, once per dependency set.
 
         Runs synchronously (called via ``asyncio.to_thread``) so the blocking
-        subprocess install doesn't stall the event loop.
+        subprocess install doesn't stall the event loop. A failed install is
+        cached too, not just successes — otherwise a dependency that can never
+        build on this interpreter (e.g. no wheel for a free-threaded Python
+        build, missing compiler) retries the full failing subprocess on every
+        single startup instead of failing fast after the first attempt.
         """
         from tau.packages.manager import PackageManager
 
@@ -424,7 +428,7 @@ class ExtensionLoader:
 
         digest = hashlib.sha256("\n".join(sorted(deps)).encode("utf-8")).hexdigest()
         cache_file = venv_dir / ".tau_ext_deps.json"
-        cache: dict[str, str] = {}
+        cache: dict[str, Any] = {}
         if cache_file.is_file():
             try:
                 cache = json.loads(cache_file.read_text(encoding="utf-8"))
@@ -433,12 +437,29 @@ class ExtensionLoader:
                 cache = {}
 
         key = str(subdir.resolve())
-        if cache.get(key) != digest:
-            _log.info("Installing dependencies for extension %r: %s", subdir.name, ", ".join(deps))
+        entry = cache.get(key)
+        # Older cache files stored the digest directly as a bare string (success-only).
+        cached_digest = entry.get("digest") if isinstance(entry, dict) else entry
+        if cached_digest == digest:
+            if isinstance(entry, dict) and not entry.get("ok", True):
+                raise RuntimeError(
+                    f"Dependencies for extension {subdir.name!r} previously failed to "
+                    f"install: {entry.get('error', 'unknown error')}"
+                )
+            add_site_packages_path(pkg_mgr.site_packages())
+            return
+
+        _log.info("Installing dependencies for extension %r: %s", subdir.name, ", ".join(deps))
+        try:
             pkg_mgr.install_requirements(deps)
-            cache[key] = digest
+        except Exception as exc:
+            cache[key] = {"digest": digest, "ok": False, "error": str(exc)}
             cache_file.parent.mkdir(parents=True, exist_ok=True)
             cache_file.write_text(json.dumps(cache, indent=2), encoding="utf-8")
+            raise
+        cache[key] = {"digest": digest, "ok": True}
+        cache_file.parent.mkdir(parents=True, exist_ok=True)
+        cache_file.write_text(json.dumps(cache, indent=2), encoding="utf-8")
 
         add_site_packages_path(pkg_mgr.site_packages())
 

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/api/text/builtins.py

@@ -22,6 +22,7 @@ LLM_APIS: list[tuple[str, str]] = [
     ("google_vertex", "tau.inference.api.text.google_vertex:GoogleVertexAPI"),
     ("anthropic_vertex", "tau.inference.api.text.anthropic_vertex:AnthropicVertexAPI"),
     ("openai_vertex", "tau.inference.api.text.openai_vertex:OpenAIVertexAPI"),
+    ("xai", "tau.inference.api.text.xai_responses:XAIAPIResponses"),
 ]
 
 # Backward-compat alias

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/api/text/openai_responses.py

@@ -88,15 +88,9 @@ def _content_to_openai(content_items: list, supports_thinking: bool = True) -> l
                             else f"data:{mime or 'image/png'};base64,{b64}"
                         )
                         other_parts.append({"type": "input_image", "image_url": url})
-                case ToolCallContent():
-                    other_parts.append(
-                        {
-                            "type": "function_call",
-                            "call_id": item.id,
-                            "name": item.name,
-                            "arguments": json.dumps(item.args),
-                        }
-                    )
+                # ToolCallContent is handled by _messages_to_input, which hoists
+                # it out to a top-level function_call item — see the comment
+                # on the supports_thinking=True branch below.
         parts: list[dict[str, Any]] = []
         if thinking_parts or text_parts:
             merged = "\n".join(thinking_parts + text_parts)
@@ -104,6 +98,11 @@ def _content_to_openai(content_items: list, supports_thinking: bool = True) -> l
         parts.extend(other_parts)
         return parts
 
+    # ThinkingContent and ToolCallContent are intentionally not handled here:
+    # the Responses API has no "thinking" content-part type (reasoning is
+    # ephemeral and isn't replayed on later turns — see openai_codex_responses.py),
+    # and function_call is a top-level input item, not nested inside a
+    # message's content array. _messages_to_input hoists it out separately.
     parts = []
     for item in content_items:
         match item:
@@ -117,23 +116,6 @@ def _content_to_openai(content_items: list, supports_thinking: bool = True) -> l
                         else f"data:{mime or 'image/png'};base64,{b64}"
                     )
                     parts.append({"type": "input_image", "image_url": url})
-            case ThinkingContent():
-                parts.append(
-                    {
-                        "type": "thinking",
-                        "thinking": item.content,
-                        "signature": item.signature,
-                    }
-                )
-            case ToolCallContent():
-                parts.append(
-                    {
-                        "type": "function_call",
-                        "call_id": item.id,
-                        "name": item.name,
-                        "arguments": json.dumps(item.args),
-                    }
-                )
     return parts
 
 
@@ -167,6 +149,19 @@ def _messages_to_input(
                 parts = _content_to_openai(msg.contents, supports_thinking=supports_thinking)
                 if parts:
                     input_items.append({"role": role, "content": parts})
+                # function_call is a top-level input item in the Responses API,
+                # not nested inside a message's content array. It must precede
+                # its matching function_call_output (emitted by the ToolMessage).
+                for content in msg.contents:
+                    if isinstance(content, ToolCallContent):
+                        input_items.append(
+                            {
+                                "type": "function_call",
+                                "call_id": content.id,
+                                "name": content.name,
+                                "arguments": json.dumps(content.args),
+                            }
+                        )
 
     return instructions, input_items
 
@@ -258,7 +253,12 @@ class OpenAIResponsesAPI(BaseAPI):
             if modified is not None:
                 params = modified
 
-        tool_names: dict[str, str] = {}
+        # Keyed by the response item's own id (event.item_id in the arguments
+        # delta/done events), mapping to (call_id, name). item_id and call_id
+        # are two distinct identifiers — OpenAI's backend happens to make them
+        # equal, but other Responses-API-compatible backends (e.g. xAI's Grok
+        # CLI proxy) don't, so they must be tracked separately.
+        tool_calls: dict[str, tuple[str, str]] = {}
         _input_tokens = 0
         _output_tokens = 0
         _cache_read_tokens = 0
@@ -279,7 +279,7 @@ class OpenAIResponsesAPI(BaseAPI):
                     elif item.type == "reasoning":
                         yield ThinkingStartEvent(thinking=None)
                     elif item.type == "function_call":
-                        tool_names[item.call_id] = item.name  # type: ignore[union-attr,index]
+                        tool_calls[item.id] = (item.call_id, item.name)  # type: ignore[union-attr,index]
                         yield ToolCallStartEvent(
                             tool_call=ToolCallContent(id=item.call_id, name=item.name)  # type: ignore[union-attr,arg-type]
                         )
@@ -297,18 +297,16 @@ class OpenAIResponsesAPI(BaseAPI):
                     yield ThinkingEndEvent(thinking=ThinkingContent(content=event.text))  # type: ignore[union-attr]
 
                 elif etype == "response.function_call_arguments.delta":
-                    call_id = event.item_id  # type: ignore[union-attr]
+                    call_id, _ = tool_calls.get(event.item_id, (event.item_id, ""))  # type: ignore[union-attr]
                     yield ToolCallDeltaEvent(tool_call=ToolCallContent(id=call_id))
 
                 elif etype == "response.function_call_arguments.done":
-                    call_id = event.item_id  # type: ignore[union-attr]
+                    call_id, name = tool_calls.get(event.item_id, (event.item_id, ""))  # type: ignore[union-attr]
                     args_str = event.arguments.strip()  # type: ignore[union-attr]
                     args = parse_tool_args(args_str)
 
                     yield ToolCallEndEvent(
-                        tool_call=ToolCallContent(
-                            id=call_id, name=tool_names.get(call_id, ""), args=args
-                        )
+                        tool_call=ToolCallContent(id=call_id, name=name, args=args)
                     )
 
                 elif etype == "response.done":

tau_coding_agent-0.6.9/tau/inference/api/text/xai_responses.py

@@ -0,0 +1,31 @@
+"""
+xAI Grok CLI API — thin wrapper around the OpenAI Responses API adapter,
+pointed at the Grok CLI's cli-chat-proxy.grok.com backend.
+
+That proxy gatekeeps on client-identity headers (confirmed live: a request
+without ``x-grok-client-version`` is rejected with HTTP 426 "outdated
+version"), which the plain OpenAI Responses client doesn't send.
+"""
+
+from __future__ import annotations
+
+from tau.inference.api.text.openai_responses import OpenAIResponsesAPI
+from tau.inference.types import LLMOptions
+
+__all__ = ["XAIAPIResponses"]
+
+_DEFAULT_BASE_URL = "https://cli-chat-proxy.grok.com/v1"
+_CLIENT_VERSION = "0.2.93"
+
+_GROK_CLI_HEADERS = {
+    "x-grok-client-identifier": "grok-cli",
+    "x-grok-client-version": _CLIENT_VERSION,
+    "x-xai-token-auth": "xai-grok-cli",
+}
+
+
+class XAIAPIResponses(OpenAIResponsesAPI):
+    def __init__(self, options: LLMOptions) -> None:
+        options.base_url = options.base_url or _DEFAULT_BASE_URL
+        options.headers = {**_GROK_CLI_HEADERS, **(options.headers or {})}
+        super().__init__(options)

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/provider/oauth/__init__.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     )
     from tau.inference.provider.oauth.google_antigravity import GoogleAntigravityOAuthProvider
     from tau.inference.provider.oauth.openai_codex import OpenAICodexOAuthProvider
+    from tau.inference.provider.oauth.xai_grok import XAIGrokOAuthProvider
 
 __all__ = [
     "OAuthProvider",
@@ -30,6 +31,7 @@ __all__ = [
     "GitHubCopilotOAuthProvider",
     "get_copilot_base_url",
     "GoogleAntigravityOAuthProvider",
+    "XAIGrokOAuthProvider",
 ]
 
 
@@ -57,4 +59,8 @@ def __getattr__(name: str):
         from tau.inference.provider.oauth.google_antigravity import GoogleAntigravityOAuthProvider
 
         return GoogleAntigravityOAuthProvider
+    if name == "XAIGrokOAuthProvider":
+        from tau.inference.provider.oauth.xai_grok import XAIGrokOAuthProvider
+
+        return XAIGrokOAuthProvider
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/provider/oauth/anthropic_claude_code.py

@@ -308,11 +308,9 @@ class AnthropicClaudeCodeOAuthProvider(OAuthProvider):
         pass
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.anthropic_claude_code import AnthropicClaudeCodeAPI
-
-        return AnthropicClaudeCodeAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "anthropic_claude_code"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/provider/oauth/github_copilot.py

@@ -353,8 +353,6 @@ class GitHubCopilotOAuthProvider(OAuthProvider):
         return not (signal and signal.is_set())
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.github_copilot_chat import GitHubCopilotChatAPI
-
-        return GitHubCopilotChatAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "github_copilot_chat"

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/provider/oauth/google_antigravity.py

@@ -277,11 +277,9 @@ class GoogleAntigravityOAuthProvider(OAuthProvider):
             pass
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.google_antigravity import GoogleAntigravityAPI
-
-        return GoogleAntigravityAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "google_antigravity"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None

{tau_coding_agent-0.6.7 → tau_coding_agent-0.6.9}/tau/inference/provider/oauth/openai_codex.py

@@ -326,11 +326,9 @@ class OpenAICodexOAuthProvider(OAuthProvider):
         await asyncio.to_thread(_revoke_token_sync, credential.refresh)
 
     @property
-    def api(self):
-        """Return the API class that handles requests with this provider's tokens."""
-        from tau.inference.api.text.openai_codex_responses import OpenAICodexResponsesAPI
-
-        return OpenAICodexResponsesAPI
+    def api(self) -> str:
+        """Registry key for the API class; resolved (and the SDK imported) lazily."""
+        return "openai_codex_responses"
 
     async def validate(
         self, credential: OAuthCredential, signal: AbortSignal | None = None