thwip-cli 1.6.0__tar.gz → 1.6.2__tar.gz

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.6.0
+Version: 1.6.2
 Summary: Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly
 Project-URL: Homepage, https://github.com/tanmayhutt/thwip-cli
 Project-URL: Repository, https://github.com/tanmayhutt/thwip-cli

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/docs/verification.md

@@ -1,7 +1,7 @@
 # Verification status
 
-Verified locally on 2026-09-24 for v1.6.0. The Python suite
-passes 263 offline tests. Exhaustive behavior across every provider and
+Verified locally on 2026-09-24 for v1.6.2. The Python suite
+passes 265 offline tests on Python 3.11, 3.12, and 3.13. Exhaustive behavior across every provider and
 configuration has not been established.
 
 ## Native CLI connections (2026-09-24)
@@ -19,6 +19,9 @@ each using its existing sign-in. No API keys were configured.
 | Ctrl+C during a response | Turn cancelled, child process terminated, REPL continued, unanswered message removed |
 | Ctrl+C at a Codex permission prompt | Turn cancelled, no file created, no leftover process, REPL continued |
 | Usage-limit failover | With a test-only shim making Codex report "You've hit your usage limit", the real REPL showed the alternatives, switched to Claude Code on `1`, retried the message, and answered; history held one clean pair |
+| Terminal hygiene (v1.6.2) | Cursor-position queries disabled, keyboard echo off during turns, stray input flushed before each prompt; fixes `^[`/`^R` noise and phantom empty prompts seen in a real Ghostty session during a slow Antigravity reply. Permission prompt and chat re-verified live afterwards |
+| Ollama adapter (v1.6.1) | End to end against the fake Ollama routes: model list, streamed text with usage, tool call, HTTP 500 and unreachable server now raise clear errors instead of ending the turn silently |
+| Dependency audits (v1.6.1) | pip-audit reports no known vulnerabilities; npm audit reports zero |
 | Direct API adapters (v1.6.0) | All six (OpenAI, Anthropic, Google, DeepSeek, Groq, OpenRouter) run end to end through their real SDKs over HTTP against `tests/fake_providers.py`: live catalog, streamed text with usage, tool call and result round trip, HTTP 429 to LimitHit. The real REPL was also driven against the fake with direct keys: startup, live `/models`, chat, read_file tool round, provider switches, and 429 failover |
 | Full command sweep (v1.5.1) | Every slash command with invalid arguments, native launcher decline, key picker cancel, Ctrl+T, Ctrl+C inside pickers and confirmations, Backspace editing; found and fixed Backspace triggering `/history` via the Ctrl+H binding |
 | Parity commands | Live REPL run: `!git log`, `/model` picker, `@file` mention answered by Codex, `/compact` summary, `/export`, `/copy`, `/diff`, `/new`, `/resume`, `/usage` |

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "thwip-cli"
-version = "1.6.0"
+version = "1.6.2"
 description = "Universal coding agent multiplexer: detect, switch, and route between AI coding agents seamlessly"
 readme = "README.md"
 license = "MIT"

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/tests/fake_providers.py

@@ -17,6 +17,7 @@ from urllib.parse import urlparse
 REPLY = "fake reply from local provider"
 CHAT_MODELS = ["gpt-fake-chat", "gpt-fake-limited"]
 GEMINI_MODELS = ["gemini-fake-chat", "gemini-fake-limited"]
+OLLAMA_MODELS = ["fake-local:latest", "fake-broken:latest"]
 
 
 def _wants_tool(body: dict) -> bool:
@@ -76,6 +77,8 @@ class Handler(BaseHTTPRequestHandler):
                  "inputTokenLimit": 32000, "outputTokenLimit": 8000} for m in GEMINI_MODELS]})
         if path.endswith("/models"):
             return self._json(200, {"data": [{"id": m, "display_name": m, "context_window": 32000} for m in CHAT_MODELS]})
+        if path.endswith("/api/tags"):
+            return self._json(200, {"models": [{"name": m, "model": m, "size": 1, "details": {"parameter_size": "1B"}} for m in OLLAMA_MODELS]})
         return self._json(404, {"error": "not found"})
 
     def do_POST(self):
