thwip-cli 1.16.2__tar.gz → 1.17.0__tar.gz

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/.github/workflows/ci.yml

@@ -26,3 +26,23 @@ jobs:
         with:
           name: evals-fake-${{ matrix.python }}
           path: evals-fake.json
+
+  windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@c771a70e6277c0a99b617c7a806ffedaca235ff9 # v9.0.0
+      - run: uv python install 3.13
+      - run: uv sync --all-extras --python 3.13
+      - name: Lint
+        run: uv run ruff check .
+      - name: Unit and integration tests (offline)
+        run: uv run pytest -q
+      - name: Evaluation harness (offline fake adapter)
+        run: uv run python -m thwip.evals --provider fake --out evals-fake-windows.json
+      - name: Build wheel and sdist
+        run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: windows-build
+          path: dist/

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: thwip-cli
-Version: 1.16.2
+Version: 1.17.0
 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
@@ -164,6 +164,29 @@ needs one is declined by the CLI itself and thwip shows its explanation; its own
 flag is the only alternative. `/permissions` prints this summary. The evaluation harness approves the
 CLIs' write questions for the file-edit task so all three are measured on a real edit.
 
+**Your own models.** `/providers add` walks you through adding any server that speaks the OpenAI
+chat protocol: llama.cpp, LM Studio, vLLM, Ollama's `/v1` endpoint, text-generation-webui, a company
+gateway, or a hosted API. You give it a name, the base URL ending in `/v1`, optionally the name of an
+environment variable holding a key, and optionally model IDs; otherwise thwip lists the models from
+the server. The provider then appears in `/switch`, in the fallback chain, and as a compaction worker
+like any other. Saved under `[providers.<name>]` in the config:
+
+```toml
+[providers.local]
+base_url = "http://localhost:1234/v1"
+models = ["qwen2.5-coder", "llama3.3"]
+default_model = "qwen2.5-coder"
+```
+
+**Images.** `@shot.png` in a message sends the image to the CLI's own image input instead of reading
+it as text: Codex receives the local path, Claude Code receives the image inline. Antigravity's
+headless input is text only, so it receives the path and may open it with its own tools. Direct API
+providers do not take images through thwip yet.
+
+**Windows.** The package is pure Python. CI runs the full test suite, the offline harness and the
+build on a Windows runner as well as Linux, so a wheel built anywhere runs on macOS, Linux and
+Windows. Native CLIs must themselves support the platform.
+
 **Before a switch.** A switch sends the live conversation to the new CLI. When that transfer would
 fill a large share of the new CLI's window, thwip says how many tokens it is and offers to compact
 first, so the handoff is small. `/handoff` shows the same numbers without switching.

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/README.md

@@ -127,6 +127,29 @@ needs one is declined by the CLI itself and thwip shows its explanation; its own
 flag is the only alternative. `/permissions` prints this summary. The evaluation harness approves the
 CLIs' write questions for the file-edit task so all three are measured on a real edit.
 
+**Your own models.** `/providers add` walks you through adding any server that speaks the OpenAI
+chat protocol: llama.cpp, LM Studio, vLLM, Ollama's `/v1` endpoint, text-generation-webui, a company
+gateway, or a hosted API. You give it a name, the base URL ending in `/v1`, optionally the name of an
+environment variable holding a key, and optionally model IDs; otherwise thwip lists the models from
+the server. The provider then appears in `/switch`, in the fallback chain, and as a compaction worker
+like any other. Saved under `[providers.<name>]` in the config:
+
+```toml
+[providers.local]
+base_url = "http://localhost:1234/v1"
+models = ["qwen2.5-coder", "llama3.3"]
+default_model = "qwen2.5-coder"
+```
+
+**Images.** `@shot.png` in a message sends the image to the CLI's own image input instead of reading
+it as text: Codex receives the local path, Claude Code receives the image inline. Antigravity's
+headless input is text only, so it receives the path and may open it with its own tools. Direct API
+providers do not take images through thwip yet.
+
+**Windows.** The package is pure Python. CI runs the full test suite, the offline harness and the
+build on a Windows runner as well as Linux, so a wheel built anywhere runs on macOS, Linux and
+Windows. Native CLIs must themselves support the platform.
+
 **Before a switch.** A switch sends the live conversation to the new CLI. When that transfer would
 fill a large share of the new CLI's window, thwip says how many tokens it is and offers to compact
 first, so the handoff is small. `/handoff` shows the same numbers without switching.

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/pyproject.toml

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

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/tests/test_compaction.py

