polyclaude 0.1.0__tar.gz

polyclaude-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: pip install -e .
+      - name: Import & CLI smoke test
+        run: |
+          python -c "import polyclaude, polyclaude.bridge, polyclaude.cli, polyclaude.providers"
+          polyclaude --list
+          polyclaude --version

polyclaude-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write        # required for PyPI Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

polyclaude-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# secrets — never commit
+.env
+.env.*
+*.key
+*.pem
+
+# python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.venv/
+venv/
+.eggs/
+
+# tooling
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+
+# os / editor
+.DS_Store
+*.swp
+.idea/
+.vscode/
+
+# runtime logs
+/tmp/polyclaude*.log

polyclaude-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Devesh Pratap
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

polyclaude-0.1.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: polyclaude
+Version: 0.1.0
+Summary: Use OpenAI, Gemini, and any OpenAI-compatible model inside the Claude Code CLI.
+Project-URL: Homepage, https://github.com/ibedevesh/polyclaude
+Project-URL: Repository, https://github.com/ibedevesh/polyclaude
+Project-URL: Issues, https://github.com/ibedevesh/polyclaude/issues
+Author-email: Devesh Pratap <mail2deveshpratap@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: anthropic,claude,claude-code,cli,coding-agent,gemini,gpt,llm,openai,proxy
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Requires-Dist: mitmproxy>=10
+Description-Content-Type: text/markdown
+
+# polyclaude
+
+**Use OpenAI, Gemini, or any OpenAI-compatible model inside the Claude Code CLI.**
+
+Claude Code is a great terminal coding agent — but it only talks to Anthropic's
+models. `polyclaude` lets you keep the exact Claude Code experience (its UI,
+tools, and agent loop) while the actual model behind it is **GPT, Gemini, a Groq
+model, an OpenRouter model, or a local Ollama model**.
+
+It works by running a tiny local proxy that speaks Claude Code's API on one side
+and your provider's API on the other, translating between them on the fly.
+Claude Code itself is never modified.
+
+```
+Claude Code  ⇄  Anthropic Messages API  ⇄  [ polyclaude ]  ⇄  OpenAI / Gemini / …
+```
+
+---
+
+## Install
+
+```bash
+pipx install polyclaude      # recommended
+# or: uv tool install polyclaude
+# or: pip install polyclaude
+```
+
+You'll also need [Claude Code](https://docs.claude.com/claude-code) installed
+(`claude` on your PATH) and an API key for whichever provider you want to use.
+
+## Use
+
+```bash
+export GEMINI_API_KEY=...        # or OPENAI_API_KEY, GROQ_API_KEY, …
+polyclaude --gemini              # Claude Code, powered by Gemini
+polyclaude --openai              # …powered by GPT
+polyclaude --openai --model gpt-4.1
+polyclaude --gemini --model gemini-2.5-pro
+```
+
+That's it — you're dropped into a normal Claude Code session running on the
+model you chose. First run auto-configures the local proxy certificate; nothing
+else to set up.
+
+Pass arguments straight through to `claude` after `--`:
+
+```bash
+polyclaude --gemini -- -p "explain this repo"
+```
+
+---
+
+## Providers
+
+| Provider | Flag | Key env | Default model |
+|---|---|---|---|
+| Google Gemini | `--gemini` | `GEMINI_API_KEY` | `gemini-2.5-pro` |
+| OpenAI | `--openai` | `OPENAI_API_KEY` | `gpt-4.1` |
+| Groq | `--groq` | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
+| OpenRouter | `--openrouter` | `OPENROUTER_API_KEY` | `anthropic/claude-3.5-sonnet` |
+| Ollama (local) | `--ollama` | — | `qwen2.5-coder` |
+
+Any model your key can access works via `--model`, including the newest ones
+(Gemini 3.x, GPT-5.x). polyclaude handles the provider-specific details so tool
+calling and reasoning keep working:
+
+- **Gemini 3.x** thinking models need their function-call *thought signatures*
+  round-tripped across turns — handled automatically.
+- **GPT-5.5 / 5.6** can't use tools and reasoning together on the standard
+  endpoint; polyclaude routes them through OpenAI's `/responses` API so you get
+  **both** (tune depth with `--reasoning low|medium|high`).
+- Reasoning models reject non-default sampling params — dropped automatically.
+- Turns that hit the output-token cap are transparently continued.
+
+Run `polyclaude --list` to see everything.
+
+---
+
+## Specialize the agent
+
+Give the agent a persona/use-case with a profile — it's appended to the system
+prompt for the main loop only, so Claude Code's own tooling keeps working:
+
+```bash
+polyclaude --gemini --profile datascience
+polyclaude --openai --profile reviewer
+polyclaude --gemini --profile ./my-profile.md      # your own file
+```
+
+Bundled profiles: `datascience`, `reviewer`, `concise`. Or replace the whole
+system prompt with `--system path/to/file.md`.
+
+---
+
+## How it works
+
+`polyclaude` starts [mitmproxy](https://mitmproxy.org) locally with a small
+addon and points Claude Code at it (via `HTTPS_PROXY` + `NODE_EXTRA_CA_CERTS`,
+scoped to that one process). The addon intercepts requests to
+`api.anthropic.com/v1/messages`, translates the Anthropic request into the
+provider's format, calls the provider, and streams the reply back in Anthropic's
+event format. Every other host is passed straight through untouched.
+
+Only sessions you launch with `polyclaude` are affected — your normal `claude`
+is unchanged and still uses Anthropic.
+
+---
+
+## FAQ
+
+**Does this change my Claude Code install?** No. It only sets proxy environment
+variables for the session it launches.
+
+**Do my keys leave my machine?** Only to the provider you choose (Google,
+OpenAI, etc.), exactly as if you called their API directly. polyclaude has no
+servers.
+
+**Quality feels off on some models.** Different models behave differently inside
+Claude Code's harness (its prompt and tools are tuned for Claude). Larger/newer
+models fare better; try `--reasoning high` on OpenAI and compare providers.
+
+**Can I use my own endpoint?** Yes — anything OpenAI-compatible. Point at it and
+go (OpenRouter, vLLM, LM Studio, etc.).
+
+---
+
+## Notes
+
+For personal and development use, with your own API keys. Respect the terms of
+service of Claude Code and of whichever model provider you use.
+
+## License
+
+MIT © Devesh Pratap

polyclaude-0.1.0/README.md

@@ -0,0 +1,134 @@
+# polyclaude
+
+**Use OpenAI, Gemini, or any OpenAI-compatible model inside the Claude Code CLI.**
+
+Claude Code is a great terminal coding agent — but it only talks to Anthropic's
+models. `polyclaude` lets you keep the exact Claude Code experience (its UI,
+tools, and agent loop) while the actual model behind it is **GPT, Gemini, a Groq
+model, an OpenRouter model, or a local Ollama model**.
+
+It works by running a tiny local proxy that speaks Claude Code's API on one side
+and your provider's API on the other, translating between them on the fly.
+Claude Code itself is never modified.
+
+```
+Claude Code  ⇄  Anthropic Messages API  ⇄  [ polyclaude ]  ⇄  OpenAI / Gemini / …
+```
+
+---
+
+## Install
+
+```bash
+pipx install polyclaude      # recommended
+# or: uv tool install polyclaude
+# or: pip install polyclaude
+```
+
+You'll also need [Claude Code](https://docs.claude.com/claude-code) installed
+(`claude` on your PATH) and an API key for whichever provider you want to use.
+
+## Use
+
+```bash
+export GEMINI_API_KEY=...        # or OPENAI_API_KEY, GROQ_API_KEY, …
+polyclaude --gemini              # Claude Code, powered by Gemini
+polyclaude --openai              # …powered by GPT
+polyclaude --openai --model gpt-4.1
+polyclaude --gemini --model gemini-2.5-pro
+```
+
+That's it — you're dropped into a normal Claude Code session running on the
+model you chose. First run auto-configures the local proxy certificate; nothing
+else to set up.
+
+Pass arguments straight through to `claude` after `--`:
+
+```bash
+polyclaude --gemini -- -p "explain this repo"
+```
+
+---
+
+## Providers
+
+| Provider | Flag | Key env | Default model |
+|---|---|---|---|
+| Google Gemini | `--gemini` | `GEMINI_API_KEY` | `gemini-2.5-pro` |
+| OpenAI | `--openai` | `OPENAI_API_KEY` | `gpt-4.1` |
+| Groq | `--groq` | `GROQ_API_KEY` | `llama-3.3-70b-versatile` |
+| OpenRouter | `--openrouter` | `OPENROUTER_API_KEY` | `anthropic/claude-3.5-sonnet` |
+| Ollama (local) | `--ollama` | — | `qwen2.5-coder` |
+
+Any model your key can access works via `--model`, including the newest ones
+(Gemini 3.x, GPT-5.x). polyclaude handles the provider-specific details so tool
+calling and reasoning keep working:
+
+- **Gemini 3.x** thinking models need their function-call *thought signatures*
+  round-tripped across turns — handled automatically.
+- **GPT-5.5 / 5.6** can't use tools and reasoning together on the standard
+  endpoint; polyclaude routes them through OpenAI's `/responses` API so you get
+  **both** (tune depth with `--reasoning low|medium|high`).
+- Reasoning models reject non-default sampling params — dropped automatically.
+- Turns that hit the output-token cap are transparently continued.
+
+Run `polyclaude --list` to see everything.
+
+---
+
+## Specialize the agent
+
+Give the agent a persona/use-case with a profile — it's appended to the system
+prompt for the main loop only, so Claude Code's own tooling keeps working:
+
+```bash
+polyclaude --gemini --profile datascience
+polyclaude --openai --profile reviewer
+polyclaude --gemini --profile ./my-profile.md      # your own file
+```
+
+Bundled profiles: `datascience`, `reviewer`, `concise`. Or replace the whole
+system prompt with `--system path/to/file.md`.
+
+---
+
+## How it works
+
+`polyclaude` starts [mitmproxy](https://mitmproxy.org) locally with a small
+addon and points Claude Code at it (via `HTTPS_PROXY` + `NODE_EXTRA_CA_CERTS`,
+scoped to that one process). The addon intercepts requests to
+`api.anthropic.com/v1/messages`, translates the Anthropic request into the
+provider's format, calls the provider, and streams the reply back in Anthropic's
+event format. Every other host is passed straight through untouched.
+
+Only sessions you launch with `polyclaude` are affected — your normal `claude`
+is unchanged and still uses Anthropic.
+
+---
+
+## FAQ
+
+**Does this change my Claude Code install?** No. It only sets proxy environment
+variables for the session it launches.
+
+**Do my keys leave my machine?** Only to the provider you choose (Google,
+OpenAI, etc.), exactly as if you called their API directly. polyclaude has no
+servers.
+
+**Quality feels off on some models.** Different models behave differently inside
+Claude Code's harness (its prompt and tools are tuned for Claude). Larger/newer
+models fare better; try `--reasoning high` on OpenAI and compare providers.
+
+**Can I use my own endpoint?** Yes — anything OpenAI-compatible. Point at it and
+go (OpenRouter, vLLM, LM Studio, etc.).
+
+---
+
+## Notes
+
+For personal and development use, with your own API keys. Respect the terms of
+service of Claude Code and of whichever model provider you use.
+
+## License
+
+MIT © Devesh Pratap

polyclaude-0.1.0/docs/prompts.md

@@ -0,0 +1,47 @@
+# Specializing the system prompt
+
+polyclaude can inject a persona / use-case into the agent's system prompt so the
+same Claude Code becomes a specialized assistant — without editing anything in
+Claude Code itself.
+
+## Profiles
+
+```bash
+polyclaude --gemini --profile datascience
+polyclaude --openai --profile reviewer
+polyclaude --gemini --profile concise
+```
+
+The profile text is **appended** to the system prompt of the **main agent
+loop** only. The lightweight side-calls Claude Code makes (conversation titles,
+summaries, etc.) are left alone, so nothing breaks.
+
+Bundled profiles: `datascience`, `reviewer`, `concise`.
+
+## Your own profile
+
+Point `--profile` at any Markdown file:
+
+```bash
+polyclaude --gemini --profile ./profiles/backend.md
+```
+
+A profile is just plain instructions, e.g.:
+
+```markdown
+# Backend engineer
+You work on a Python + FastAPI + Postgres service. Prefer async, type hints,
+and small pure functions. Always add or update tests for changed behavior.
+```
+
+## Replace the whole system prompt
+
+For full control:
+
+```bash
+polyclaude --gemini --system ./my-system.md
+```
+
+This replaces the main system prompt entirely. Note that Claude Code's built-in
+prompt carries important tool-usage contracts — replacing it wholesale can
+change behavior, so append (a profile) unless you know you want a full swap.

polyclaude-0.1.0/docs/providers.md

@@ -0,0 +1,35 @@
+# Providers & models
+
+polyclaude works with any OpenAI-compatible backend. Presets:
+
+| Provider | Flag | Key env | Base URL | Default model |
+|---|---|---|---|---|
+| Gemini | `--gemini` | `GEMINI_API_KEY` / `GOOGLE_API_KEY` | `generativelanguage.googleapis.com/v1beta/openai` | `gemini-2.5-pro` |
+| OpenAI | `--openai` | `OPENAI_API_KEY` | `api.openai.com/v1` | `gpt-4.1` |
+| Groq | `--groq` | `GROQ_API_KEY` | `api.groq.com/openai/v1` | `llama-3.3-70b-versatile` |
+| OpenRouter | `--openrouter` | `OPENROUTER_API_KEY` | `openrouter.ai/api/v1` | `anthropic/claude-3.5-sonnet` |
+| Ollama | `--ollama` | — | `127.0.0.1:11434/v1` | `qwen2.5-coder` |
+
+Override the model with `--model NAME`.
+
+## Newer models
+
+These work; polyclaude smooths over their API differences:
+
+- **Gemini 3.x** (`gemini-3.1-pro-preview`, `gemini-pro-latest`, …) — thinking
+  models. Their function calls carry a *thought signature* that must be sent
+  back on the next turn or the API rejects it; polyclaude stores and replays it.
+- **GPT-5.x / 5.5 / 5.6** — on `/v1/chat/completions` these refuse to use tools
+  and reasoning at the same time. polyclaude routes `gpt-5.5`/`gpt-5.6` through
+  OpenAI's `/v1/responses` API so you get tools **and** full reasoning; control
+  depth with `--reasoning low|medium|high` (default `high`). Reasoning items are
+  round-tripped across turns.
+- **o-series / any reasoning model** — non-default `temperature`/`top_p` are
+  dropped (they'd be rejected).
+
+## Tips
+
+- `--reasoning` only affects OpenAI reasoning models routed via `/responses`.
+- Free Groq keys have low per-minute token limits; large contexts may 429.
+- For a fully local, no-key setup: install Ollama, `ollama pull qwen2.5-coder`,
+  then `polyclaude --ollama`.

polyclaude-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "polyclaude"
+version = "0.1.0"
+description = "Use OpenAI, Gemini, and any OpenAI-compatible model inside the Claude Code CLI."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Devesh Pratap", email = "mail2deveshpratap@gmail.com" }]
+keywords = ["claude-code", "claude", "openai", "gemini", "gpt", "llm", "cli", "anthropic", "proxy", "coding-agent"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Build Tools",
+]
+dependencies = ["mitmproxy>=10"]
+
+[project.urls]
+Homepage = "https://github.com/ibedevesh/polyclaude"
+Repository = "https://github.com/ibedevesh/polyclaude"
+Issues = "https://github.com/ibedevesh/polyclaude/issues"
+
+[project.scripts]
+polyclaude = "polyclaude.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/polyclaude"]

polyclaude-0.1.0/src/polyclaude/__init__.py

@@ -0,0 +1,3 @@
+"""polyclaude — use OpenAI, Gemini, and any OpenAI-compatible model in Claude Code."""
+
+__version__ = "0.1.0"

polyclaude-0.1.0/src/polyclaude/bridge.py

@@ -0,0 +1,466 @@
+"""
+polyclaude bridge — a mitmproxy addon that answers Claude Code's Anthropic
+Messages API requests from an OpenAI-compatible backend (OpenAI, Gemini, Groq,
+OpenRouter, Ollama, …), translating both directions on the wire.
+
+Claude Code is unmodified. It sends its turn to api.anthropic.com/v1/messages;
+this addon intercepts that request, translates it to the backend's format,
+calls the backend, and translates the reply back into the exact Anthropic
+streaming (SSE) grammar Claude Code expects.
+
+Configured entirely via POLYCLAUDE_* environment variables (set by the CLI):
+    POLYCLAUDE_BASE            backend base URL (…/v1)
+    POLYCLAUDE_MODEL           main-loop model
+    POLYCLAUDE_SMALL           model for the lightweight side-calls (titles etc.)
+    POLYCLAUDE_KEY             API key for the backend
+    POLYCLAUDE_REASONING       OpenAI reasoning effort: low|medium|high (default high)
+    POLYCLAUDE_AUTOCONTINUE    1 = stitch a turn truncated at the token cap
+    POLYCLAUDE_MAXTOK          output cap (default 32768)
+    POLYCLAUDE_SYSTEM_APPEND_FILE   append this file to the main system prompt
+    POLYCLAUDE_SYSTEM_REPLACE_FILE  replace the main system prompt with this file
+    POLYCLAUDE_LOG             optional path to a wire log
+"""
+import json
+import os
+import ssl
+import urllib.error
+import urllib.request
+
+from mitmproxy import http
+
+BASE = os.environ.get("POLYCLAUDE_BASE", "").rstrip("/")
+MODEL = os.environ.get("POLYCLAUDE_MODEL", "gpt-4.1")
+SMALL = os.environ.get("POLYCLAUDE_SMALL", MODEL)
+API_KEY = os.environ.get("POLYCLAUDE_KEY", "")
+REASONING = os.environ.get("POLYCLAUDE_REASONING", "high")
+AUTOCONT = os.environ.get("POLYCLAUDE_AUTOCONTINUE", "1") == "1"
+MAX_TOK = int(os.environ.get("POLYCLAUDE_MAXTOK", "32768"))
+MAXCONT = int(os.environ.get("POLYCLAUDE_MAXCONT", "4"))
+LOG = os.environ.get("POLYCLAUDE_LOG", "")
+
+_ssl_ctx = ssl.create_default_context()
+try:
+    import certifi
+    _ssl_ctx = ssl.create_default_context(cafile=certifi.where())
+except Exception:
+    pass
+
+
+def _read_file(var):
+    p = os.environ.get(var, "")
+    if not p:
+        return ""
+    try:
+        with open(os.path.expanduser(p)) as f:
+            return f.read().strip()
+    except Exception:
+        return ""
+
+
+SYS_APPEND = _read_file("POLYCLAUDE_SYSTEM_APPEND_FILE")
+SYS_REPLACE = _read_file("POLYCLAUDE_SYSTEM_REPLACE_FILE")
+
+# per-tool-call state that must round-trip across turns
+_SIG = {}   # Gemini 3.x thought_signature, keyed by tool-call id
+_RSN = {}   # OpenAI /responses reasoning items, keyed by tool-call id
+
+
+def _log(m):
+    if LOG:
+        try:
+            with open(LOG, "a") as f:
+                f.write(m + "\n")
+        except Exception:
+            pass
+
+
+def _is_messages(flow):
+    return (flow.request.pretty_host.endswith("api.anthropic.com")
+            and "/v1/messages" in flow.request.path
+            and not flow.request.path.endswith("count_tokens"))
+
+
+def _is_count(flow):
+    return (flow.request.pretty_host.endswith("api.anthropic.com")
+            and flow.request.path.endswith("count_tokens"))
+
+
+def _pick_model(anthropic_model):
+    return SMALL if "haiku" in (anthropic_model or "") else MODEL
+
+
+def _is_main_loop(body):
+    m = body.get("model", "")
+    tools = {t.get("name") for t in body.get("tools", []) if isinstance(t, dict)}
+    return ("opus" in m) or ("sonnet" in m) or ("Bash" in tools) or ("Edit" in tools)
+
+
+def _sys_to_str(system):
+    if isinstance(system, str):
+        return system
+    if isinstance(system, list):
+        return "\n\n".join(b.get("text", "") for b in system
+                           if isinstance(b, dict) and b.get("type") == "text")
+    return ""
+
+
+def _apply_prompt_override(body):
+    """Append/replace the main-loop system prompt from the configured files."""
+    if not (SYS_APPEND or SYS_REPLACE) or not _is_main_loop(body):
+        return
+    sysv = body.get("system")
+    if SYS_REPLACE:
+        body["system"] = SYS_REPLACE
+    elif SYS_APPEND:
+        if isinstance(sysv, str):
+            body["system"] = sysv + "\n\n" + SYS_APPEND
+        elif isinstance(sysv, list):
+            sysv.append({"type": "text", "text": "\n\n" + SYS_APPEND})
+        else:
+            body["system"] = SYS_APPEND
+
+
+# ---------------------------------------------------------------------------
+# Anthropic request -> OpenAI chat/completions request
+# ---------------------------------------------------------------------------
+def _to_openai(body):
+    msgs = []
+    system = _sys_to_str(body.get("system", ""))
+    if system:
+        msgs.append({"role": "system", "content": system})
+
+    for m in body.get("messages", []):
+        role = m.get("role")
+        content = m.get("content")
+        if isinstance(content, str):
+            msgs.append({"role": role, "content": content})
+            continue
+        text_parts, tool_calls, tool_results = [], [], []
+        for blk in content or []:
+            if not isinstance(blk, dict):
+                continue
+            bt = blk.get("type")
+            if bt == "text":
+                text_parts.append(blk.get("text", ""))
+            elif bt == "tool_use":
+                tc = {"id": blk.get("id"), "type": "function",
+                      "function": {"name": blk.get("name"),
+                                   "arguments": json.dumps(blk.get("input", {}))}}
+                sig = _SIG.get(blk.get("id"))
+                if sig:
+                    tc["extra_content"] = {"google": {"thought_signature": sig}}
+                tool_calls.append(tc)
+            elif bt == "tool_result":
+                rc = blk.get("content")
+                if isinstance(rc, list):
+                    rc = "".join(x.get("text", "") for x in rc
+                                 if isinstance(x, dict))
+                elif not isinstance(rc, str):
+                    rc = json.dumps(rc)
+                tool_results.append((blk.get("tool_use_id"), rc or ""))
+            elif bt == "image":
+                text_parts.append("[image omitted]")
+        if role == "assistant":
+            am = {"role": "assistant", "content": "\n".join(text_parts) or None}
+            if tool_calls:
+                am["tool_calls"] = tool_calls
+            msgs.append(am)
+        else:
+            for tid, rc in tool_results:
+                msgs.append({"role": "tool", "tool_call_id": tid, "content": rc})
+            if text_parts:
+                msgs.append({"role": "user", "content": "\n".join(text_parts)})
+
+    tgt = _pick_model(body.get("model", ""))
+    out = {"model": tgt, "messages": msgs,
+           "max_completion_tokens": min(int(body.get("max_tokens", MAX_TOK)),
+                                        MAX_TOK)}
+    reasoning = tgt.startswith(("gpt-5", "gpt-6", "o1", "o3", "o4"))
+    if not reasoning:
+        if body.get("temperature") is not None:
+            out["temperature"] = body["temperature"]
+        if body.get("top_p") is not None:
+            out["top_p"] = body["top_p"]
+    if body.get("stop_sequences"):
+        out["stop"] = body["stop_sequences"]
+
+    fn_tools = [{"type": "function",
+                 "function": {"name": t.get("name"),
+                              "description": t.get("description", ""),
+                              "parameters": t.get("input_schema",
+                                                  {"type": "object"})}}
+                for t in (body.get("tools") or []) if "input_schema" in t]
+    if fn_tools:
+        out["tools"] = fn_tools
+        tc = body.get("tool_choice") or {}
+        tt = tc.get("type")
+        out["tool_choice"] = ("required" if tt == "any"
+                              else {"type": "function",
+                                    "function": {"name": tc["name"]}}
+                              if tt == "tool" and tc.get("name") else "auto")
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Anthropic request -> OpenAI /responses request (tools + full reasoning)
+# ---------------------------------------------------------------------------
+def _to_responses(body):
+    inp, seen = [], set()
+    for m in body.get("messages", []):
+        role = m.get("role")
+        content = m.get("content")
+        if isinstance(content, str):
+            inp.append({"role": role, "content": content})
+            continue
+        buf = []
+        if role == "assistant":
+            for blk in content or []:
+                bt = blk.get("type") if isinstance(blk, dict) else None
+                if bt == "text":
+                    buf.append(blk.get("text", ""))
+                elif bt == "tool_use":
+                    if buf:
+                        inp.append({"role": "assistant", "content": "\n".join(buf)})
+                        buf = []
+                    for r in _RSN.get(blk.get("id"), []):
+                        rid = r.get("id")
+                        if rid and rid not in seen:
+                            inp.append(r)
+                            seen.add(rid)
+                    inp.append({"type": "function_call",
+                                "call_id": blk.get("id"), "name": blk.get("name"),
+                                "arguments": json.dumps(blk.get("input", {}))})
+            if buf:
+                inp.append({"role": "assistant", "content": "\n".join(buf)})
+        else:
+            for blk in content or []:
+                bt = blk.get("type") if isinstance(blk, dict) else None
+                if bt == "text":
+                    buf.append(blk.get("text", ""))
+                elif bt == "image":
+                    buf.append("[image omitted]")
+                elif bt == "tool_result":
+                    rc = blk.get("content")
+                    if isinstance(rc, list):
+                        rc = "".join(x.get("text", "") for x in rc
+                                     if isinstance(x, dict))
+                    elif not isinstance(rc, str):
+                        rc = json.dumps(rc)
+                    inp.append({"type": "function_call_output",
+                                "call_id": blk.get("tool_use_id"),
+                                "output": rc or ""})
+            if buf:
+                inp.append({"role": "user", "content": "\n".join(buf)})
+
+    out = {"model": _pick_model(body.get("model", "")), "input": inp,
+           "store": False, "reasoning": {"effort": REASONING},
+           "include": ["reasoning.encrypted_content"],
+           "max_output_tokens": min(int(body.get("max_tokens", MAX_TOK)),
+                                    MAX_TOK)}
+    instr = _sys_to_str(body.get("system", ""))
+    if instr:
+        out["instructions"] = instr
+    fn = [{"type": "function", "name": t.get("name"),
+           "description": t.get("description", ""),
+           "parameters": t.get("input_schema", {"type": "object"})}
+          for t in (body.get("tools") or []) if "input_schema" in t]
+    if fn:
+        out["tools"] = fn
+        tc = body.get("tool_choice") or {}
+        tt = tc.get("type")
+        out["tool_choice"] = ("required" if tt == "any"
+                              else {"type": "function", "name": tc["name"]}
+                              if tt == "tool" and tc.get("name") else "auto")
+    return out
+
+
+def _use_responses(tgt):
+    return "openai.com" in BASE and (
+        os.environ.get("POLYCLAUDE_RESPONSES_FORCE") == "1"
+        or tgt.startswith("gpt-5.6") or tgt.startswith("gpt-5.5"))
+
+
+# ---------------------------------------------------------------------------
+# HTTP to the backend
+# ---------------------------------------------------------------------------
+def _post(path, payload, timeout):
+    req = urllib.request.Request(
+        f"{BASE}/{path}", data=json.dumps(payload).encode(),
+        headers={"Authorization": f"Bearer {API_KEY}",
+                 "Content-Type": "application/json",
+                 "Accept": "application/json",
+                 "User-Agent": "polyclaude/0.1"},
+        method="POST")
+    with urllib.request.urlopen(req, timeout=timeout, context=_ssl_ctx) as r:
+        return json.loads(r.read())
+
+
+def _chat(payload):
+    oai = _post("chat/completions", payload, 120)
+    if not AUTOCONT:
+        return oai
+    for _ in range(MAXCONT):
+        ch = (oai.get("choices") or [{}])[0]
+        msg = ch.get("message", {})
+        if ch.get("finish_reason") != "length" or msg.get("tool_calls"):
+            break
+        cont = dict(payload)
+        cont["messages"] = payload["messages"] + [
+            {"role": "assistant", "content": msg.get("content") or ""},
+            {"role": "user", "content": "continue"}]
+        nxt = _post("chat/completions", cont, 120)
+        nmsg = (nxt.get("choices") or [{}])[0].get("message", {})
+        oai["choices"][0]["message"]["content"] = \
+            (msg.get("content") or "") + (nmsg.get("content") or "")
+        oai["choices"][0]["finish_reason"] = \
+            (nxt.get("choices") or [{}])[0].get("finish_reason")
+        if nmsg.get("tool_calls"):
+            oai["choices"][0]["message"]["tool_calls"] = nmsg["tool_calls"]
+        payload = cont
+    return oai
+
+
+def _responses_to_oai(resp):
+    text, tool_calls, pending = "", [], []
+    for it in resp.get("output", []):
+        t = it.get("type")
+        if t == "reasoning":
+            pending.append(it)
+        elif t == "message":
+            for c in it.get("content", []):
+                if c.get("type") == "output_text":
+                    text += c.get("text", "")
+            pending = []
+        elif t == "function_call":
+            cid = it.get("call_id") or it.get("id")
+            tool_calls.append({"id": cid, "type": "function",
+                               "function": {"name": it.get("name"),
+                                            "arguments": it.get("arguments") or "{}"}})
+            if pending:
+                _RSN[cid] = list(pending)
+    reason = (resp.get("incomplete_details") or {}).get("reason")
+    finish = ("tool_calls" if tool_calls
+              else "length" if reason == "max_output_tokens" else "stop")
+    u = resp.get("usage", {})
+    return {"id": resp.get("id", "msg"),
+            "choices": [{"message": {"content": text, "tool_calls": tool_calls},
+                         "finish_reason": finish}],
+            "usage": {"prompt_tokens": u.get("input_tokens", 0),
+                      "completion_tokens": u.get("output_tokens", 0)}}
+
+
+# ---------------------------------------------------------------------------
+# OpenAI response -> Anthropic SSE
+# ---------------------------------------------------------------------------
+def _sse(event, data):
+    return f"event: {event}\ndata: {json.dumps(data)}\n\n".encode()
+
+
+_STOP = {"stop": "end_turn", "length": "max_tokens",
+         "tool_calls": "tool_use", "content_filter": "end_turn"}
+
+
+def _to_sse(oai, anthropic_model):
+    ch = (oai.get("choices") or [{}])[0]
+    msg = ch.get("message", {})
+    text = msg.get("content") or ""
+    tool_calls = msg.get("tool_calls") or []
+    finish = ch.get("finish_reason", "stop")
+    usage = oai.get("usage", {})
+    out = b""
+    out += _sse("message_start", {"type": "message_start", "message": {
+        "id": oai.get("id", "msg"), "type": "message", "role": "assistant",
+        "model": anthropic_model, "content": [], "stop_reason": None,
+        "stop_sequence": None,
+        "usage": {"input_tokens": usage.get("prompt_tokens", 0),
+                  "output_tokens": 0}}})
+    out += _sse("ping", {"type": "ping"})
+    idx = 0
+    if text:
+        out += _sse("content_block_start", {"type": "content_block_start",
+                    "index": idx, "content_block": {"type": "text", "text": ""}})
+        out += _sse("content_block_delta", {"type": "content_block_delta",
+                    "index": idx,
+                    "delta": {"type": "text_delta", "text": text}})
+        out += _sse("content_block_stop",
+                    {"type": "content_block_stop", "index": idx})
+        idx += 1
+    for tc in tool_calls:
+        fn = tc.get("function", {})
+        tid = tc.get("id", f"toolu_{idx}")
+        sig = (((tc.get("extra_content") or {}).get("google") or {})
+               .get("thought_signature"))
+        if sig:
+            _SIG[tid] = sig
+        out += _sse("content_block_start", {"type": "content_block_start",
+                    "index": idx,
+                    "content_block": {"type": "tool_use", "id": tid,
+                                      "name": fn.get("name"), "input": {}}})
+        out += _sse("content_block_delta", {"type": "content_block_delta",
+                    "index": idx,
+                    "delta": {"type": "input_json_delta",
+                              "partial_json": fn.get("arguments") or "{}"}})
+        out += _sse("content_block_stop",
+                    {"type": "content_block_stop", "index": idx})
+        idx += 1
+    stop = "tool_use" if tool_calls else _STOP.get(finish, "end_turn")
+    out += _sse("message_delta", {"type": "message_delta",
+                "delta": {"stop_reason": stop, "stop_sequence": None},
+                "usage": {"output_tokens": usage.get("completion_tokens", 0)}})
+    out += _sse("message_stop", {"type": "message_stop"})
+    return out
+
+
+def _error_sse(model, message):
+    return _to_sse({"id": "err", "choices": [{"message": {
+        "content": f"[polyclaude error] {message}"},
+        "finish_reason": "stop"}], "usage": {}}, model)
+
+
+# ---------------------------------------------------------------------------
+# mitmproxy hook
+# ---------------------------------------------------------------------------
+class Bridge:
+    def request(self, flow: http.HTTPFlow):
+        if _is_count(flow):
+            try:
+                body = json.loads(flow.request.content or b"{}")
+            except Exception:
+                body = {}
+            flow.response = http.Response.make(
+                200, json.dumps({"input_tokens": len(json.dumps(body)) // 4}
+                                ).encode(), {"content-type": "application/json"})
+            return
+        if not _is_messages(flow):
+            return
+        try:
+            body = json.loads(flow.request.content or b"{}")
+        except Exception:
+            return
+        model = body.get("model", "claude-opus")
+        _apply_prompt_override(body)
+        tgt = _pick_model(model)
+        _log(f"\n=== {model} -> {tgt}  tools={len(body.get('tools') or [])} "
+             f"msgs={len(body.get('messages', []))} ===")
+        try:
+            if _use_responses(tgt):
+                oai = _responses_to_oai(_post("responses", _to_responses(body), 300))
+                _log(f">>> via /responses (reasoning={REASONING})")
+            else:
+                oai = _chat(_to_openai(body))
+            ch = (oai.get("choices") or [{}])[0]
+            _log(f">>> finish={ch.get('finish_reason')} "
+                 f"usage={oai.get('usage', {})}")
+            sse = _to_sse(oai, model)
+        except urllib.error.HTTPError as e:
+            detail = e.read().decode(errors="replace")[:400]
+            _log(f"!!! backend {e.code}: {detail}")
+            sse = _error_sse(model, f"backend {e.code}: {detail}")
+        except Exception as e:
+            _log(f"!!! {e!r}")
+            sse = _error_sse(model, repr(e))
+        flow.response = http.Response.make(
+            200, sse, {"content-type": "text/event-stream; charset=utf-8"})
+
+
+addons = [Bridge()]

polyclaude-0.1.0/src/polyclaude/cli.py

@@ -0,0 +1,206 @@
+"""polyclaude CLI — start the bridge and launch Claude Code on a chosen model."""
+import argparse
+import atexit
+import importlib.util
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from . import __version__
+from .providers import PROVIDERS
+
+CA = Path.home() / ".mitmproxy" / "mitmproxy-ca-cert.pem"
+
+
+def _die(msg, code=1):
+    print(f"polyclaude: {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+def _find(exe):
+    """Locate an executable, preferring the one next to our interpreter."""
+    local = Path(sys.executable).parent / exe
+    if local.exists():
+        return str(local)
+    return shutil.which(exe)
+
+
+def _resolve_key(prov):
+    for var in prov["key_env"]:
+        v = os.environ.get(var)
+        if v:
+            return v
+    return None
+
+
+def _profile_path(name):
+    # a path wins; otherwise look up a bundled profile by name
+    if os.path.sep in name or name.endswith(".md"):
+        p = Path(name).expanduser()
+        return str(p) if p.exists() else None
+    bundled = Path(__file__).parent / "profiles" / f"{name}.md"
+    return str(bundled) if bundled.exists() else None
+
+
+def _free_port(start):
+    for p in range(start, start + 40):
+        with socket.socket() as s:
+            if s.connect_ex(("127.0.0.1", p)) != 0:
+                return p
+    return start
+
+
+def _wait_listen(port, timeout=25):
+    end = time.time() + timeout
+    while time.time() < end:
+        with socket.socket() as s:
+            if s.connect_ex(("127.0.0.1", port)) == 0:
+                return True
+        time.sleep(0.2)
+    return False
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    passthrough = []
+    if "--" in argv:
+        i = argv.index("--")
+        passthrough = argv[i + 1:]
+        argv = argv[:i]
+
+    ap = argparse.ArgumentParser(
+        prog="polyclaude",
+        description="Use OpenAI, Gemini, and any OpenAI-compatible model in Claude Code.",
+        epilog="Examples:\n"
+               "  polyclaude --gemini\n"
+               "  polyclaude --openai --model gpt-4.1\n"
+               "  polyclaude --gemini --profile datascience\n"
+               "  polyclaude --openai -- -p \"one-shot prompt\"",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    g = ap.add_mutually_exclusive_group()
+    for name in PROVIDERS:
+        g.add_argument(f"--{name}", dest="provider", action="store_const",
+                       const=name, help=f"use {name}")
+    ap.add_argument("--provider", dest="provider2",
+                    help="provider name (alternative to the flags above)")
+    ap.add_argument("--model", help="model override")
+    ap.add_argument("--profile", help="specialize the system prompt "
+                    "(bundled name or path to a .md file)")
+    ap.add_argument("--system", help="replace the whole main system prompt with this file")
+    ap.add_argument("--reasoning", choices=["low", "medium", "high"],
+                    help="OpenAI reasoning depth (default high)")
+    ap.add_argument("--port", type=int, default=8118, help="proxy port (default 8118)")
+    ap.add_argument("--list", action="store_true", help="list providers and exit")
+    ap.add_argument("--verbose", action="store_true", help="print the wire log path")
+    ap.add_argument("--version", action="version",
+                    version=f"polyclaude {__version__}")
+    args = ap.parse_args(argv)
+
+    if args.list:
+        for n, p in PROVIDERS.items():
+            key = (p["key_env"][0] if p["key_env"] else "(none)")
+            print(f"  --{n:<11} default {p['model']:<28} key: {key}")
+        return
+
+    provider = args.provider or args.provider2 or "gemini"
+    if provider not in PROVIDERS:
+        _die(f"unknown provider '{provider}'. Try: {', '.join(PROVIDERS)}")
+    prov = PROVIDERS[provider]
+
+    key = _resolve_key(prov)
+    if prov["key_env"] and not key:
+        _die(f"no API key found. Set one of {prov['key_env']} in your "
+             f"environment.\n  {prov['help']}")
+
+    claude = shutil.which("claude")
+    if not claude:
+        _die("the `claude` CLI is not installed or not on PATH.\n"
+             "  Install: https://docs.claude.com/claude-code")
+    mitmdump = _find("mitmdump")
+    if not mitmdump:
+        _die("mitmproxy not found (it is a dependency; try reinstalling polyclaude).")
+
+    bridge = importlib.util.find_spec("polyclaude.bridge").origin
+    model = args.model or prov["model"]
+    port = _free_port(args.port)
+    log = "/tmp/polyclaude.log"
+
+    env = os.environ.copy()
+    env.update({
+        "POLYCLAUDE_BASE": prov["base"],
+        "POLYCLAUDE_MODEL": model,
+        "POLYCLAUDE_SMALL": prov["small"],
+        "POLYCLAUDE_KEY": key or "none",
+        "POLYCLAUDE_REASONING": args.reasoning or "high",
+        "POLYCLAUDE_AUTOCONTINUE": "1",
+        "POLYCLAUDE_LOG": log,
+    })
+    if args.system:
+        sp = Path(args.system).expanduser()
+        if not sp.exists():
+            _die(f"--system file not found: {args.system}")
+        env["POLYCLAUDE_SYSTEM_REPLACE_FILE"] = str(sp)
+    elif args.profile:
+        pp = _profile_path(args.profile)
+        if not pp:
+            avail = ", ".join(sorted(
+                p.stem for p in (Path(__file__).parent / "profiles").glob("*.md")))
+            _die(f"unknown profile '{args.profile}'. Bundled: {avail} "
+                 f"(or pass a path to a .md file)")
+        env["POLYCLAUDE_SYSTEM_APPEND_FILE"] = pp
+
+    # a proxy env must NOT leak into the proxy's own upstream call
+    for v in ("HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy"):
+        env.pop(v, None)
+
+    print(f"polyclaude {__version__}  ·  {provider}  ·  {model}")
+    open(log, "w").close()
+    proxy = subprocess.Popen(
+        [mitmdump, "-q", "-s", bridge, "--listen-host", "127.0.0.1",
+         "--listen-port", str(port), "--allow-hosts", r"anthropic\.com"],
+        env=env, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    def _cleanup():
+        if proxy.poll() is None:
+            proxy.terminate()
+            try:
+                proxy.wait(timeout=5)
+            except Exception:
+                proxy.kill()
+    atexit.register(_cleanup)
+
+    if not _wait_listen(port):
+        _cleanup()
+        _die("the bridge proxy did not start in time.")
+    # mitmproxy creates its CA on first start; wait for it
+    for _ in range(50):
+        if CA.exists():
+            break
+        time.sleep(0.1)
+    if not CA.exists():
+        _cleanup()
+        _die("mitmproxy CA not found; run `mitmdump` once to generate it, then retry.")
+
+    if args.verbose:
+        print(f"  wire log: tail -f {log}")
+    print(f"  launching Claude Code (Ctrl-C to exit)\n")
+
+    run_env = os.environ.copy()
+    run_env["HTTPS_PROXY"] = f"http://127.0.0.1:{port}"
+    run_env["NODE_EXTRA_CA_CERTS"] = str(CA)
+    run_env.setdefault("ANTHROPIC_API_KEY", "sk-polyclaude-bridge")
+    cmd = [claude, *passthrough]
+    try:
+        rc = subprocess.call(cmd, env=run_env)
+    except KeyboardInterrupt:
+        rc = 130
+    _cleanup()
+    sys.exit(rc)
+
+
+if __name__ == "__main__":
+    main()

polyclaude-0.1.0/src/polyclaude/profiles/concise.md

@@ -0,0 +1,6 @@
+# Concise
+
+Be terse. Lead with the answer or the change. No preamble, no restating the
+question, no filler. Minimal explanation unless asked. Prefer diffs, commands,
+and short bullet points over prose. If a one-line answer is correct, give exactly
+one line.

polyclaude-0.1.0/src/polyclaude/profiles/datascience.md

@@ -0,0 +1,18 @@
+# Data Science specialist
+
+You are operating as a senior data scientist / ML engineer. Bias all work toward:
+
+- **Stack**: pandas / polars, numpy, scikit-learn, statsmodels, PyTorch; notebooks
+  and reproducible scripts.
+- **Inspect before you model**: check shapes, dtypes, missingness, duplicates,
+  class balance, and target leakage before touching a model — and say what you saw.
+- **Reproducibility**: set random seeds, pin the split, log versions.
+- **Sound statistics**: state assumptions; prefer effect sizes and confidence
+  intervals over bare p-values; avoid p-hacking and multiple-comparison traps.
+- **Honest evaluation**: hold out data, cross-validate, pick the metric that
+  matches the goal, check calibration and error slices — never present train-set
+  performance as if it generalizes.
+- **Performance**: vectorize; be memory-aware on large frames; prefer
+  chunking/streaming for big data.
+- **Communication**: clear plots (labeled axes + units), short tradeoff notes,
+  runnable code. Never claim things about data you have not inspected.

polyclaude-0.1.0/src/polyclaude/profiles/reviewer.md

@@ -0,0 +1,14 @@
+# Code reviewer
+
+You are a senior code reviewer. When reviewing or writing code:
+
+- Prioritize correctness, then readability, then performance.
+- Flag real defects with the exact file:line and a concrete failure scenario
+  (inputs → wrong output), not vague concerns.
+- Watch for: off-by-one and boundary bugs, error/exception handling, resource
+  leaks, race conditions, input validation, and security-sensitive sinks.
+- Prefer the smallest change that fixes the issue; call out unnecessary
+  complexity and suggest simplifications.
+- Distinguish blocking issues from nits, and say which is which.
+- When you change code, match the surrounding style and add tests where they
+  meaningfully reduce risk.

polyclaude-0.1.0/src/polyclaude/providers.py

@@ -0,0 +1,44 @@
+"""Provider presets: base URL, default models, and which env var holds the key.
+
+Defaults are broadly-available models. Override any with `--model NAME`, and
+newer models (Gemini 3.x, GPT-5.x/5.6) work too — the bridge handles their
+quirks automatically.
+"""
+
+PROVIDERS = {
+    "gemini": {
+        "base": "https://generativelanguage.googleapis.com/v1beta/openai",
+        "model": "gemini-2.5-pro",
+        "small": "gemini-2.5-flash",
+        "key_env": ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
+        "help": "Get a key at https://aistudio.google.com/apikey",
+    },
+    "openai": {
+        "base": "https://api.openai.com/v1",
+        "model": "gpt-4.1",
+        "small": "gpt-4.1-mini",
+        "key_env": ["OPENAI_API_KEY"],
+        "help": "Get a key at https://platform.openai.com/api-keys",
+    },
+    "groq": {
+        "base": "https://api.groq.com/openai/v1",
+        "model": "llama-3.3-70b-versatile",
+        "small": "llama-3.1-8b-instant",
+        "key_env": ["GROQ_API_KEY"],
+        "help": "Get a free key at https://console.groq.com/keys",
+    },
+    "openrouter": {
+        "base": "https://openrouter.ai/api/v1",
+        "model": "anthropic/claude-3.5-sonnet",
+        "small": "anthropic/claude-3.5-haiku",
+        "key_env": ["OPENROUTER_API_KEY"],
+        "help": "Get a key at https://openrouter.ai/keys",
+    },
+    "ollama": {
+        "base": "http://127.0.0.1:11434/v1",
+        "model": "qwen2.5-coder",
+        "small": "qwen2.5-coder",
+        "key_env": [],  # local, no key
+        "help": "Install from https://ollama.com and `ollama pull qwen2.5-coder`",
+    },
+}