@@ -86,6 +89,8 @@ class Handler(BaseHTTPRequestHandler):
         if _is_limited(body, path):
             return self._json(429, {"error": {"message": "Rate limit reached for model; quota exhausted", "type": "rate_limit_error"}},
                               {"retry-after": "0"})
+        if path.endswith("/api/chat"):
+            return self._ollama(body)
         if path.endswith("/chat/completions"):
             return self._chat_completions(body)
         if path.endswith("/responses"):
@@ -130,6 +135,28 @@ class Handler(BaseHTTPRequestHandler):
                                 "output": output, "usage": {"input_tokens": 11, "output_tokens": 5, "total_tokens": 16},
                                 "parallel_tool_calls": True, "tool_choice": "auto", "tools": []})
 
+    # --- Ollama ---
+    def _ollama(self, body):
+        if "broken" in str(body.get("model", "")):
+            return self._json(500, {"error": "model runner crashed"})
+        if _wants_tool(body):
+            message = {"role": "assistant", "content": "", "tool_calls": [{"function": {"name": "read_file", "arguments": {"file_path": "note.txt"}}}]}
+        else:
+            message = {"role": "assistant", "content": REPLY}
+        final = {"model": body["model"], "message": message, "done": True, "prompt_eval_count": 11, "eval_count": 5}
+        if body.get("stream", True):
+            self.send_response(200)
+            self.send_header("Content-Type", "application/x-ndjson")
+            self.end_headers()
+            if not _wants_tool(body):
+                for piece in ["fake reply ", "from local provider"]:
+                    self.wfile.write((json.dumps({"model": body["model"], "message": {"role": "assistant", "content": piece}, "done": False}) + "\n").encode())
+                final["message"] = {"role": "assistant", "content": ""}
+            self.wfile.write((json.dumps(final) + "\n").encode())
+            self.wfile.flush()
+            return None
+        return self._json(200, final)
+
     # --- Anthropic ---
     def _anthropic(self, body):
         usage = {"input_tokens": 11, "output_tokens": 5}

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/tests/test_direct_providers_e2e.py

@@ -97,7 +97,7 @@ async def test_http_429_becomes_limit_hit(agent):
 
 
 def test_default_urls_are_used_without_override(monkeypatch):
-    for provider, env in ENV.items():
+    for env in ENV.values():
         monkeypatch.delenv(env, raising=False)
     from thwip import endpoints
     endpoints.configure({})
@@ -105,3 +105,30 @@ def test_default_urls_are_used_without_override(monkeypatch):
     endpoints.configure({"openai": "https://proxy.example/v1/"})
     assert base_url("openai") == "https://proxy.example/v1" and is_overridden("openai")
     endpoints.configure({})
+
+
+@pytest.fixture
+def ollama(fake):
+    from thwip.agents.ollama_agent import OllamaAgent
+    return OllamaAgent(host=fake.url)
+
+
+def test_ollama_lists_models_from_server(ollama):
+    assert ollama.is_configured()
+    assert [m.id for m in ollama.available_models] == ["fake-local:latest", "fake-broken:latest"]
+
+
+@pytest.mark.asyncio
+async def test_ollama_stream_tool_round_and_errors(ollama):
+    events = await run(ollama, messages=[{"role": "user", "content": "hello"}], model="fake-local:latest", stream=True)
+    assert "".join(e.content for e in events if isinstance(e, TextDelta)) == REPLY
+    assert isinstance(events[-1], AgentDone) and events[-1].usage.input_tokens == 11
+    events = await run(ollama, messages=[{"role": "user", "content": "Please read the file note.txt"}], model="fake-local:latest",
+                       tools=TOOLS, stream=False)
+    calls = [e for e in events if isinstance(e, ToolUseStart)]
+    assert calls and calls[0].tool_name == "read_file" and calls[0].args == {"file_path": "note.txt"}
+    with pytest.raises(RuntimeError, match="HTTP 500"):
+        await run(ollama, messages=[{"role": "user", "content": "hello"}], model="fake-broken:latest", stream=True)
+    from thwip.agents.ollama_agent import OllamaAgent
+    with pytest.raises(RuntimeError, match="unreachable"):
+        await run(OllamaAgent(host="http://127.0.0.1:9"), messages=[{"role": "user", "content": "hello"}], model="x", stream=True)

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/thwip/__init__.py