@@ -148,3 +148,43 @@ async def test_cmd_compact_falls_back_to_plain_text_when_worker_cannot_do_json(c
     assert await cli.cmd_compact() is True
     assert other.calls == 4, "two repairs after the first JSON attempt, then one plain-text request"
     assert "plain prose summary" in cli.session.messages[0].content
+
+
+class SequenceAgent(Agent):
+    """Replies in order; used to prove the coverage check sends missing exact items back."""
+
+    def __init__(self, name, replies):
+        super().__init__(name)
+        self.replies = list(replies)
+        self.prompts = []
+
+    async def chat(self, messages=None, **kwargs):
+        self.calls += 1
+        self.prompts.append(messages[-1]["content"])
+        yield TextDelta(content=self.replies.pop(0) if self.replies else self.replies_last)
+        yield AgentDone()
+
+    replies_last = ""
+
+
+@pytest.mark.asyncio
+async def test_structured_summary_sends_back_missing_exact_items():
+    from thwip.compaction import extract_anchors, missing_anchors, summarize_structured
+
+    history = [{"role": "user", "content": "Edit thwip/cli.py; the code word is PLUM-7 and the docs are at https://x.y/z"},
+               {"role": "assistant", "content": "Done, see `uv lock` output; released v1.16.2."}]
+    anchors = extract_anchors(transcript(history))
+    assert {"thwip/cli.py", "PLUM-7", "https://x.y/z", "uv lock", "1.16.2"} <= set(anchors)
+    incomplete = '{"context": ["edited the CLI file"], "decisions": [], "open_tasks": []}'
+    complete = ('{"context": ["Edit thwip/cli.py; code word PLUM-7; docs https://x.y/z"], '
+                '"decisions": ["ran `uv lock`; released v1.16.2"], "open_tasks": []}')
+    worker = SequenceAgent("w", [incomplete, complete])
+    summary, repairs = await summarize_structured(worker, history)
+    assert worker.calls == 2 and "left out these exact items" in worker.prompts[1] and "PLUM-7" in worker.prompts[1]
+    assert not missing_anchors(summary, anchors) and repairs == 1
+
+    # When the worker keeps leaving items out, they are appended verbatim rather than lost.
+    stubborn = SequenceAgent("s", [incomplete, incomplete, incomplete])
+    stubborn.replies_last = incomplete
+    summary, _ = await summarize_structured(stubborn, history)
+    assert "Exact items from earlier turns" in summary and "PLUM-7" in summary and "https://x.y/z" in summary

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/tests/test_native_agents.py

@@ -287,3 +287,18 @@ async def test_codex_thread_is_reused_across_turns(monkeypatch):
     [e async for e in agent.chat([{'role': 'user', 'content': 'b'}], model='future-model', resume={'id': thread_id, 'synced': 0})]
     methods = [m for m, _ in rpc.requests]
     assert 'thread/start' not in methods and 'thread/resume' not in methods, 'the open thread is reused without re-opening'
+
+
+@pytest.mark.asyncio
+async def test_codex_turn_carries_local_images(monkeypatch, tmp_path):
+    agent = NativeAgent('openai', '.')
+    rpc = FakeRPC('openai')
+    async def connect():
+        return rpc
+    monkeypatch.setattr(agent, '_connect', connect)
+    shot = tmp_path / 'shot.png'
+    shot.write_bytes(b'png')
+    [e async for e in agent.chat([{'role': 'user', 'content': 'what is this'}], model='future-model', images=[str(shot)])]
+    turn = next(p for m, p in rpc.requests if m == 'turn/start')
+    assert turn['input'][0] == {'type': 'text', 'text': 'what is this'}
+    assert turn['input'][1] == {'type': 'localImage', 'path': str(shot)}

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/tests/test_native_print.py

@@ -1,6 +1,7 @@
 """Print-mode native adapters, exercised with fake CLI processes only."""
 
 import asyncio
+import base64
 import json
 
 import pytest
@@ -390,3 +391,17 @@ async def test_thwip_adds_no_restrictions_of_its_own(monkeypatch):
     await collect(agy, model="gemini-3.8-flash-high")
     assert "--mode" not in calls[0][0] and "--sandbox" not in calls[0][0]
     await agy.close()
+
+
+@pytest.mark.asyncio
+async def test_claude_turn_carries_images_as_blocks(monkeypatch, tmp_path):
+    agent = PrintAgent("claude", ".")
+    shot = tmp_path / "shot.png"
+    shot.write_bytes(b"png-bytes")
+    calls = install_fake(monkeypatch, agent, [{"type": "result", "subtype": "success", "result": "a cat", "usage": {}}])
+    events = [e async for e in agent.chat([{"role": "user", "content": "what is this"}], model="fable", images=[str(shot)])]
+    assert isinstance(events[-1], AgentDone)
+    content = calls[0][1].user_messages()[0]
+    assert content[0] == {"type": "text", "text": "what is this"}
+    assert content[1]["type"] == "image" and content[1]["source"]["media_type"] == "image/png"
+    assert content[1]["source"]["data"] == base64.b64encode(b"png-bytes").decode()

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/tests/test_parity_commands.py

@@ -308,3 +308,53 @@ def test_current_folder_wins_over_the_remembered_project(tmp_path, monkeypatch):
     monkeypatch.chdir(Path.home())
     assert Path(ThwipCLI().config.project) == remembered.resolve(), "from home, the remembered project is the default"
     assert Path(ThwipCLI(project=str(here)).config.project) == here.resolve(), "--project always wins"
+
+
+def test_custom_provider_config_round_trip_and_registry(tmp_path, monkeypatch):
+    import tomllib
+
+    from thwip.agents.custom_agent import CustomAgent
+
+    monkeypatch.setenv("THWIP_CONFIG_DIR", str(tmp_path / "config"))
+    config = ThwipConfig()
+    config._apply_toml(tomllib.loads(
+        '[providers.local]\nbase_url = "http://localhost:1234/v1/"\nmodels = ["qwen", "llama"]\ndefault_model = "llama"\n'
+        '[providers.bad]\nmodels = ["x"]\n'))
+    assert set(config.providers) == {"local"}, "an entry without base_url is ignored"
+    assert config.providers["local"]["base_url"] == "http://localhost:1234/v1"
+    config.save()
+    reloaded = ThwipConfig.load()
+    assert reloaded.providers["local"]["models"] == ["qwen", "llama"]
+    registry = AgentRegistry(reloaded)
+    agent = registry.get_agent("local")
+    assert isinstance(agent, CustomAgent) and agent.is_configured() and agent.get_default_model() == "llama"
+    assert agent.get_model_info("anything-else") is not None, "unknown IDs are left to the server"
+    assert agent._get_api_key() == "local" and not agent.responses_api
+    assert agent in registry.get_ready_agents()
+
+
+@pytest.mark.asyncio
+async def test_custom_provider_lists_models_from_the_server(monkeypatch):
+    import httpx
+
+    from thwip.agents.custom_agent import CustomAgent
+
+    def handler(request):
+        assert request.url.path.endswith("/models") and request.headers.get("authorization") == "Bearer k"
+        return httpx.Response(200, json={"data": [{"id": "served-a"}, {"id": "served-b"}]})
+    transport = httpx.MockTransport(handler)
+    real = httpx.AsyncClient
+    monkeypatch.setattr(httpx, "AsyncClient", lambda **kw: real(transport=transport, **kw))
+    monkeypatch.setenv("MY_KEY", "k")
+    agent = CustomAgent("srv", {"base_url": "http://srv/v1", "api_key_env": "MY_KEY", "models": ["mine"]})
+    await agent.refresh_models()
+    assert [m.id for m in agent.available_models] == ["mine", "served-a", "served-b"] and agent.get_default_model() == "mine"
+
+
+@pytest.mark.asyncio
+async def test_image_mentions_go_to_the_cli_image_input(cli, tmp_path, monkeypatch):
+    (tmp_path / "shot.png").write_bytes(b"\x89PNG fake")
+    (tmp_path / "notes.txt").write_text("plain text")
+    text = cli._expand_mentions("look at @shot.png and @notes.txt")
+    assert cli._pending_images == [str((tmp_path / "shot.png").resolve())]
+    assert "Attached file: notes.txt" in text and "PNG" not in text, "images are never read as text"

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/__init__.py

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

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/agents/__init__.py

@@ -54,6 +54,11 @@ class AgentRegistry:
                 inst = agent_cls(api_key=key)
 
             self._agents[name] = inst
+        # Your own OpenAI-compatible providers from [providers.<name>].
+        from thwip.agents.custom_agent import CustomAgent
+        for name, spec in (getattr(self.config, "providers", None) or {}).items():
+            if name not in self._agents:
+                self._agents[name] = CustomAgent(name, spec)
 
     def get_agent(self, name: str) -> BaseAgent | None:
         """Get agent by name or alias."""
@@ -75,7 +80,10 @@ class AgentRegistry:
             "local": "ollama",
             "openrouter": "openrouter",
         }
