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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.7
+Version: 0.6.8
 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.6.7 → tau_coding_agent-0.6.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tau-coding-agent"
-version = "0.6.7"
+version = "0.6.8"
 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.6.7 → tau_coding_agent-0.6.8}/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.8}/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.8}/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.8}/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.8/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.8}/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.8/tau/inference/provider/oauth/xai_grok.py

@@ -0,0 +1,286 @@
+"""
+xAI Grok CLI OAuth flow — PKCE + local callback server.
+
+The access token is used as a Bearer token for calls to
+cli-chat-proxy.grok.com, the same proxy the official Grok CLI/Grok Build
+uses to give SuperGrok/X Premium+ subscribers quota-based access to Grok
+models without a separate pay-per-token API key.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import datetime as dt
+import json
+import secrets
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+from tau.inference.provider.oauth.pkce import generate_pkce
+from tau.inference.provider.oauth.types import (
+    AbortSignal,
+    OAuthAuthInfo,
+    OAuthCredential,
+    OAuthLoginCallbacks,
+    OAuthPrompt,
+)
+from tau.inference.provider.oauth.utils import (
+    await_oauth_code,
+    get_oauth_ssl_context,
+    parse_authorization_input,
+    start_oauth_callback_server,
+)
+from tau.inference.provider.types import OAuthProvider
+
+__all__ = ["XAIGrokOAuthProvider"]
+
+CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828"
+ISSUER = "https://auth.x.ai"
+AUTHORIZE_URL = f"{ISSUER}/oauth2/authorize"
+TOKEN_URL = f"{ISSUER}/oauth2/token"
+REVOKE_URL = f"{ISSUER}/oauth2/revoke"
+USERINFO_URL = f"{ISSUER}/oauth2/userinfo"
+CALLBACK_HOST = "127.0.0.1"
+CALLBACK_PORT = 56121
+CALLBACK_PATH = "/callback"
+REDIRECT_URI = f"http://{CALLBACK_HOST}:{CALLBACK_PORT}{CALLBACK_PATH}"
+SCOPES = "openid profile email offline_access grok-cli:access api:access"
+
+
+def _build_authorization_url(challenge: str, state: str, nonce: str) -> str:
+    """Build the xAI authorization URL with PKCE and state parameters."""
+    params = {
+        "response_type": "code",
+        "client_id": CLIENT_ID,
+        "redirect_uri": REDIRECT_URI,
+        "scope": SCOPES,
+        "code_challenge": challenge,
+        "code_challenge_method": "S256",
+        "state": state,
+        "nonce": nonce,
+        "plan": "generic",
+        "referrer": "tau",
+    }
+    return f"{AUTHORIZE_URL}?{urllib.parse.urlencode(params)}"
+
+
+def _post_form(url: str, body: dict) -> dict:
+    """POST a form-encoded request and return the parsed JSON response;
+    raise RuntimeError on HTTP errors.
+    """
+    data = urllib.parse.urlencode(body).encode()
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, context=get_oauth_ssl_context(), timeout=30) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        body_text = e.read().decode(errors="replace")
+        raise RuntimeError(f"Request failed ({e.code}): {body_text}") from e
+
+
+def _exchange_code(code: str, verifier: str) -> dict:
+    """Exchange an authorization code for tokens using PKCE verification."""
+    return _post_form(
+        TOKEN_URL,
+        {
+            "grant_type": "authorization_code",
+            "client_id": CLIENT_ID,
+            "code": code,
+            "redirect_uri": REDIRECT_URI,
+            "code_verifier": verifier,
+        },
+    )
+
+
+def _refresh_token_sync(refresh_token: str) -> dict:
+    """Exchange a refresh token for a new access token via xAI's token endpoint."""
+    return _post_form(
+        TOKEN_URL,
+        {
+            "grant_type": "refresh_token",
+            "client_id": CLIENT_ID,
+            "refresh_token": refresh_token,
+        },
+    )
+
+
+def _validate_token_sync(access_token: str) -> bool:
+    """Check if the access token is valid by probing the userinfo endpoint."""
+    req = urllib.request.Request(
+        USERINFO_URL,
+        headers={"Authorization": f"Bearer {access_token}"},
+        method="GET",
+    )
+    try:
+        with urllib.request.urlopen(req, context=get_oauth_ssl_context(), timeout=10) as resp:
+            return resp.status == 200
+    except urllib.error.HTTPError as e:
+        return e.code not in (401, 403)
+    except Exception:
+        return False
+
+
+def _revoke_token_sync(token: str) -> None:
+    """Revoke a token at xAI's revocation endpoint (best-effort, silently ignores errors)."""
+    try:
+        _post_form(REVOKE_URL, {"token": token, "client_id": CLIENT_ID})
+    except Exception:
+        pass
+
+
+def _parse_token_response(data: dict) -> tuple[str, str, int]:
+    """Extract (access_token, refresh_token, expires_ms) from an xAI token response."""
+    access = data.get("access_token")
+    refresh = data.get("refresh_token")
+    expires_in = data.get("expires_in")
+    if not access or not isinstance(expires_in, (int, float)):
+        raise ValueError(f"Token response missing fields: {data}")
+    if not refresh:
+        refresh = ""
+    expires_ms = int(time.time() * 1000) + int(expires_in) * 1000 - 5 * 60 * 1000
+    return access, refresh, expires_ms
+
+
+_GROK_AUTH_FILE = Path.home() / ".grok" / "auth.json"
+_GROK_AUTH_KEY = f"{ISSUER}::{CLIENT_ID}"
+
+
+def read_grok_file_credential() -> OAuthCredential | None:
+    """Read the Grok CLI credential from ~/.grok/auth.json, if available.
+
+    The official Grok CLI stores tokens keyed by "<issuer>::<client_id>",
+    with the access token under "key" (a JWT) and expiry as an ISO 8601
+    timestamp under "expires_at" — distinct field names from every other
+    OAuth credential file this codebase reads.
+    """
+    try:
+        data = json.loads(_GROK_AUTH_FILE.read_text(encoding="utf-8"))
+        entry = data.get(_GROK_AUTH_KEY)
+        if not isinstance(entry, dict):
+            return None
+        access = entry.get("key", "")
+        refresh = entry.get("refresh_token", "")
+        expires_at = entry.get("expires_at", "")
+        if not refresh:
+            return None
+        expires_ms = int(dt.datetime.fromisoformat(expires_at.replace("Z", "+00:00")).timestamp() * 1000)
+        return OAuthCredential(access=access, refresh=refresh, expires=expires_ms)
+    except Exception:
+        return None
+
+
+async def login_xai_grok(callbacks: OAuthLoginCallbacks) -> OAuthCredential:
+    """Run the full xAI Grok OAuth login flow and return a fresh OAuthCredential.
+
+    If a credential exists at ~/.grok/auth.json (written by the official
+    Grok CLI) it is returned directly without opening a browser.
+    """
+    file_cred = read_grok_file_credential()
+    if file_cred is not None:
+        return file_cred
+
+    verifier, challenge = generate_pkce()
+    state = secrets.token_urlsafe(32)
+    nonce = secrets.token_urlsafe(16)
+    url = _build_authorization_url(challenge, state, nonce)
+
+    server, code_future = await start_oauth_callback_server(
+        CALLBACK_PATH, state, CALLBACK_HOST, CALLBACK_PORT
+    )
+    callbacks.on_auth(
+        OAuthAuthInfo(
+            url=url,
+            instructions=(
+                "Complete xAI login in your browser (requires a SuperGrok / "
+                "X Premium+ subscription). If the browser is on another "
+                "machine, paste the final redirect URL here."
+            ),
+        )
+    )
+
+    code, recv_state = await await_oauth_code(code_future, state, server, callbacks)
+
+    if not code:
+        raw = await callbacks.on_prompt(
+            OAuthPrompt(
+                message="Paste the authorization code or full redirect URL:",
+                placeholder=REDIRECT_URI,
+            )
+        )
+        parsed_code, parsed_state = parse_authorization_input(raw)
+        if parsed_state and parsed_state != state:
+            raise ValueError("OAuth state mismatch")
+        code = parsed_code
+        recv_state = parsed_state or state
+
+    if not code:
+        raise ValueError("Missing authorization code")
+    if not recv_state:
+        raise ValueError("Missing OAuth state")
+
+    if callbacks.on_progress:
+        callbacks.on_progress("Exchanging authorization code for tokens...")
+
+    data = await asyncio.to_thread(_exchange_code, code, verifier)
+    access, refresh, expires_ms = _parse_token_response(data)
+
+    return OAuthCredential(access=access, refresh=refresh, expires=expires_ms)
+
+
+async def refresh_xai_grok_token(
+    credential: OAuthCredential, signal: AbortSignal | None = None
+) -> OAuthCredential:
+    """Exchange a refresh token for a new OAuthCredential; transparent to the streaming loop."""
+    data = await asyncio.to_thread(_refresh_token_sync, credential.refresh)
+    access, new_refresh, expires_ms = _parse_token_response(data)
+    refresh = new_refresh or credential.refresh
+    return OAuthCredential(access=access, refresh=refresh, expires=expires_ms)
+
+
+@dataclass
+class XAIGrokOAuthProvider(OAuthProvider):
+    """OAuthProvider implementation for xAI Grok CLI (SuperGrok / X Premium+) accounts."""
+
+    id: str = "xai-grok"
+    name: str = "xAI Grok CLI (SuperGrok Subscription)"
+    uses_callback_server: bool = True
+
+    async def login(self, callbacks: OAuthLoginCallbacks) -> OAuthCredential:
+        """Initiate the OAuth login flow through xAI's authorization server."""
+        return await login_xai_grok(callbacks)
+
+    async def refresh_token(
+        self, credential: OAuthCredential, signal: AbortSignal | None = None
+    ) -> OAuthCredential:
+        """Obtain a new access token using the stored refresh token."""
+        return await refresh_xai_grok_token(credential, signal=signal)
+
+    async def logout(self, credential: OAuthCredential) -> None:
+        """Revoke the refresh token at xAI's revocation endpoint (best-effort)."""
+        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.xai_responses import XAIAPIResponses
+
+        return XAIAPIResponses
+
+    async def validate(
+        self, credential: OAuthCredential, signal: AbortSignal | None = None
+    ) -> bool:
+        """Return True if the credential is unexpired and accepted by the API."""
+        if self.is_expired(credential):
+            return False
+        if signal and signal.is_set():
+            return False
+        return await asyncio.to_thread(_validate_token_sync, credential.access)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tau-coding-agent
-Version: 0.6.7
+Version: 0.6.8
 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