@@ -1,4 +1,4 @@
 """thwip: Universal Coding Agent Multiplexer."""
 
-__version__ = "1.6.0"
+__version__ = "1.6.2"
 __app_name__ = "thwip"

thwip_cli-1.6.2/thwip/agents/ollama_agent.py

@@ -0,0 +1,218 @@
+"""
+Ollama agent adapter.
+
+Local offline models with unlimited quota, zero cost, and full privacy.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import urllib.error
+import urllib.request
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+
+from thwip.agents.base import (
+    AgentDone,
+    AgentEvent,
+    BaseAgent,
+    Capability,
+    LimitStatus,
+    ModelInfo,
+    SubscriptionInfo,
+    SubscriptionTier,
+    TextDelta,
+    TokenUsage,
+    ToolUseStart,
+)
+
+
+class OllamaAgent(BaseAgent):
+    """
+    Ollama Local Agent.
+
+    Runs entirely on-device with zero rate limits and unlimited usage.
+    """
+
+    name = "ollama"
+    display_name = "Ollama (Local)"
+    company = "Ollama"
+    description = "Local models running entirely on-device (zero API limits, private)"
+    website = "https://ollama.com"
+
+    capabilities = {
+        Capability.CHAT,
+        Capability.FILE_EDIT,
+        Capability.FILE_READ,
+        Capability.CODE_RUN,
+        Capability.TERMINAL,
+        Capability.GIT,
+    }
+
+    def __init__(self, host: str = "http://localhost:11434") -> None:
+        self.host = host.rstrip("/")
+        self._cached_models: list[ModelInfo] | None = None
+
+    @property
+    def available_models(self) -> list[ModelInfo]:
+        if self._cached_models is not None:
+            return self._cached_models
+
+        # Try to query running Ollama server for downloaded models
+        models = []
+        try:
+              req = urllib.request.Request(f"{self.host}/api/tags")
+              with urllib.request.urlopen(req, timeout=1.5) as resp:
+                  data = json.loads(resp.read().decode("utf-8"))
+                  for m in data.get("models", []):
+                      name = m.get("name", "")
+                      models.append(
+                          ModelInfo(
+                              id=name,
+                              name=f"{name} (Local)",
+                              context_window=32_768,
+                              max_output=8_192,
+                              supports_tools=True,
+                              supports_streaming=True,
+                              pricing_input=0.0,
+                              pricing_output=0.0,
+                          )
+                      )
+        except Exception:
+              pass
+
+        if not models:
+              # Defaults
+              models = [
+                  ModelInfo(id="llama3.3", name="Llama 3.3", is_default=True),
+                  ModelInfo(id="qwen2.5-coder", name="Qwen 2.5 Coder"),
+                  ModelInfo(id="deepseek-r1", name="DeepSeek R1 Distill"),
+                  ModelInfo(id="codellama", name="CodeLlama"),
+              ]
+        self._cached_models = models
+        return models
+
+    def is_installed(self) -> bool:
+        return shutil.which("ollama") is not None or self._is_server_reachable()
+
+    def get_handoff_models(self) -> list[ModelInfo]:
+        """Never query even a remote configured Ollama host during a preview."""
+        if self._cached_models is not None:
+              return list(self._cached_models)
+        return [
+              ModelInfo(id="llama3.3", name="Llama 3.3", is_default=True),
+              ModelInfo(id="qwen2.5-coder", name="Qwen 2.5 Coder"),
+              ModelInfo(id="deepseek-r1", name="DeepSeek R1 Distill"),
+              ModelInfo(id="codellama", name="CodeLlama"),
+        ]
+
+    def _is_server_reachable(self) -> bool:
+        try:
+              req = urllib.request.Request(f"{self.host}/api/tags")
+              with urllib.request.urlopen(req, timeout=1.0) as resp:
+                  return resp.status == 200
+        except Exception:
+              return False
+
+    def is_configured(self) -> bool:
+        return self._is_server_reachable()
+
+    def get_install_info(self) -> dict[str, str]:
+        path = shutil.which("ollama") or ""
+        return {
+              "method": "CLI / Local Daemon" if path else "Local Server",
+              "path": path or self.host,
+              "version": "Local",
+        }
+
+    def get_subscription_info(self) -> SubscriptionInfo:
+        return SubscriptionInfo(
+              tier=SubscriptionTier.UNLIMITED,
+              is_active=self.is_configured(),
+              message="Unlimited offline local compute",
+        )
+
+    async def chat(
+        self,
+        messages: list[dict[str, Any]],
+        model: str | None = None,
+        system_prompt: str | None = None,
+        tools: list[dict[str, Any]] | None = None,
+        stream: bool = True,
+    ) -> AsyncIterator[AgentEvent]:
+        model = model or self.get_default_model()
+        formatted_messages = []
+        if system_prompt:
+              formatted_messages.append({"role": "system", "content": system_prompt})
+        formatted_messages.extend(messages)
+
+        payload: dict[str, Any] = {
+              "model": model,
+              "messages": formatted_messages,
+              "stream": stream,
+        }
+        if tools:
+              payload["tools"] = tools
+
+        try:
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                if stream:
+                    async with client.stream(
+                        "POST", f"{self.host}/api/chat", json=payload
+                    ) as resp:
+                        if resp.status_code != 200:
+                            body = (await resp.aread()).decode("utf-8", "replace")[:200]
+                            raise RuntimeError(f"Ollama returned HTTP {resp.status_code} for {model}: {body or 'no details'}")
+                        async for line in resp.aiter_lines():
+                            if not line:
+                                continue
+                            try:
+                                data = json.loads(line)
+                                msg = data.get("message", {})
+                                content = msg.get("content", "")
+                                if content:
+                                    yield TextDelta(content=content)
+                                for call in msg.get("tool_calls", []):
+                                    function = call.get("function", {})
+                                    yield ToolUseStart(
+                                        tool_id=call.get("id", function.get("name", "tool")),
+                                        tool_name=function.get("name", ""),
+                                        args=function.get("arguments", {}),
+                                    )
+                                if data.get("done"):
+                                    prompt_eval = data.get("prompt_eval_count", 0)
+                                    eval_count = data.get("eval_count", 0)
+                                    yield AgentDone(
+                                        usage=TokenUsage(
+                                            input_tokens=prompt_eval,
+                                            output_tokens=eval_count,
+                                        )
+                                    )
+                            except json.JSONDecodeError:
+                                continue
+                else:
+                    resp = await client.post(f"{self.host}/api/chat", json=payload)
+                    if resp.status_code != 200:
+                        raise RuntimeError(f"Ollama returned HTTP {resp.status_code} for {model}: {resp.text[:200] or 'no details'}")
+                    data = resp.json()
+                    message = data.get("message", {})
+                    if message.get("content"):
+                        yield TextDelta(content=message["content"])
+                    for call in message.get("tool_calls", []):
+                        function = call.get("function", {})
+                        yield ToolUseStart(
+                            tool_id=call.get("id", function.get("name", "tool")),
+                            tool_name=function.get("name", ""),
+                            args=function.get("arguments", {}),
+                        )
+                    yield AgentDone(usage=TokenUsage(input_tokens=data.get("prompt_eval_count", 0) or 0,
+                                                     output_tokens=data.get("eval_count", 0) or 0))
+        except httpx.HTTPError as exc:
+            raise RuntimeError(f"Ollama server at {self.host} is unreachable: {type(exc).__name__}. "
+                               "Start it with `ollama serve` or /switch to another agent.") from exc
+
+    def check_limits(self) -> LimitStatus:
+        return LimitStatus.OK if self.is_configured() else LimitStatus.NO_KEY

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/thwip/cli.py

@@ -68,6 +68,39 @@ from thwip.theme import (
 )
 from thwip.tools import ToolManager
 
+# prompt_toolkit's cursor-position query is answered by the terminal with an escape sequence.
+# During a long native turn nobody reads stdin, so the answer would be echoed as ^[ ... R and later
+# swallowed as input. The layout does not need it, so disable the query.
+os.environ.setdefault("PROMPT_TOOLKIT_NO_CPR", "1")
+
+
+class QuietTerminal:
+    """Turn off keyboard echo while a turn runs and drop stray input before the next prompt."""
+
+    def __enter__(self):
+        self._saved = None
+        try:
+            import termios
+            self._fd = sys.stdin.fileno()
+            if sys.stdin.isatty():
+                self._saved = termios.tcgetattr(self._fd)
+                quiet = termios.tcgetattr(self._fd)
+                quiet[3] &= ~termios.ECHO
+                termios.tcsetattr(self._fd, termios.TCSANOW, quiet)
+        except (ImportError, OSError, ValueError, AttributeError):
+            self._saved = None
+        return self
+
+    def __exit__(self, *exc):
+        try:
+            import termios
+            if self._saved is not None:
+                termios.tcflush(self._fd, termios.TCIFLUSH)
+                termios.tcsetattr(self._fd, termios.TCSANOW, self._saved)
+        except (ImportError, OSError, ValueError, AttributeError):
+            pass
+        return False
+
 
 class TurnInterrupted(Exception):
     """Raised when the user presses Ctrl+C at a prompt shown during a turn."""
@@ -217,7 +250,8 @@ class ThwipCLI:
                     continue
 
                 # Process chat message with agent; Ctrl+C interrupts the turn, not the REPL.
-                await self._run_interruptible(self.process_user_message(self._expand_mentions(user_input)))
+                with QuietTerminal():
+                    await self._run_interruptible(self.process_user_message(self._expand_mentions(user_input)))
 
             except (KeyboardInterrupt, EOFError):
                 console.print("\n[dim]Exiting thwip. Goodbye![/dim]")

{thwip_cli-1.6.0 → thwip_cli-1.6.2}/uv.lock

@@ -1022,7 +1022,7 @@ wheels = [
 
 [[package]]
 name = "thwip-cli"
-version = "1.6.0"
+version = "1.6.2"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },

thwip_cli-1.6.0/thwip/agents/ollama_agent.py

@@ -1,212 +0,0 @@
-"""
-Ollama agent adapter.
-
-Local offline models with unlimited quota, zero cost, and full privacy.
-"""
-
-from __future__ import annotations
-
-import json
-import shutil
-import urllib.error
-import urllib.request
-from collections.abc import AsyncIterator
-from typing import Any
-
-import httpx
-
-from thwip.agents.base import (
-    AgentDone,
-    AgentEvent,
-    BaseAgent,
-    Capability,
-    LimitStatus,
-    ModelInfo,
-    SubscriptionInfo,
-    SubscriptionTier,
-    TextDelta,
-    TokenUsage,
-    ToolUseStart,
-)
-
-
-class OllamaAgent(BaseAgent):
-    """
-    Ollama Local Agent.
-
-    Runs entirely on-device with zero rate limits and unlimited usage.
-    """
-
-    name = "ollama"
-    display_name = "Ollama (Local)"
-    company = "Ollama"
-    description = "Local models running entirely on-device (zero API limits, private)"
-    website = "https://ollama.com"
-
-    capabilities = {
-        Capability.CHAT,
-        Capability.FILE_EDIT,
-        Capability.FILE_READ,
-        Capability.CODE_RUN,
-        Capability.TERMINAL,
-        Capability.GIT,
-    }
-
-    def __init__(self, host: str = "http://localhost:11434") -> None:
-        self.host = host.rstrip("/")
-        self._cached_models: list[ModelInfo] | None = None
-
-    @property
-    def available_models(self) -> list[ModelInfo]:
-        if self._cached_models is not None:
-            return self._cached_models
-
-        # Try to query running Ollama server for downloaded models
-        models = []
-        try:
-            req = urllib.request.Request(f"{self.host}/api/tags")
-            with urllib.request.urlopen(req, timeout=1.5) as resp:
-                data = json.loads(resp.read().decode("utf-8"))
-                for m in data.get("models", []):
-                    name = m.get("name", "")
-                    models.append(
-                        ModelInfo(
-                            id=name,
-                            name=f"{name} (Local)",
-                            context_window=32_768,
-                            max_output=8_192,
-                            supports_tools=True,
-                            supports_streaming=True,
-                            pricing_input=0.0,
-                            pricing_output=0.0,
-                        )
-                    )
-        except Exception:
-            pass
-
-        if not models:
-            # Defaults
-            models = [
-                ModelInfo(id="llama3.3", name="Llama 3.3", is_default=True),
-                ModelInfo(id="qwen2.5-coder", name="Qwen 2.5 Coder"),
-                ModelInfo(id="deepseek-r1", name="DeepSeek R1 Distill"),
-                ModelInfo(id="codellama", name="CodeLlama"),
-            ]
-        self._cached_models = models
-        return models
-
-    def is_installed(self) -> bool:
-        return shutil.which("ollama") is not None or self._is_server_reachable()
-
-    def get_handoff_models(self) -> list[ModelInfo]:
-        """Never query even a remote configured Ollama host during a preview."""
-        if self._cached_models is not None:
-            return list(self._cached_models)
-        return [
-            ModelInfo(id="llama3.3", name="Llama 3.3", is_default=True),
-            ModelInfo(id="qwen2.5-coder", name="Qwen 2.5 Coder"),
-            ModelInfo(id="deepseek-r1", name="DeepSeek R1 Distill"),
-            ModelInfo(id="codellama", name="CodeLlama"),
-        ]
-
-    def _is_server_reachable(self) -> bool:
-        try:
-            req = urllib.request.Request(f"{self.host}/api/tags")
-            with urllib.request.urlopen(req, timeout=1.0) as resp:
-                return resp.status == 200
-        except Exception:
-            return False
-
-    def is_configured(self) -> bool:
-        return self._is_server_reachable()
-
-    def get_install_info(self) -> dict[str, str]:
-        path = shutil.which("ollama") or ""
-        return {
-            "method": "CLI / Local Daemon" if path else "Local Server",
-            "path": path or self.host,
-            "version": "Local",
-        }
-
-    def get_subscription_info(self) -> SubscriptionInfo:
-        return SubscriptionInfo(
-            tier=SubscriptionTier.UNLIMITED,
-            is_active=self.is_configured(),
-            message="Unlimited offline local compute",
-        )
-
-    async def chat(
-        self,
-        messages: list[dict[str, Any]],
-        model: str | None = None,
-        system_prompt: str | None = None,
-        tools: list[dict[str, Any]] | None = None,
-        stream: bool = True,
-    ) -> AsyncIterator[AgentEvent]:
-        model = model or self.get_default_model()
-        formatted_messages = []
-        if system_prompt:
-            formatted_messages.append({"role": "system", "content": system_prompt})
-        formatted_messages.extend(messages)
-
-        payload: dict[str, Any] = {
-            "model": model,
-            "messages": formatted_messages,
-            "stream": stream,
-        }
-        if tools:
-            payload["tools"] = tools
-
-        async with httpx.AsyncClient(timeout=120.0) as client:
-            if stream:
-                async with client.stream(
-                    "POST", f"{self.host}/api/chat", json=payload
-                ) as resp:
-                    if resp.status_code != 200:
-                        yield AgentDone()
-                        return
-                    async for line in resp.aiter_lines():
-                        if not line:
-                            continue
-                        try:
-                            data = json.loads(line)
-                            msg = data.get("message", {})
-                            content = msg.get("content", "")
-                            if content:
-                                yield TextDelta(content=content)
-                            for call in msg.get("tool_calls", []):
-                                function = call.get("function", {})
-                                yield ToolUseStart(
-                                    tool_id=call.get("id", function.get("name", "tool")),
-                                    tool_name=function.get("name", ""),
-                                    args=function.get("arguments", {}),
-                                )
-                            if data.get("done"):
-                                prompt_eval = data.get("prompt_eval_count", 0)
-                                eval_count = data.get("eval_count", 0)
-                                yield AgentDone(
-                                    usage=TokenUsage(
-                                        input_tokens=prompt_eval,
-                                        output_tokens=eval_count,
-                                    )
-                                )
-                        except json.JSONDecodeError:
-                            continue
-            else:
-                resp = await client.post(f"{self.host}/api/chat", json=payload)
-                if resp.status_code == 200:
-                    data = resp.json()
-                    message = data.get("message", {})
-                    if message.get("content"):
-                        yield TextDelta(content=message["content"])
-                    for call in message.get("tool_calls", []):
-                        function = call.get("function", {})
-                        yield ToolUseStart(
-                            tool_id=call.get("id", function.get("name", "tool")),
-                            tool_name=function.get("name", ""),
-                            args=function.get("arguments", {}),
-                        )
-                    yield AgentDone()
-
-    def check_limits(self) -> LimitStatus:
-        return LimitStatus.OK if self.is_configured() else LimitStatus.NO_KEY