-        normalized = alias_map.get(name.lower().strip(), name.lower().strip())
+        wanted = name.lower().strip()
+        if wanted in self._agents:
+            return self._agents[wanted]   # a provider you named yourself wins over built-in aliases
+        normalized = alias_map.get(wanted, wanted)
         return self._agents.get(normalized)
 
     async def connect_native_agents(self, project: str) -> None:

thwip_cli-1.17.0/thwip/agents/custom_agent.py

@@ -0,0 +1,129 @@
+"""Your own providers: any OpenAI-compatible server, local or hosted.
+
+llama.cpp, LM Studio, vLLM, Ollama's /v1 endpoint, text-generation-webui, a company gateway: anything
+that speaks the OpenAI chat-completions protocol. Configured under [providers.<name>] in config.toml
+or with /providers add. Models are listed live from the server's /models endpoint when it has one,
+or taken from the config; any model ID is accepted and the server validates it.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from thwip.agents.base import Capability, LimitStatus, ModelInfo, SubscriptionInfo
+from thwip.agents.openai_agent import OpenAIAgent
+
+
+class CustomAgent(OpenAIAgent):
+    """An OpenAI-compatible endpoint under a name you chose."""
+
+    responses_api = False
+    capabilities = {Capability.CHAT, Capability.FILE_READ, Capability.FILE_EDIT, Capability.CODE_RUN,
+                    Capability.TERMINAL, Capability.GIT}
+
+    def __init__(self, name: str, spec: dict[str, Any]) -> None:
+        super().__init__(api_key=spec.get("api_key"))
+        self.name = name
+        self.display_name = spec.get("display_name") or name
+        self.company = spec.get("company") or "Custom"
+        self.base_url = str(spec["base_url"]).rstrip("/")
+        self.api_key_env = spec.get("api_key_env", "")
+        self.available_models = [ModelInfo(id=m, name=m, is_default=(i == 0)) for i, m in enumerate(spec.get("models", []))]
+        default = spec.get("default_model")
+        if default:
+            for model in self.available_models:
+                model.is_default = model.id == default
+            if default not in {m.id for m in self.available_models}:
+                self.available_models.insert(0, ModelInfo(id=default, name=default, is_default=True))
+        self.discovery_error = ""
+
+    # --- Keys and client ---
+
+    def _get_api_key(self) -> str | None:
+        if self._api_key:
+            return self._api_key
+        if self.api_key_env:
+            value = os.environ.get(self.api_key_env, "").strip()
+            if value:
+                return value
+        return "local"   # local servers ignore the key; the OpenAI client requires a non-empty one
+
+    def _ensure_client(self) -> Any:
+        if self._client is None:
+            from openai import AsyncOpenAI
+            self._client = AsyncOpenAI(api_key=self._get_api_key(), base_url=self.base_url)
+        return self._client
+
+    # --- Detection ---
+
+    def is_installed(self) -> bool:
+        return True
+
+    def is_configured(self) -> bool:
+        return bool(self.base_url)
+
+    @property
+    def auth_method(self) -> str:
+        return "custom_endpoint"
+
+    def get_status_display(self):
+        if self.discovery_error:
+            return (f"Configured; {self.discovery_error}", "status.limited")
+        return (f"Ready ({self.base_url})", "status.ready")
+
+    def get_install_info(self) -> dict[str, str]:
+        return {"method": "OpenAI-compatible endpoint", "path": self.base_url, "version": ""}
+
+    def get_subscription_info(self) -> SubscriptionInfo:
+        return SubscriptionInfo(is_active=True, message=f"Your own endpoint: {self.base_url}")
+
+    def check_limits(self):
+        return LimitStatus.OK
+
+    def get_model_info(self, model_id):
+        known = super().get_model_info(model_id)
+        if known or not isinstance(model_id, str) or not model_id or any(c.isspace() for c in model_id):
+            return known
+        return ModelInfo(id=model_id, name=model_id)   # the server validates unknown IDs
+
+    def get_default_model(self) -> str:
+        for model in self.available_models:
+            if model.is_default:
+                return model.id
+        return self.available_models[0].id if self.available_models else ""
+
+    # --- Live model list ---
+
+    async def refresh_models(self) -> None:
+        """Merge the server's /models list over the configured one; keep the configured list on failure."""
+        headers = {}
+        key = self._get_api_key()
+        if key and key != "local":
+            headers["Authorization"] = f"Bearer {key}"
+        try:
+            async with httpx.AsyncClient(timeout=10) as client:
+                response = await client.get(f"{self.base_url}/models", headers=headers)
+                response.raise_for_status()
+                payload = response.json()
+        except Exception as exc:
+            self.discovery_error = f"model list unavailable ({type(exc).__name__}); using the configured list"
+            return
+        items = payload.get("data", payload) if isinstance(payload, dict) else payload
+        live = []
+        for item in items if isinstance(items, list) else []:
+            model_id = item.get("id") if isinstance(item, dict) else item
+            if isinstance(model_id, str) and model_id:
+                live.append(model_id)
+        if not live:
+            self.discovery_error = "the server listed no models; using the configured list"
+            return
+        self.discovery_error = ""
+        default = self.get_default_model()
+        configured = {m.id for m in self.available_models}
+        merged = list(self.available_models) + [ModelInfo(id=m, name=m) for m in live if m not in configured]
+        for model in merged:
+            model.is_default = model.id == (default or live[0])
+        self.available_models = merged

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/agents/native_agent.py

