Trim agents/cliproxyapi surface

Drop unused symbols + the misleading config.example.yaml so the public
shim is just six things: ProxyEndpoint, anthropic_env, openai_env,
openai_yaml_block, is_ready, wait_until_ready.

- Remove gemini_env() — no current consumer.
- Remove spawn_proxy() ctx-manager — proxy always runs out of band on
this deploy (long-lived OAuth state).
- Remove agents/cliproxyapi/config.example.yaml — the real working
config lives in the operator's own ~/.cli-proxy-api/.
- Remove empty agents/common/tasks_md/ scaffolding.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

agents/README.md

@@ -45,7 +45,7 @@ gtb submit figraph --file <printed-path> --agent <my-agent-id>
 
 1. Create `agents/<new_agent>/{__init__.py,runner.py,install.sh,README.md}`.
 2. In `runner.py` import from `agents.cliproxyapi` (one of `anthropic_env`,
-   `openai_env`, `gemini_env`, or `openai_yaml_block` per the agent's SDK).
+   `openai_env`, or `openai_yaml_block` per the agent's SDK).
 3. Use `agents.common.workspace.make_workspace()` for the run dir,
    `agents.common.tasks.task_instruction()` for the task prompt,
    `agents.common.submit.finalize()` for validate+optional-submit.

agents/cliproxyapi/README.md

@@ -16,10 +16,8 @@ from agents.cliproxyapi import (
     ProxyEndpoint,        # where + key (read from env)
     anthropic_env,        # → dict, splice into subprocess env
     openai_env,
-    gemini_env,
     openai_yaml_block,    # → dict, drop into a YAML config
     wait_until_ready,     # TCP probe; raise SystemExit on miss
-    spawn_proxy,          # ctx-manager (opt-in; mostly for CI)
 )
 ```
 
@@ -49,11 +47,6 @@ env = {**os.environ, **openai_env(ep, model="gpt-5.3-codex-spark")}
 Sets `OPENAI_BASE_URL=…/v1`, `OPENAI_API_KEY`, `OPENAI_API_BASE`,
 `OPENAI_MODEL`.
 
-### Gemini SDK
-```python
-env = {**os.environ, **gemini_env(ep, model="gemini-2-pro-preview")}
-```
-
 ### YAML configs (e.g. MLEvolve)
 ```python
 block = openai_yaml_block(ep, model="gpt-5.3-codex-spark")
@@ -69,13 +62,9 @@ config["agent"]["feedback"].update(block)
    git clone https://github.com/router-for-me/CLIProxyAPI && cd CLIProxyAPI
    docker compose up -d        # or: go build -o cliproxy ./cmd/...
    ```
-2. Drop in a config (start from
-   [`config.example.yaml`](config.example.yaml) here):
-   ```bash
-   mkdir -p ~/.cli-proxy-api
-   cp agents/cliproxyapi/config.example.yaml ~/.cli-proxy-api/config.yaml
-   $EDITOR ~/.cli-proxy-api/config.yaml      # set api-keys[0] + aliases
-   ```
+2. Set up the proxy config (`~/.cli-proxy-api/config.yaml`) with one
+   `api-keys:` entry and your upstream Claude / Codex / Gemini OAuth
+   accounts. See the upstream README for the full schema.
 3. Run interactively once to OAuth-log into Claude / Codex / Gemini accounts.
 4. Export client-side env vars:
    ```bash

agents/cliproxyapi/__init__.py

@@ -18,16 +18,14 @@ isn't up, and an opt-in `spawn_proxy()` ctx-manager for one-off testing.
 """
 
 from .endpoint import ProxyEndpoint
-from .env import anthropic_env, gemini_env, openai_env, openai_yaml_block
-from .health import is_ready, spawn_proxy, wait_until_ready
+from .env import anthropic_env, openai_env, openai_yaml_block
+from .health import is_ready, wait_until_ready
 
 __all__ = [
     "ProxyEndpoint",
     "anthropic_env",
-    "gemini_env",
     "openai_env",
     "openai_yaml_block",
     "is_ready",
-    "spawn_proxy",
     "wait_until_ready",
 ]

agents/cliproxyapi/env.py

@@ -1,10 +1,9 @@
 """Build env-var dicts (or YAML-config snippets) that point an SDK at the proxy.
 
-Three SDK shapes are covered today; add more here as agents arrive:
+Two SDK shapes are covered today; add more here as agents arrive:
 
     anthropic_env(ep, model)   → Anthropic SDK / Claude Code CLI
     openai_env(ep, model)      → OpenAI SDK / Codex CLI
-    gemini_env(ep, model)      → google-generativeai SDK / gemini-cli
 
 Plus `openai_yaml_block(ep, model)` for agents whose config files take
 `base_url` / `api_key` / `model` fields directly (e.g. MLEvolve).
@@ -53,22 +52,6 @@ def openai_env(ep: ProxyEndpoint, model: str | None = None) -> dict[str, str]:
     return env
 
 
-def gemini_env(ep: ProxyEndpoint, model: str | None = None) -> dict[str, str]:
-    """Env vars consumed by google-generativeai and gemini-cli.
-
-    The proxy exposes Gemini's `/v1beta/models/.../generateContent` shape on
-    the proxy root — clients prepend nothing.
-    """
-    env = {
-        "GEMINI_API_BASE": ep.base_url(),
-        "GOOGLE_API_KEY": ep.api_key,
-        "GEMINI_API_KEY": ep.api_key,
-    }
-    if model:
-        env["GEMINI_MODEL"] = model
-    return env
-
-
 def openai_yaml_block(ep: ProxyEndpoint, model: str) -> dict[str, str]:
     """Three-key dict for configs that name the proxy directly (e.g. MLEvolve).
 

agents/cliproxyapi/health.py

@@ -1,20 +1,11 @@
-"""Probe and (optionally) spawn the CLIProxyAPI process.
-
-`wait_until_ready` does a TCP connect — endpoint-agnostic, so it works no
-matter which protocol surfaces the proxy version exposes.
-
-`spawn_proxy` is a context manager for tests / one-off CI runs. Most users
-should run the proxy out-of-band: it owns long-lived OAuth tokens and may
-serve other tools besides the testbed.
-"""
+"""TCP-probe the CLIProxyAPI port. Endpoint-agnostic — works regardless of
+which protocol surfaces (Anthropic / OpenAI / Gemini) the proxy version
+exposes."""
 
 from __future__ import annotations
 
-import contextlib
 import socket
-import subprocess
 import time
-from pathlib import Path
 
 from .endpoint import ProxyEndpoint
 
@@ -38,26 +29,3 @@ def wait_until_ready(ep: ProxyEndpoint, timeout: float = 30.0) -> None:
         f"Start it (e.g. `cliproxy --config ~/.cli-proxy-api/config.yaml`) "
         f"and confirm CLIPROXYAPI_HOST / CLIPROXYAPI_PORT."
     )
-
-
-@contextlib.contextmanager
-def spawn_proxy(
-    config_path: str | Path,
-    binary: str = "cliproxy",
-    timeout: float = 30.0,
-):
-    ep = ProxyEndpoint.from_env()
-    proc = subprocess.Popen(
-        [binary, "--config", str(config_path)],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-    )
-    try:
-        wait_until_ready(ep, timeout=timeout)
-        yield ep
-    finally:
-        proc.terminate()
-        try:
-            proc.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proc.kill()