@@ -187,7 +187,10 @@ class NativeAgent(BaseAgent):
         self._thread_id = session["thread"]["id"]
         return self._thread_id, False
 
-    async def chat(self, messages, model=None, system_prompt=None, tools=None, stream=True, resume=None, memory_note=""):
+    supports_images = True   # Codex takes local image paths as turn input
+
+    async def chat(self, messages, model=None, system_prompt=None, tools=None, stream=True, resume=None, memory_note="",
+                   images=None):
         rpc = await self._live_rpc()
         event_task = None
         chosen = model or self.get_default_model()
@@ -205,8 +208,9 @@ class NativeAgent(BaseAgent):
                 stale = rpc.events.get_nowait()
                 if stale.get("method") == "_closed":
                     raise RuntimeError("Native CLI exited before the turn started.")
-            await rpc.request("turn/start", {"threadId": thread_id, "model": chosen,
-                                             "input": [{"type": "text", "text": prompt}]})
+            turn_input = [{"type": "text", "text": prompt}]
+            turn_input += [{"type": "localImage", "path": str(path)} for path in (images or [])]
+            await rpc.request("turn/start", {"threadId": thread_id, "model": chosen, "input": turn_input})
             usage = TokenUsage()
             started_items = {}
             text_items = set()

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/agents/native_print.py

@@ -16,9 +16,11 @@ tool that needs one is declined by the CLI itself, and thwip shows its explanati
 from __future__ import annotations
 
 import asyncio
+import base64
 import collections
 import contextlib
 import json
+import mimetypes
 import os
 import shutil
 import uuid
@@ -272,7 +274,25 @@ class PrintAgent(BaseAgent):
 
     # --- Chat ---
 
-    async def chat(self, messages, model=None, system_prompt=None, tools=None, stream=True, resume=None, memory_note=""):
+    supports_images = True   # passed through to the CLI's own image input
+
+    @staticmethod
+    def _image_blocks(images) -> list[dict]:
+        """Anthropic-style image blocks (base64) for Claude Code's stream-json input."""
+        blocks = []
+        for path in images or []:
+            path = Path(path)
+            media = mimetypes.guess_type(path.name)[0] or "image/png"
+            try:
+                data = base64.b64encode(path.read_bytes()).decode()
+            except OSError:
+                continue
+            blocks.append({"type": "image", "source": {"type": "base64", "media_type": media, "data": data}})
+        return blocks
+
+    async def chat(self, messages, model=None, system_prompt=None, tools=None, stream=True, resume=None, memory_note="",
+                   images=None):
+        self._images = list(images or [])
         chosen = model or self.get_default_model()
         resume_id = resume.get("id") if isinstance(resume, dict) else None
         synced = resume.get("synced", 0) if isinstance(resume, dict) else 0
@@ -313,7 +333,9 @@ class PrintAgent(BaseAgent):
             # The initialize handshake is what makes Claude Code route can_use_tool questions over the stream.
             await self._send(process, {"type": "control_request", "request_id": "thwip-init",
                                        "request": {"subtype": "initialize"}})
-            await self._send(process, {"type": "user", "message": {"role": "user", "content": prompt}})
+            blocks = self._image_blocks(getattr(self, "_images", []))
+            content = [{"type": "text", "text": prompt}, *blocks] if blocks else prompt
+            await self._send(process, {"type": "user", "message": {"role": "user", "content": content}})
             async for event in self._iterate(process):
                 kind = event.get("type")
                 if kind == "system" and event.get("session_id"):
@@ -386,6 +408,10 @@ class PrintAgent(BaseAgent):
         streamed_text = produced_text = False
         session_id = kept.conversation_id
         try:
+            images = [str(Path(p)) for p in getattr(self, "_images", [])]
+            if images:
+                # Antigravity's headless input takes text only; the paths are named so its own tools can open them.
+                prompt = prompt + "\n\nAttached image files (open them with your own tools): " + ", ".join(images)
             await self._send(process, {"event": "user", "message": {"role": "user", "content": prompt}})
             async for event in self._iterate(process):
                 kind = event.get("event") or event.get("type")

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/agents/openai_agent.py

@@ -101,6 +101,8 @@ class OpenAIAgent(BaseAgent):
         ),
     ]
 
+    responses_api = True   # OpenAI itself; compatible servers (custom providers) use chat completions only
+
     def __init__(self, api_key: str | None = None) -> None:
         self._api_key = api_key
         self._client = None
@@ -297,8 +299,8 @@ class OpenAIAgent(BaseAgent):
 
         client = self._ensure_client()
         model = model or self.get_default_model()
-        if tools:
-            stream = False
+        if tools and self.responses_api:
+            stream = False   # tool rounds go through the Responses API
 
         # Build messages with system prompt
         api_messages: list[dict[str, Any]] = []

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/cli.py

@@ -78,6 +78,9 @@ from thwip.utils import estimate_cost
 os.environ.setdefault("PROMPT_TOOLKIT_NO_CPR", "1")
 
 
+IMAGE_SUFFIXES = {".png", ".jpg", ".jpeg", ".gif", ".webp"}
+
+
 class QuietTerminal:
     """Turn off keyboard echo while a turn runs and drop stray input before the next prompt."""
 
@@ -232,8 +235,8 @@ class ThwipCLI:
         print_info("Connecting installed agents using their existing sign-ins...")
         await self.registry.connect_native_agents(str(Path(self.session.project_path).resolve()))
         self.current_agent = self._resolve_initial_agent()
-        if getattr(self.current_agent, "native_tools", False):
-            self.session.current_model = self.current_agent.get_default_model()
+        if getattr(self.current_agent, "native_tools", False) or self.current_agent.name in (getattr(self.config, "providers", None) or {}):
+            self.session.current_model = self.current_agent.get_default_model()   # the global default model is not theirs
         # 1. Detect agents on system
         self.detector.scan_all()
         all_agents = self.registry.list_agents()
@@ -463,6 +466,9 @@ class ThwipCLI:
         elif cmd == "/export":
             self.cmd_export(cmd_line.partition(" ")[2].strip())
 
+        elif cmd == "/providers":
+            await self.cmd_providers(arg1.lower(), arg2)
+
         elif cmd in ("/permissions", "/approvals"):   # Codex calls it /approvals
             self.cmd_permissions()
 
@@ -819,6 +825,7 @@ class ThwipCLI:
     def _expand_mentions(self, text: str) -> str:
         """Attach files referenced as @path (inside the project) to the message, like @ mentions in Codex and Claude Code."""
         mentions = re.findall(r"(?<!\S)@([\w./\-]+)", text)
+        self._pending_images = []
         if not mentions:
             return text
         attachments = []
@@ -827,6 +834,11 @@ class ThwipCLI:
             candidate = (project / mention).resolve()
             if not candidate.is_file() or project not in candidate.parents:
                 continue
+            if candidate.suffix.lower() in IMAGE_SUFFIXES:
+                # Images go to the CLI's own image input (Codex, Claude Code), never read as text.
+                self._pending_images.append(str(candidate))
+                print_info(f"Attached image {mention}")
+                continue
             content = self.tool_manager.execute_tool("read_file", {"file_path": mention, "max_lines": 400})
             attachments.append(f"[Attached file: {mention}]\n{content}")
             print_info(f"Attached {mention}")
@@ -1149,6 +1161,73 @@ class ThwipCLI:
             return "No earlier conversation matched that query." if self.session.archive else "Nothing has been compacted yet; the full conversation is already in context."
         return "\n\n".join(chunk.text for chunk in found)
 
+    async def cmd_providers(self, sub: str = "", rest: str = "") -> None:
+        """/providers [add|remove <name>|list]: your own OpenAI-compatible models, local or hosted."""
+        providers = getattr(self.config, "providers", None)
+        if providers is None:
+            self.config.providers = providers = {}
+        if sub == "add":
+            console.print(Text(
+                "Add any server that speaks the OpenAI chat protocol: llama.cpp, LM Studio, vLLM, Ollama (/v1), "
+                "text-generation-webui, a company gateway, or a hosted API.\n"
+                "You need its base URL ending in /v1, and a key only if the server asks for one.", style="dim"))
+            name = (await self._ask_text("Name for this provider (e.g. local, lmstudio, work):")).strip().lower().replace(" ", "-")
+            if not name:
+                print_info("Nothing added.")
+                return
+            base_url = (await self._ask_text("Base URL (e.g. http://localhost:1234/v1):")).strip().rstrip("/")
+            if not base_url.startswith(("http://", "https://")):
+                print_error("The base URL must start with http:// or https://.")
+                return
+            key_env = (await self._ask_text("Environment variable holding the API key (Enter if none):")).strip()
+            models_text = (await self._ask_text("Model IDs, comma separated (Enter to list them from the server):")).strip()
+            spec = {"base_url": base_url}
+            if key_env:
+                spec["api_key_env"] = key_env
+            if models_text:
+                spec["models"] = [m.strip() for m in models_text.split(",") if m.strip()]
+            from thwip.agents.custom_agent import CustomAgent
+            agent = CustomAgent(name, spec)
+            with console.status("[dim]Asking the server for its model list...[/dim]"):
+                await agent.refresh_models()
+            if not agent.available_models:
+                print_error("The server listed no models and none were given. Check the URL or enter model IDs.")
+                return
+            if agent.discovery_error:
+                print_warning(agent.discovery_error)
+            providers[name] = spec
+            self.registry._agents[name] = agent
+            with contextlib.suppress(Exception):
+                self.config.save()
+            print_success(f"Added {name}: {len(agent.available_models)} model(s), default {agent.get_default_model()}. "
+                          f"Use /switch {name}. Saved under [providers.{name}] in config.toml.")
+            return
+        if sub == "remove":
+            name = rest.strip().lower()
+            if name in providers:
+                providers.pop(name)
+                self.registry._agents.pop(name, None)
+                with contextlib.suppress(Exception):
+                    self.config.save()
+                print_success(f"Removed provider {name}.")
+            else:
+                print_error(f"No custom provider named '{name}'.")
+            return
+        if not providers:
+            console.print(Text("No custom providers yet. /providers add walks you through adding any OpenAI-compatible "
+                               "server, local (llama.cpp, LM Studio, vLLM, Ollama) or hosted.", style="dim"))
+            return
+        table = Table(title="Your providers", box=box.ROUNDED)
+        table.add_column("Name", style="bold white")
+        table.add_column("Base URL", style="white")
+        table.add_column("Models", style="dim")
+        for name, spec in providers.items():
+            agent = self.registry.get_agent(name)
+            models = ", ".join(m.id for m in (agent.available_models if agent else [])) or ", ".join(spec.get("models", []))
+            table.add_row(name, spec.get("base_url", ""), models[:80])
+        console.print(table)
+        console.print(Text("/providers add, /providers remove <name>, /switch <name>", style="dim"))
+
     def cmd_permissions(self) -> None:
         """/permissions: how each native CLI's own permission questions reach you."""
         lines = [
@@ -1292,6 +1371,8 @@ class ThwipCLI:
             ("@path in a message", "Attach a project file's content to your message"),
             ("/prompt [show|set <text>|reset|save]", "Your standing instructions for every assistant; thwip itself adds only a neutral note"),
             ("/permissions", "How each native CLI's own permission questions reach you"),
+            ("/providers [add|remove <name>]", "Your own models: any OpenAI-compatible server, local or hosted"),
+            ("@image.png in a message", "Send an image to the CLI's own image input (Codex, Claude Code)"),
             ("/recall <words>", "Search earlier turns that compaction summarized away"),
             ("/trace [n]", "Recent request traces: latency, tokens, cost, tool calls, errors per provider"),
             ("/memory [show|init|edit|update|sync|vault|link]", "Project memory file shared by every CLI, filed into your second-brain vault; /init is a shortcut for /memory init"),
@@ -2006,6 +2087,14 @@ class ThwipCLI:
                         chat_kwargs["resume"] = self.session.native_session(self.current_agent.name)
                         if memory_note:
                             chat_kwargs["memory_note"] = memory_note
+                    pending_images = getattr(self, "_pending_images", [])
+                    if pending_images:
+                        if getattr(self.current_agent, "supports_images", False):
+                            chat_kwargs["images"] = list(pending_images)
+                        else:
+                            print_warning(f"{self.current_agent.display_name} takes no image input through thwip; "
+                                          "the image was not sent.")
+                        self._pending_images = []
                     response_stream = self.current_agent.chat(**chat_kwargs)
                     # Close the adapter generator deterministically on interruption so child processes stop.
                     closer = contextlib.aclosing(response_stream) if hasattr(response_stream, "aclose") else contextlib.nullcontext(response_stream)

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/compaction.py

@@ -11,6 +11,7 @@ Vocabulary:
 from __future__ import annotations
 
 import contextlib
+import re
 from collections.abc import Sequence
 
 from thwip.agents.base import AgentDone, LimitHit, TextDelta
@@ -20,14 +21,47 @@ class CompactionUnavailable(RuntimeError):
     """The worker could not produce a summary (limit hit or empty answer)."""
 
 
-SUMMARY_SYSTEM_PROMPT = "You write faithful, compact summaries for another assistant that will continue the work."
-
+SUMMARY_SYSTEM_PROMPT = ("You write faithful, compact summaries for another assistant that will continue the work. "
+                         "When unsure whether a detail matters, keep it.")
 SUMMARY_REQUEST = (
-    "Summarize the conversation below for another assistant that will continue it. Keep every decision, "
-    "requirement, file path, command, error, code word, URL, and open task exactly as stated. Use short bullet points "
-    "under the headings Context, Decisions, Open tasks. Do not add commentary.\n\n"
+    "Summarize the conversation below for another assistant that will continue it with no other memory of it.\n"
+    "Rules:\n"
+    "- Copy every file path, command, error message, code word, identifier, URL, number and version exactly as written; "
+    "never paraphrase these.\n"
+    "- Keep every decision with its reason, every requirement and constraint the user stated, and every preference "
+    "about how the user wants to work.\n"
+    "- Keep every open task, question, and anything tried that failed, so it is not tried again.\n"
+    "- Drop only greetings, repetition, and reasoning that led nowhere.\n"
+    "- Short bullet points under the headings Context, Decisions, Open tasks. No commentary.\n\n"
 )
 
+# Things a summary must carry word for word. They are extracted deterministically from the old turns and checked
+# against the summary; a summary missing any of them is sent back with the exact list.
+_ANCHOR_PATTERNS = [
+    re.compile(r"`([^`\n]{2,120})`"),                                      # anything the conversation put in code marks
+    re.compile(r"(?<![\w/.])((?:~|\.{1,2})?/?[\w.\-]+(?:/[\w.\-]+)+)"),    # paths with at least one slash
+    re.compile(r"\b([\w.\-]+\.(?:py|js|ts|tsx|md|toml|json|yml|yaml|txt|ini|cfg|sh|html|css|rs|go|java|c|h|cpp))\b"),
+    re.compile(r"\b(https?://[^\s)\]]+)"),                                  # URLs
+    re.compile(r"\b([A-Z][A-Z0-9_-]{3,})\b"),                                # CODE-WORDS and CONSTANTS
+    re.compile(r"\bv?(\d+\.\d+(?:\.\d+)+)\b"),                            # versions
+]
+
+
+def extract_anchors(text: str) -> list[str]:
+    """Exact strings the summary must contain, in order of first appearance, without duplicates."""
+    found: list[str] = []
+    for pattern in _ANCHOR_PATTERNS:
+        for match in pattern.findall(text):
+            item = match.strip()
+            if len(item) >= 2 and item not in found:
+                found.append(item)
+    return found
+
+
+def missing_anchors(summary: str, anchors: Sequence[str]) -> list[str]:
+    lowered = summary.lower()
+    return [a for a in anchors if a.lower() not in lowered]
+
 
 def choose_worker(active, ready: Sequence, chain: Sequence[str] = ()):
     """Pick the provider that writes the summary: never the active one when any alternative is ready."""
@@ -54,13 +88,32 @@ async def summarize_structured(worker, messages: Sequence[dict], model: str | No
     Falls back to the plain-text summary when the worker cannot produce valid JSON after repairs.
     """
     from thwip.structured import StructuredOutputError, render_summary, request_json, summary_schema
-
-    request = SUMMARY_REQUEST + transcript(messages)
+    text = transcript(messages)
+    request = SUMMARY_REQUEST + text
+    anchors = extract_anchors(text)
     try:
         data, repairs = await request_json(worker, request, summary_schema(), model=model)
-        return render_summary(data), repairs
     except StructuredOutputError:
         return await summarize(worker, messages, model), -1
+    summary = render_summary(data)
+    # Coverage check: every exact item from the old turns must appear in the summary. Two rounds, then whatever is
+    # still missing is appended verbatim so nothing is silently dropped.
+    for _round in range(2):
+        missing = missing_anchors(summary, anchors)
+        if not missing:
+            break
+        fix = (request + "\n\nYour previous summary left out these exact items; include each one verbatim where it "
+               "belongs:\n- " + "\n- ".join(missing[:40]) + "\n\nPrevious summary:\n" + summary)
+        try:
+            data, more = await request_json(worker, fix, summary_schema(), model=model)
+        except StructuredOutputError:
+            break
+        repairs += more + 1
+        summary = render_summary(data)
+    missing = missing_anchors(summary, anchors)
+    if missing:
+        summary += "\nExact items from earlier turns\n" + "\n".join(f"- {m}" for m in missing[:40])
+    return summary, repairs
 
 
 async def summarize(worker, messages: Sequence[dict], model: str | None = None) -> str:

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/config.py

@@ -249,6 +249,9 @@ class ThwipConfig:
 
     # Optional per-provider base URL overrides ([endpoints] table)
     endpoints: dict[str, str] = field(default_factory=dict)
+    # Your own providers: any OpenAI-compatible server, local or hosted ([providers.<name>] tables).
+    # Keys: base_url (required), api_key or api_key_env, models (list), default_model, display_name, company.
+    providers: dict[str, dict] = field(default_factory=dict)
 
     # Sub-configs
     fallback: FallbackConfig = field(default_factory=FallbackConfig)
@@ -307,6 +310,12 @@ class ThwipConfig:
         # Endpoint overrides are free-form provider -> URL pairs.
         raw_endpoints = data.get("endpoints", {})
         clean["endpoints"] = {str(k): v for k, v in raw_endpoints.items() if isinstance(v, str)} if isinstance(raw_endpoints, dict) else {}
+        raw_providers = data.get("providers", {})
+        clean["providers"] = {}
+        if isinstance(raw_providers, dict):
+            for name, entry in raw_providers.items():
+                if isinstance(entry, dict) and isinstance(entry.get("base_url"), str) and entry["base_url"].strip():
+                    clean["providers"][str(name)] = entry
         raw_keys = data.get("keys", {})
         clean["keys"] = {key: value for key, value in raw_keys.items()
                          if isinstance(value, str) and value.strip()} if isinstance(raw_keys, dict) else {}
@@ -375,6 +384,21 @@ class ThwipConfig:
             from thwip import endpoints as endpoint_overrides
             endpoint_overrides.configure(self.endpoints)
 
+        # Custom providers
+        providers = data.get("providers", {})
+        if isinstance(providers, dict):
+            self.providers = {}
+            for name, entry in providers.items():
+                slug = str(name).strip().lower().replace(" ", "-")
+                if not slug or not isinstance(entry, dict):
+                    continue
+                clean_entry = {"base_url": str(entry["base_url"]).strip().rstrip("/")}
+                for key in ("api_key", "api_key_env", "default_model", "display_name", "company"):
+                    if isinstance(entry.get(key), str) and entry[key].strip():
+                        clean_entry[key] = entry[key].strip()
+                if isinstance(entry.get("models"), list):
+                    clean_entry["models"] = [str(m).strip() for m in entry["models"] if isinstance(m, str) and m.strip()]
+                self.providers[slug] = clean_entry
         # Fallback
         fallback = data.get("fallback", {})
         if "enabled" in fallback:
@@ -447,6 +471,7 @@ class ThwipConfig:
                 "max_width": self.display.max_width,
                 "dynamic_ui": self.display.dynamic_ui,
             },
+            "providers": self.providers,
             "limits": {
                 "warn_at_percent": self.limits.warn_at_percent,
                 "quota_warn_percent": self.limits.quota_warn_percent,

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/thwip/data/thwip.1

@@ -89,6 +89,10 @@ neutral note and the relevant project memory.
 Pick a known project, create one, or switch to a path. Sessions remember their project, so thwip can
 run from the home folder; started there, it asks which project to work on.
 .TP
+.B /providers [add|remove <name>]
+Your own models: any OpenAI-compatible server, local or hosted. /providers add asks for a name, the
+base URL, an optional key variable and optional model IDs, then lists the server's models.
+.TP
 .B /permissions
 How each native CLI's own permission questions reach you. Codex and Claude Code ask through thwip;
 Antigravity cannot ask in headless mode and declines such tools itself.

{thwip_cli-1.16.2 → thwip_cli-1.17.0}/uv.lock

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