diff --git a/ORCHESTRATION.md b/ORCHESTRATION.md index 3554677..ff7c217 100644 --- a/ORCHESTRATION.md +++ b/ORCHESTRATION.md @@ -14,7 +14,7 @@ Call `list_agents` first and re-read `coordinator` before every dispatch. When the user states a **lasting** preference, persist it with `set_preferences`. Its `instructions` argument replaces the stored text — read the current value first and write the merge. One-off wishes are not preferences. -Workers are reached **only** through Agent Bridge MCP tools (`list_agents`, `dispatch_task`, `wait_task`, `check_task`, `get_result`, `get_transcript`, `cancel_task`, `list_sessions`, `end_session`). If those tools are missing, stop and say so. Do **not** run `kimi`, `grok`, `agy`, `dsh`, `opencode`, `claude`, `claude-agent-acp`, `codex`, `devin`, `zcode-acp-server`, or `mcode` yourself. `git` / `pytest` after a turn is review, not a substitute for dispatch. +Workers are reached **only** through Agent Bridge MCP tools (`list_agents`, `list_models`, `dispatch_task`, `wait_task`, `check_task`, `get_result`, `get_transcript`, `cancel_task`, `list_sessions`, `end_session`). If those tools are missing, stop and say so. Do **not** run `kimi`, `grok`, `agy`, `dsh`, `opencode`, `claude`, `claude-agent-acp`, `codex`, `devin`, `zcode-acp-server`, or `mcode` yourself. `git` / `pytest` after a turn is review, not a substitute for dispatch. ## Step 1 — dispatch, or do it yourself? @@ -49,6 +49,8 @@ In `auto`/`eager`, tell the user after the fact. In `manual`, their explicit req ## How to dispatch +When `dispatch_enabled=true`, use supported workers' `list_models(agent,cwd)` before choosing a model. See SETUP.md for usage details. + 1. `list_agents`. Read `coordinator.mode` / `instructions` / `dispatch_enabled` and `env.proxy` / `env.warnings`. A null proxy on a direct network is normal; if a worker fails with connect errors on a proxied machine, fix `[env.proxy]` instead of retrying. 2. `dispatch_task` with `cwd` = **this conversation's project folder** (absolute). Never the Agent Bridge install path (unless the user is editing Bridge). Never a temp dir. The `message` must be self-contained: background, absolute paths, acceptance criteria, things not to do. Leave `model`/`effort` unset unless you have a reason. - Antigravity: `agy models` slugs; default `gemini-3.7-flash`. diff --git a/ORCHESTRATION.zh-CN.md b/ORCHESTRATION.zh-CN.md index 177f31f..221cef6 100644 --- a/ORCHESTRATION.zh-CN.md +++ b/ORCHESTRATION.zh-CN.md @@ -84,3 +84,7 @@ ACP 失败保留字符串 `error`,并可附带 `failure`。`failure.prompt_may 需要重试去重时,在首次调用 `dispatch_task` 前生成 UUID `request_id`,首次调用就传入。重试须使用同一 ID 和原始参数;首次省略了 `session_id`,重试也保持省略。只在重试时补 ID 无法对首次调用去重。相同参数复用原任务(`reused=true`),不同参数直接拒绝。去重只在同一 Bridge 实例内、原任务仍保留时有效,仍须通过正常派发校验。重启 Bridge、切换实例或清理原任务后不再保留绑定;Worker 的外部副作用不保证 exactly-once。 对另一个 Bridge 实例拥有的任务,`check_task` / `get_result` 从 `state.json` 作答——带 `from_state: true`、`silent_for_sec: null`;`wait_task` / `cancel_task` 仍须由拥有它的实例调用。 + +## 按需查询模型目录 + +当 `dispatch_enabled=true` 时,选择模型前调用支持此功能的 worker 的 `list_models(agent,cwd)`;字段、缓存、effort 映射和会话行为见 SETUP.md。 diff --git a/README.md b/README.md index a419687..174f83e 100644 --- a/README.md +++ b/README.md @@ -104,6 +104,7 @@ Close coordinators that are holding Bridge, then `agent-bridge upgrade`, then re | Tool | Role | | --- | --- | | `list_agents` | Probe workers, report remaining quota, proxy/env + coordinator policy | +| `list_models` | Discover advertised models for one worker/project, with cached results | | `set_preferences` | Persist coordinator mode / routing preferences | | `dispatch_task` | Start or resume a turn in the project `cwd` | | `wait_task` | Block up to `timeout_sec` (default 180) | @@ -114,6 +115,13 @@ Close coordinators that are holding Bridge, then `agent-bridge upgrade`, then re | `list_sessions` | Known sessions | | `end_session` | Shut down a worker process | +Call `list_models(agent="kimi", cwd="/absolute/project")` to discover a worker's +advertised models before choosing one. Supported workers are Kimi, DSH, +Claude Code, Antigravity, and Codex; check `list_agents.model_discovery` for support. +Results are cached per worker/project for one hour by default. Use +`refresh=true` for an immediate update. See [Model discovery](SETUP.md#model-discovery) +for result fields, configuration, and session behavior. + `get_result` returns up to 60,000 characters per call. Continue with `next_cursor` while `has_more` is true. Detailed work events remain available through `get_transcript` and `~/.agent-bridge/transcripts/`; sparse task diff --git a/SETUP.md b/SETUP.md index eddc7d9..be2cb8b 100644 --- a/SETUP.md +++ b/SETUP.md @@ -446,6 +446,56 @@ uv run --no-sync python scripts/setup_lab.py If a worker is missing, `list_agents` reports `available: false` and the coordinator should pick another worker or do the work itself. +### Model discovery + +`list_agents` includes a `model_discovery` capability block. Query a supported +worker on demand, using this conversation's absolute project directory: + +```text +list_models(agent="kimi", cwd="/absolute/project") +list_models(agent="antigravity", cwd="/absolute/project", refresh=true) +``` + +Supported workers and catalog sources: + +| Worker | Source | +| --- | --- | +| Kimi, DSH, Claude Code | ACP `initialize` / `session/new` | +| Antigravity | `agy models` | +| Codex | app-server `model/list`, using app-server configuration and the worker's `config_overrides` | + +Discovery uses a separate worker process, closed after the lookup. ACP discovery +denies permission requests and may leave an empty session in worker history. +`list_models` is available when `coordinator.dispatch_enabled=true`. + +Result fields: + +| Field | Meaning | +| --- | --- | +| `models` | Advertised choices with `id`, `name`, `is_default`, and `supported_efforts` | +| `default_model` | Default model ID reported by the query session; `null` when unknown | +| `supported_efforts` | Worker-native effort levels for a model; `null` means unknown, `[]` means explicitly no levels | +| `source` | Worker interface used for discovery | +| `agent`, `cwd` | Worker name and resolved project directory | +| `fetched_at`, `cached` | Fetch timestamp and whether this response came from cache | +| `availability="advertised"`, `invocation_verified=false` | Results describe the worker's catalog; successful model invocation is a separate check | +| `effort_vocabulary="worker_native"` | Effort names use the worker's vocabulary | +| `warnings` | Discovery diagnostics | + +For dispatch, pass `off|low|medium|high|max` to `dispatch_task.effort`; +the adapter maps that value to the worker's effort settings. + +```toml +[models] +cache_sec = 3600 # one hour; 0 disables reuse +timeout_sec = 30 # complete lookup deadline, including worker initialization +``` + +The cache is per worker and project, in memory for this Bridge instance. +Expired entries are refreshed on the next query. Use `refresh=true` after +changing accounts, worker configuration, or model access. A failed refresh +returns an error and preserves the last successful cache entry. + The coordinator can pin a worker model and thinking intensity on `dispatch_task`: ```text diff --git a/agents.toml b/agents.toml index e6c1616..0a7178e 100644 --- a/agents.toml +++ b/agents.toml @@ -253,3 +253,8 @@ command = ["codex"] # session_meta = { yolo = true } revivable = true idle_unload_sec = 0 + +# On-demand worker model catalogs. +[models] +cache_sec = 3600 +timeout_sec = 30 diff --git a/scripts/smoke_models.py b/scripts/smoke_models.py new file mode 100644 index 0000000..2b83cf2 --- /dev/null +++ b/scripts/smoke_models.py @@ -0,0 +1,80 @@ +"""Smoke-test list_models through an isolated MCP server. + + uv run python scripts/smoke_models.py --cwd /absolute/project + +Uses a temporary Bridge home under ignored lab/, preserving worker login homes. +ACP may leave empty discovery sessions in the worker's own history. +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import os +import shutil +import sys +import tempfile +from pathlib import Path +from typing import Any + +from mcp.client.session import ClientSession +from mcp.client.stdio import StdioServerParameters, stdio_client + +from agent_bridge.paths import bridge_home + + +def payload(result: Any) -> dict: + structured = result.structured_content + if isinstance(structured, dict): + return structured + for content in result.content: + if getattr(content, "type", None) == "text": + return json.loads(content.text) + raise RuntimeError("MCP result contained no JSON payload") + + +async def run(cwd: Path, agents: list[str], config_home: Path, output: Path | None) -> int: + lab = Path(__file__).resolve().parents[1] / "lab" + lab.mkdir(exist_ok=True) + results = {} + with tempfile.TemporaryDirectory(prefix="model-discovery-", dir=lab) as scratch: + overlay = config_home / "agents.toml" + if overlay.is_file(): + shutil.copyfile(overlay, Path(scratch) / "agents.toml") + params = StdioServerParameters( + command=sys.executable, + args=["-c", "from agent_bridge.server import mcp; mcp.run(transport='stdio')"], + cwd=str(cwd), + env={**os.environ, "AGENT_BRIDGE_HOME": scratch, "AGENT_BRIDGE_PARENT_CONTEXT": ""}, + ) + async with stdio_client(params) as streams, ClientSession(*streams, read_timeout_seconds=120) as session: + await session.initialize() + listing = await session.list_tools() + assert "list_models" in {tool.name for tool in listing.tools} + for agent in agents: + args = {"agent": agent, "cwd": str(cwd)} + discovered = payload(await session.call_tool("list_models", args)) + if discovered.get("ok"): + cached = payload(await session.call_tool("list_models", args)) + assert cached.get("cached") is True + assert cached["models"] == discovered["models"] + results[agent] = discovered + print(json.dumps({"agent": agent, "ok": discovered.get("ok"), + "models": len(discovered.get("models", [])), + "error": discovered.get("error")}, ensure_ascii=False), flush=True) + sessions = payload(await session.call_tool("list_sessions", {})) + assert sessions["sessions"] == [], "Discovery registered a Bridge work session" + if output: + output.write_text(json.dumps(results, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return 0 if all(result.get("ok") for result in results.values()) else 1 + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--cwd", type=Path, required=True) + parser.add_argument("--agents", nargs="+", default=["kimi", "dsh", "claude", "antigravity", "codex"]) + parser.add_argument("--config-home", type=Path, default=bridge_home()) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + raise SystemExit(asyncio.run(run(args.cwd.resolve(), args.agents, args.config_home, args.output))) diff --git a/skills/agent-bridge/SKILL.md b/skills/agent-bridge/SKILL.md index 440fb3c..3159946 100644 --- a/skills/agent-bridge/SKILL.md +++ b/skills/agent-bridge/SKILL.md @@ -5,7 +5,7 @@ description: Coordinate local worker agents (Grok Build, Kimi Code, Antigravity, # Dispatching workers through Agent Bridge -You are the coordinator: users talk only to you, and you call the workers. Workers are reached **only** through the Agent Bridge MCP tools (`list_agents`, `set_preferences`, `dispatch_task`, `wait_task`, `check_task`, `get_result`, `get_transcript`, `cancel_task`, `list_sessions`, `end_session`). If those tools are missing from this session, stop and say so — never run `grok`, `kimi`, `agy`, `dsh`, `opencode`, `claude`, `claude-agent-acp`, `codex`, `devin`, `zcode-acp-server`, or `mcode` CLIs directly, and never drive their GUIs. The same product can be a coordinator and a worker; those are different processes. +You are the coordinator: users talk only to you, and you call the workers. Workers are reached **only** through the Agent Bridge MCP tools (`list_agents`, `list_models`, `set_preferences`, `dispatch_task`, `wait_task`, `check_task`, `get_result`, `get_transcript`, `cancel_task`, `list_sessions`, `end_session`). If those tools are missing from this session, stop and say so — never run `grok`, `kimi`, `agy`, `dsh`, `opencode`, `claude`, `claude-agent-acp`, `codex`, `devin`, `zcode-acp-server`, or `mcode` CLIs directly, and never drive their GUIs. The same product can be a coordinator and a worker; those are different processes. ## Before anything: read the policy @@ -19,6 +19,10 @@ Call `list_agents` first. Its result carries: Claude `status`: shared `5h`/`weekly` only. Before dispatch, even if `ok`, check the target model's `weekly:opus`/`weekly:sonnet`: 0% is exhausted; missing/null unknown. Report reset time or a user-permitted alternative. Model-only data leaves shared status unknown. +## Model discovery + +When `coordinator.dispatch_enabled=true` and `list_agents.model_discovery.supported=true`, use `list_models(agent=..., cwd=...)` to obtain worker-advertised model IDs before explicitly selecting a model. Supply this conversation's absolute project directory; use `refresh=true` after changing accounts or worker configuration. `supported_efforts` reports worker-native levels; pass `off|low|medium|high|max` to `dispatch_task.effort` for adapter mapping. See SETUP.md for result fields, caching, and session behavior. + ## Step 1 — dispatch, or do it yourself? A cost question, not a category question; "it is implementation work" is never by itself a reason to dispatch. diff --git a/src/agent_bridge/adapters/acp.py b/src/agent_bridge/adapters/acp.py index 362342a..568a1e1 100644 --- a/src/agent_bridge/adapters/acp.py +++ b/src/agent_bridge/adapters/acp.py @@ -18,6 +18,7 @@ ClientCapabilities, DeniedOutcome, Implementation, + NewSessionResponse, PermissionOption, RequestPermissionResponse, ) @@ -688,12 +689,140 @@ def __init__(self) -> None: self.pending_warnings: list[str] = [] +class _DiscoveryClient(_BridgeClient): + """ACP discovery client that denies permission requests and discards updates.""" + + async def request_permission( + self, + session_id: str, + tool_call: Any, + options: list[Any] | None, + **kwargs: Any, + ) -> RequestPermissionResponse: + return RequestPermissionResponse(outcome=DeniedOutcome(outcome="cancelled")) + + async def session_update(self, session_id: str, update: Any, **kwargs: Any) -> None: + return None + + +def _acp_model_catalog(response: NewSessionResponse, agent_name: str) -> dict[str, Any]: + """Extract model choices and current-model effort levels from an ACP snapshot.""" + options = response.config_options or [] + model_option_id = next( + (option.id for option in options if option.id == "model" or option.category == "model"), + "model", + ) + current, _offered = config_option_values(options, model_option_id) + + def model_id(value: str) -> str: + return (_dsh_native_model_label(value) or value) if agent_name == "dsh" else value + + default = model_id(current) if current else None + choices = [(model_id(value), name) for value, name in _cursor_choices(options, model_option_id)] + efforts: list[str] | None = None + for option in options: + if option.category == "thought_level" or option.id in { + "thinking", "reasoning_effort", + }: + _current_effort, offered = config_option_values(options, option.id) + # A boolean switch describes thinking enablement, not effort levels. + if offered and set(offered) != {"true", "false"}: + efforts = offered + break + return { + "source": "acp", + "models": [ + { + "id": value, + "name": name, + "is_default": value == default, + "supported_efforts": efforts if value == default else None, + } + for value, name in choices + ], + "default_model": default, + "warnings": [] if choices else [ + "Model discovery is unavailable: the ACP session did not advertise a model catalog." + ], + } + + +async def _cleanup_discovery(live: _Live) -> None: + try: + if live.conn is not None: + with contextlib.suppress(Exception): + await asyncio.wait_for(live.conn.close(), timeout=2) + finally: + try: + if live.proc is not None: + await reap_subprocess(live.proc) + finally: + if live.stderr_task is not None: + live.stderr_task.cancel() + with contextlib.suppress(asyncio.CancelledError): + await live.stderr_task + + class AcpAdapter(Adapter): def __init__(self, agent: AgentConfig, home: Path, env_config=None) -> None: super().__init__(agent, home, env_config) self._live: dict[str, _Live] = {} self._cursor_models_cache: dict[str, str] | None = None + async def list_models(self, cwd: str) -> dict[str, Any]: + """Read a catalog through a separate ACP initialize/session-new handshake. + + The caller controls the deadline; this method closes the process on exit. + """ + if self.agent.name == "dsh": + cmd = resolve_dsh_command(self.agent.command, self.agent.fallback_commands) + else: + cmd = resolve_command(self.agent.command, self.agent.fallback_commands) + env = self._env() + if self.agent.name == "dsh": + cmd, env = prepare_dsh_launch(cmd, env) + env = self._enforce_spawn_env(env) + kwargs: dict[str, Any] = {} + if sys.platform == "win32": + kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP + live = _Live() + try: + live.proc = await asyncio.create_subprocess_exec( + *cmd, + stdin=asyncio.subprocess.PIPE, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + env=env, + cwd=self.agent.cwd or cwd or None, + limit=STDIO_LIMIT, + **kwargs, + ) + proc = live.proc + client = _DiscoveryClient("model-discovery", self.home, permission_policy="deny") + live.conn = connect_to_agent(client, proc.stdin, proc.stdout) + live.stderr_task = asyncio.create_task(self._drain_stderr(proc, "model-discovery", live)) + await live.conn.initialize( + protocol_version=PROTOCOL_VERSION, + client_info=Implementation(name="agent-bridge", version="0.1.0"), + client_capabilities=ClientCapabilities(), + ) + created = await live.conn.new_session(cwd=cwd, mcp_servers=[]) + return _acp_model_catalog(created, self.agent.name) + except Exception as exc: + raise self._failure( + exc, "model_discovery", proc=live.proc, stderr=live.stderr_tail, + ) from None + finally: + # The outer deadline can fire during close(), after the handshake + # already succeeded. Keep cleanup alive and await the reap before + # propagating that cancellation to the registry. + cleanup = asyncio.create_task(_cleanup_discovery(live)) + try: + await asyncio.shield(cleanup) + except asyncio.CancelledError: + await cleanup + raise + def _env(self) -> dict[str, str]: env = build_worker_env(self.agent.env, config=self.env_config, worker_context=True, home=self.home) if self.agent.name == "claude": diff --git a/src/agent_bridge/adapters/antigravity.py b/src/agent_bridge/adapters/antigravity.py index 8795b9f..a92001d 100644 --- a/src/agent_bridge/adapters/antigravity.py +++ b/src/agent_bridge/adapters/antigravity.py @@ -15,6 +15,10 @@ from agent_bridge.adapters.base import STDIO_LIMIT, Adapter from agent_bridge.config import AgentConfig from agent_bridge.diagnostics import redact_diagnostic +from agent_bridge.model_discovery_exec import ( + parse_agy_models_output, + read_agy_models, +) from agent_bridge.models import Session, Task, TurnResult, agy_effort from agent_bridge.processes import ( drop_pid, @@ -243,6 +247,17 @@ def __init__(self, agent: AgentConfig, home: Path, env_config=None) -> None: async def ensure_session(self, session: Session) -> None: return None + async def list_models(self, cwd: str) -> dict[str, Any]: + """Read the catalog from ``agy models`` in the project directory.""" + source = "agy models" + cmd = resolve_command(self.agent.command, self.agent.fallback_commands) + env = self._enforce_spawn_env( + build_worker_env(self.agent.env, config=self.env_config, worker_context=True, home=self.home) + ) + stdout = await read_agy_models(cmd, env=env, cwd=cwd) + return {"source": source, "models": parse_agy_models_output(stdout), + "default_model": None, "warnings": []} + def _build_cmd(self, session: Session, task: Task) -> list[str]: cmd = resolve_command(self.agent.command, self.agent.fallback_commands) model = task.model or session.model diff --git a/src/agent_bridge/adapters/base.py b/src/agent_bridge/adapters/base.py index e4f23b4..841eb02 100644 --- a/src/agent_bridge/adapters/base.py +++ b/src/agent_bridge/adapters/base.py @@ -3,6 +3,7 @@ from abc import ABC, abstractmethod from collections.abc import Mapping from pathlib import Path +from typing import Any from agent_bridge.config import AgentConfig, EnvConfig from agent_bridge.models import Session, Task, TurnResult @@ -32,6 +33,10 @@ def __init__(self, agent: AgentConfig, home: Path, env_config: EnvConfig | None def can_revive(self) -> bool: return self.agent.revivable + async def list_models(self, cwd: str) -> dict[str, Any]: + """Return the worker's advertised model catalog.""" + raise NotImplementedError(f"model discovery is not implemented for {self.agent.name}") + def _enforce_spawn_env(self, env: Mapping[str, str]) -> dict[str, str]: """Last ``env.deny`` gate on the exact env a worker spawn receives. diff --git a/src/agent_bridge/adapters/codex.py b/src/agent_bridge/adapters/codex.py index bca1947..7a656e8 100644 --- a/src/agent_bridge/adapters/codex.py +++ b/src/agent_bridge/adapters/codex.py @@ -20,6 +20,10 @@ yolo_requested, ) from agent_bridge.diagnostics import redact_diagnostic +from agent_bridge.model_discovery_exec import ( + codex_app_server_list_models, + parse_codex_models, +) from agent_bridge.models import Session, Task, TurnResult from agent_bridge.processes import ( drop_pid, @@ -48,6 +52,19 @@ def __init__(self, agent, home: Path, env_config=None) -> None: async def ensure_session(self, session: Session) -> None: return None + async def list_models(self, cwd: str) -> dict[str, Any]: + """Query app-server model/list using its configuration and config_overrides.""" + env = self._enforce_spawn_env(self._worker_env()) + command = await asyncio.to_thread( + resolve_codex_command, self.agent.command, self.agent.fallback_commands, env=env + ) + argv = [*command] + for item in self.agent.config_overrides: + argv += ["-c", item] + argv.append("app-server") + entries = await codex_app_server_list_models(argv, env=env, cwd=cwd) + return parse_codex_models(entries) + def _worker_env(self) -> dict[str, str]: return build_worker_env(self.agent.env, config=self.env_config, worker_context=True, home=self.home) diff --git a/src/agent_bridge/agents.toml b/src/agent_bridge/agents.toml index e6c1616..0a7178e 100644 --- a/src/agent_bridge/agents.toml +++ b/src/agent_bridge/agents.toml @@ -253,3 +253,8 @@ command = ["codex"] # session_meta = { yolo = true } revivable = true idle_unload_sec = 0 + +# On-demand worker model catalogs. +[models] +cache_sec = 3600 +timeout_sec = 30 diff --git a/src/agent_bridge/config.py b/src/agent_bridge/config.py index 78219b3..0979900 100644 --- a/src/agent_bridge/config.py +++ b/src/agent_bridge/config.py @@ -151,6 +151,13 @@ class ServerConfig(BaseModel): idle_exit_sec: int = 0 +class ModelsConfig(BaseModel): + """Cache lifetime and timeout for on-demand model discovery.""" + + cache_sec: float = Field(default=3600.0, ge=0) + timeout_sec: float = Field(default=30.0, gt=0) + + class QuotaConfig(BaseModel): """Remaining-quota lookup that rides along with ``list_agents``. @@ -218,6 +225,7 @@ class AppConfig(BaseModel): server: ServerConfig = Field(default_factory=ServerConfig) coordinator: CoordinatorConfig = Field(default_factory=CoordinatorConfig) quota: QuotaConfig = Field(default_factory=QuotaConfig) + models: ModelsConfig = Field(default_factory=ModelsConfig) warnings: list[str] = Field(default_factory=list) def get(self, name: str) -> AgentConfig: @@ -472,7 +480,7 @@ def load_config(home: Path | None = None) -> AppConfig: f"{overlay_path} is not valid TOML: {exc}. " "Fix or delete the file, then restart the Bridge." ) from exc - supported_sections = {"agents", "env", "server", "coordinator", "quota"} + supported_sections = {"agents", "env", "server", "coordinator", "quota", "models"} unsupported = sorted(set(overlay_raw) - supported_sections) warnings = [] if unsupported: @@ -509,11 +517,19 @@ def load_config(home: Path | None = None) -> AppConfig: coord_raw["mode"] = normalize_coordinator_mode(coord_raw.get("mode")) coordinator = CoordinatorConfig.model_validate(coord_raw) quota = QuotaConfig.model_validate({**_coerce_quota(bundled_raw), **_coerce_quota(overlay_raw)}) + models_raw: dict[str, Any] = {} + for raw in (bundled_raw, overlay_raw): + block = raw.get("models", {}) + if not isinstance(block, dict): + raise ValueError("[models] must be a TOML table") + models_raw.update(block) + models = ModelsConfig.model_validate(models_raw) return AppConfig( agents=agents, env=env, server=server, coordinator=coordinator, quota=quota, + models=models, warnings=warnings, ) diff --git a/src/agent_bridge/model_catalog.py b/src/agent_bridge/model_catalog.py new file mode 100644 index 0000000..8a2ca60 --- /dev/null +++ b/src/agent_bridge/model_catalog.py @@ -0,0 +1,36 @@ +"""Worker-advertised model catalog schemas.""" + +from __future__ import annotations + +from pydantic import BaseModel, Field + +from agent_bridge.config import AgentConfig + + +class ModelInfo(BaseModel): + id: str = Field(min_length=1) + name: str | None = None + is_default: bool = False + # Worker-native levels; null means unknown, [] means explicitly no levels. + supported_efforts: list[str] | None = None + + +class ModelCatalog(BaseModel): + source: str = Field(min_length=1) + models: list[ModelInfo] + # Default model ID advertised by the query session. + default_model: str | None = None + warnings: list[str] = Field(default_factory=list) + + +def model_discovery_capability(cfg: AgentConfig) -> dict: + """Describe model-discovery support for a worker.""" + supported = cfg.protocol in {"agy", "codex"} or ( + cfg.protocol == "acp" and cfg.name in {"kimi", "dsh", "claude"} + ) + source = {"agy": "agy models", "codex": "codex app-server model/list", "acp": "acp session/new"} + return { + "supported": supported, + "source": source.get(cfg.protocol) if supported else None, + "requires_session": supported and cfg.protocol == "acp", + } diff --git a/src/agent_bridge/model_discovery_exec.py b/src/agent_bridge/model_discovery_exec.py new file mode 100644 index 0000000..9d0e2ef --- /dev/null +++ b/src/agent_bridge/model_discovery_exec.py @@ -0,0 +1,168 @@ +"""Worker model catalog discovery and parsing.""" + +from __future__ import annotations + +import asyncio +import contextlib +import re +import subprocess +import sys +from collections.abc import Mapping, Sequence +from typing import Any + +from agent_bridge.diagnostics import redact_diagnostic +from agent_bridge.processes import reap_subprocess +from agent_bridge.quota_codex import CLIENT_INFO, READ_LIMIT, _read_response, _send + +AGY_OUTPUT_LIMIT = 4 * 1024 * 1024 +AGY_STDERR_LIMIT = 16000 +MODEL_LIST_MAX_PAGES = 100 +_ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]") + + +def parse_codex_models(entries: Sequence[Any]) -> dict[str, Any]: + """Map app-server model/list metadata to a worker catalog.""" + models = [] + for entry in entries: + raw_efforts = entry.get("supportedReasoningEfforts") + models.append({ + "id": entry["id"], + "name": entry.get("displayName"), + "is_default": entry.get("isDefault", False), + "supported_efforts": ( + [item["reasoningEffort"] for item in raw_efforts] + if raw_efforts is not None else None + ), + }) + return { + "source": "codex app-server model/list", + "models": models, + "default_model": next((model["id"] for model in models if model["is_default"]), None), + "warnings": [], + } + + +def parse_agy_models_output(stdout: str) -> list[dict[str, Any]]: + """Parse AGY tab-separated model ID and display name lines.""" + models = [] + for line in _ANSI_RE.sub("", stdout).splitlines(): + if not line.strip(): + continue + fields = line.split("\t") + if len(fields) != 2: + raise RuntimeError("Unrecognized agy models output: expected tab-separated ID and name") + ident, name = (field.strip() for field in fields) + if not ident or any(char.isspace() for char in ident) or not name: + raise RuntimeError("Unrecognized agy models output: missing or invalid ID/name") + models.append({"id": ident, "name": name, "is_default": False, "supported_efforts": None}) + if not models: + raise RuntimeError("agy models returned no model catalog") + return models + + +async def _agy_stdout(proc: asyncio.subprocess.Process) -> str: + assert proc.stdout is not None + parts = [] + size = 0 + while chunk := await proc.stdout.read(65536): + size += len(chunk) + if size > AGY_OUTPUT_LIMIT: + raise RuntimeError("agy models exceeded the output limit") + parts.append(chunk) + return b"".join(parts).decode("utf-8", errors="replace") + + +async def _agy_stderr(proc: asyncio.subprocess.Process) -> bytes: + assert proc.stderr is not None + tail = b"" + while chunk := await proc.stderr.read(65536): + tail = (tail + chunk)[-AGY_STDERR_LIMIT:] + return tail + + +async def read_agy_models(command: Sequence[str], *, env: Mapping[str, str], cwd: str) -> str: + """Run agy models; caller owns deadline, this function always reaps its child.""" + kwargs: dict[str, Any] = {} + if sys.platform == "win32": + kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP + proc = await asyncio.create_subprocess_exec( + *command, + "models", + stdin=asyncio.subprocess.DEVNULL, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.PIPE, + env=dict(env), + cwd=cwd, + **kwargs, + ) + stderr = asyncio.create_task(_agy_stderr(proc)) + try: + stdout = await _agy_stdout(proc) + await proc.wait() + diagnostic = (await stderr).decode("utf-8", errors="replace").strip() + if proc.returncode != 0: + raise RuntimeError(f"agy models exited with code {proc.returncode}: {redact_diagnostic(diagnostic)}") + return stdout + finally: + cleanup = asyncio.create_task(reap_subprocess(proc, timeout=2.0)) + try: + await asyncio.shield(cleanup) + except asyncio.CancelledError: + await cleanup + raise + finally: + stderr.cancel() + with contextlib.suppress(asyncio.CancelledError): + await stderr + + +async def codex_app_server_list_models(argv: Sequence[str], *, env: Mapping[str, str], cwd: str) -> list[Any]: + """Read visible pages using the existing Codex stdio request helpers.""" + entries: list[Any] = [] + kwargs: dict[str, Any] = {} + if sys.platform == "win32": + kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP + proc = await asyncio.create_subprocess_exec( + *argv, + stdin=asyncio.subprocess.PIPE, + stdout=asyncio.subprocess.PIPE, + stderr=asyncio.subprocess.DEVNULL, + env=dict(env), + cwd=cwd, + limit=READ_LIMIT, + **kwargs, + ) + try: + await _send(proc, {"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"clientInfo": CLIENT_INFO}}) + await _read_response(proc, 1) + await _send(proc, {"jsonrpc": "2.0", "method": "initialized", "params": {}}) + cursor = None + seen_cursors = set() + for page in range(MODEL_LIST_MAX_PAGES): + params: dict[str, Any] = {"limit": 100, "includeHidden": False} + if cursor: + params["cursor"] = cursor + request_id = page + 2 + await _send(proc, {"jsonrpc": "2.0", "id": request_id, "method": "model/list", "params": params}) + result = await _read_response(proc, request_id) + if not isinstance(result.get("data"), list): + raise RuntimeError("Codex model/list returned missing or malformed data") + entries.extend(result["data"]) + cursor = result.get("nextCursor") + if cursor is None or cursor == "": + return entries + if not isinstance(cursor, str): + raise RuntimeError("Codex model/list returned a malformed nextCursor") + if cursor in seen_cursors: + raise RuntimeError("Codex model/list repeated a pagination cursor") + seen_cursors.add(cursor) + raise RuntimeError("Codex model/list exceeded the page limit") + except Exception as exc: + raise RuntimeError(f"Codex model discovery failed: {redact_diagnostic(str(exc))}") from None + finally: + cleanup = asyncio.create_task(reap_subprocess(proc, timeout=2.0)) + try: + await asyncio.shield(cleanup) + except asyncio.CancelledError: + await cleanup + raise diff --git a/src/agent_bridge/registry.py b/src/agent_bridge/registry.py index 3a3ed69..86b4437 100644 --- a/src/agent_bridge/registry.py +++ b/src/agent_bridge/registry.py @@ -2,6 +2,7 @@ import asyncio import contextlib +import copy import hashlib import json import logging @@ -28,6 +29,7 @@ from agent_bridge.diagnostics import redact_diagnostic from agent_bridge.grok_observe import observe_grok_session from agent_bridge.kimi_observe import observe_kimi_session +from agent_bridge.model_catalog import ModelCatalog, model_discovery_capability from agent_bridge.models import ( DEFAULT_WAIT_SEC, TERMINAL_STATUSES, @@ -115,6 +117,7 @@ ORPHAN_RESULT_MIN_AGE_SEC = 3600 # Persisted request_id bindings kept; bindings also drop with their task. REQUEST_KEEP_MAX = 1000 +MODEL_CACHE_MAX = 128 def _new_id(prefix: str) -> str: @@ -166,6 +169,8 @@ def __init__( # of request tuples so bindings can persist to state.json compactly. self._requests: dict[str, tuple[str, str]] = {} self._adapters: dict[str, Adapter] = {} + self._model_cache: dict[tuple[str, str], tuple[float, dict]] = {} + self._model_locks: dict[str, asyncio.Lock] = {} self._done: dict[str, asyncio.Event] = {} self._idle: dict[str, asyncio.Task[None]] = {} self._bg: dict[str, asyncio.Task[None]] = {} @@ -593,10 +598,54 @@ async def list_agents(self) -> list[dict]: async def describe(cfg: AgentConfig) -> dict: row = await probe_agent(cfg, self.config.env) row["quota"] = await self._quota_for(cfg, available=bool(row.get("available"))) + row["model_discovery"] = model_discovery_capability(cfg) return row return list(await asyncio.gather(*(describe(cfg) for cfg in self.config.agents.values()))) + async def list_models(self, agent: str, cwd: str, *, refresh: bool = False) -> dict: + """Discover and cache a worker's model catalog.""" + if not self.dispatch_enabled: + raise RuntimeError("model discovery is disabled inside worker-inherited Bridge instances") + cfg = self.config.get(agent) + if not model_discovery_capability(cfg)["supported"]: + raise NotImplementedError(f"model discovery is not implemented for {agent}") + path = Path(cwd) + if not path.is_absolute() or not path.is_dir(): + raise ValueError("cwd must be an existing absolute project directory") + resolved = str(path.resolve()) + key = (agent, resolved) + previous = self._model_cache.get(key) + if not refresh and previous and time.monotonic() - previous[0] < self.config.models.cache_sec: + return {**copy.deepcopy(previous[1]), "cached": True} + lock = self._model_locks.setdefault(agent, asyncio.Lock()) + try: + async with asyncio.timeout(self.config.models.timeout_sec), lock: + previous = self._model_cache.get(key) + if not refresh and previous and time.monotonic() - previous[0] < self.config.models.cache_sec: + return {**copy.deepcopy(previous[1]), "cached": True} + adapter = build_adapter(cfg, self.home, self.config.env) + raw = await adapter.list_models(resolved) + catalog = ModelCatalog.model_validate(raw) + result = { + **catalog.model_dump(mode="json"), + "agent": agent, + "cwd": resolved, + "fetched_at": iso(), + "cached": False, + "availability": "advertised", + "invocation_verified": False, + "effort_vocabulary": "worker_native", + } + result["warnings"] = [redact_diagnostic(w) for w in result["warnings"]] + if key not in self._model_cache and len(self._model_cache) >= MODEL_CACHE_MAX: + oldest = min(self._model_cache, key=lambda k: self._model_cache[k][0]) + self._model_cache.pop(oldest) + self._model_cache[key] = (time.monotonic(), copy.deepcopy(result)) + return result + except Exception as exc: + raise RuntimeError(redact_diagnostic(str(exc)) or type(exc).__name__) from None + async def _quota_for(self, cfg: AgentConfig, *, available: bool) -> dict: """The ``quota`` block for one ``list_agents`` row. Never raises, never gates ``available``.""" quota_cfg = self.config.quota diff --git a/src/agent_bridge/server.py b/src/agent_bridge/server.py index 754c6fc..ea6c888 100644 --- a/src/agent_bridge/server.py +++ b/src/agent_bridge/server.py @@ -64,6 +64,9 @@ async def lifespan(_server: MCPServer[Registry]) -> AsyncIterator[Registry]: "or end_session. When " "dispatch_enabled is true and the user states a lasting preference, " "persist it with set_preferences." + " Use list_models(agent, cwd) to discover model IDs before choosing one; " + "list_agents.model_discovery describes support. See the tool description " + "for result semantics and eligibility." ) mcp = MCPServer[Registry]("agent-bridge", instructions=INSTRUCTIONS, lifespan=lifespan) @@ -97,6 +100,15 @@ async def list_agents(ctx: Context) -> dict[str, Any]: return _error(exc) +@mcp.tool(annotations=READ_ONLY) +async def list_models(ctx: Context, agent: str, cwd: str, refresh: bool = False) -> dict[str, Any]: + """List models advertised by a supported worker. Pass this conversation's absolute project directory as cwd. Results are cached per worker/project for one hour by default ([models] cache_sec); refresh=true requests an immediate update. default_model reports the query session's advertised default. supported_efforts reports worker-native levels: null means unknown, [] means explicitly no levels. For dispatch_task.effort, use off|low|medium|high|max for adapter mapping. Available when coordinator.dispatch_enabled=true.""" + try: + return {"ok": True, **await _registry(ctx).list_models(agent, cwd, refresh=refresh)} + except Exception as exc: + return _error(exc) + + @mcp.tool() async def set_preferences( ctx: Context, diff --git a/tests/test_model_catalog.py b/tests/test_model_catalog.py new file mode 100644 index 0000000..224d28b --- /dev/null +++ b/tests/test_model_catalog.py @@ -0,0 +1,184 @@ +from __future__ import annotations + +import asyncio +import types + +import pytest + +from agent_bridge.config import AgentConfig, AppConfig, EnvConfig, ModelsConfig, load_config +from agent_bridge.model_catalog import model_discovery_capability +from agent_bridge.registry import Registry +from agent_bridge.server import list_models + + +@pytest.fixture +def catalog_registry(tmp_path, monkeypatch): + config = AppConfig( + agents={"kimi": AgentConfig(name="kimi", protocol="acp", command=["not-launched"])}, + env=EnvConfig(discover_proxy=False), + ) + registry = Registry(tmp_path / "bridge", config, runtime_context="coordinator") + calls = [] + + class Discovery: + async def list_models(self, cwd): + calls.append(cwd) + await asyncio.sleep(0) + return { + "source": "fake catalog", + "models": [{"id": "small", "is_default": True, "supported_efforts": ["low", "high"]}], + "default_model": "small", + } + + monkeypatch.setattr("agent_bridge.registry.build_adapter", lambda *args: Discovery()) + return registry, calls + + +async def test_cache_refresh_and_defensive_copy(catalog_registry, tmp_path): + registry, calls = catalog_registry + first = await registry.list_models("kimi", str(tmp_path)) + assert first["cached"] is False + first["models"][0]["id"] = "changed by caller" + cached = await registry.list_models("kimi", str(tmp_path)) + assert cached["cached"] is True + assert cached["models"][0]["id"] == "small" + assert cached["availability"] == "advertised" + assert cached["invocation_verified"] is False + assert cached["effort_vocabulary"] == "worker_native" + assert len(calls) == 1 + assert not (await registry.list_models("kimi", str(tmp_path), refresh=True))["cached"] + assert len(calls) == 2 + assert registry.sessions == registry.tasks == registry._adapters == {} + + +async def test_concurrent_queries_share_discovery(catalog_registry, tmp_path): + registry, calls = catalog_registry + results = await asyncio.gather(*(registry.list_models("kimi", str(tmp_path)) for _ in range(5))) + assert len(calls) == 1 + assert sum(not r["cached"] for r in results) == 1 + + +async def test_cache_scope_and_expiry(catalog_registry, tmp_path, monkeypatch): + registry, calls = catalog_registry + clock = [1000.0] + monkeypatch.setattr("agent_bridge.registry.time.monotonic", lambda: clock[0]) + await registry.list_models("kimi", str(tmp_path)) + clock[0] += 3599 + assert (await registry.list_models("kimi", str(tmp_path)))["cached"] + clock[0] += 2 + assert not (await registry.list_models("kimi", str(tmp_path)))["cached"] + other = tmp_path / "other" + other.mkdir() + await registry.list_models("kimi", str(other)) + assert len(calls) == 3 + + +async def test_failed_refresh_is_explicit_and_preserves_cache(catalog_registry, tmp_path, monkeypatch): + registry, _ = catalog_registry + await registry.list_models("kimi", str(tmp_path)) + + class Broken: + async def list_models(self, cwd): + raise RuntimeError("Authorization: Bearer catalog-secret") + + monkeypatch.setattr("agent_bridge.registry.build_adapter", lambda *args: Broken()) + with pytest.raises(RuntimeError) as caught: + await registry.list_models("kimi", str(tmp_path), refresh=True) + assert "catalog-secret" not in str(caught.value) + assert (await registry.list_models("kimi", str(tmp_path)))["cached"] + + +async def test_discovery_timeout_cancels_adapter(catalog_registry, tmp_path, monkeypatch): + registry, _ = catalog_registry + registry.config.models.timeout_sec = 0.01 + cleaned = asyncio.Event() + + class Slow: + async def list_models(self, cwd): + try: + await asyncio.Event().wait() + finally: + cleaned.set() + + monkeypatch.setattr("agent_bridge.registry.build_adapter", lambda *args: Slow()) + with pytest.raises(RuntimeError, match="TimeoutError"): + await registry.list_models("kimi", str(tmp_path)) + assert cleaned.is_set() + assert not registry._model_cache + + +async def test_deadline_includes_waiting_for_worker_lock(catalog_registry, tmp_path): + registry, calls = catalog_registry + registry.config.models.timeout_sec = 0.01 + lock = registry._model_locks.setdefault("kimi", asyncio.Lock()) + async with lock: + with pytest.raises(RuntimeError, match="TimeoutError"): + await registry.list_models("kimi", str(tmp_path), refresh=True) + assert calls == [] + + +async def test_fresh_cache_does_not_wait_for_discovery_lock(catalog_registry, tmp_path): + registry, calls = catalog_registry + await registry.list_models("kimi", str(tmp_path)) + registry.config.models.timeout_sec = 0.01 + async with registry._model_locks["kimi"]: + cached = await registry.list_models("kimi", str(tmp_path)) + assert cached["cached"] + cached["models"][0]["id"] = "caller mutation" + again = await registry.list_models("kimi", str(tmp_path)) + assert again["models"][0]["id"] == "small" + assert len(calls) == 1 + + +async def test_list_agents_reports_capability_without_discovery(catalog_registry, monkeypatch): + registry, calls = catalog_registry + registry.config.quota.enabled = False + + async def probe(cfg, env): + return {"agent": cfg.name, "available": True} + + monkeypatch.setattr("agent_bridge.registry.probe_agent", probe) + rows = await registry.list_agents() + assert rows[0]["model_discovery"]["supported"] + assert calls == [] + + +async def test_rejects_bad_context_and_unsupported_worker(catalog_registry, tmp_path): + registry, calls = catalog_registry + with pytest.raises(ValueError, match="absolute"): + await registry.list_models("kimi", "relative") + registry.config.agents["grok"] = AgentConfig(name="grok", protocol="acp", command=["unused"]) + with pytest.raises(NotImplementedError): + await registry.list_models("grok", str(tmp_path)) + registry.dispatch_enabled = False + with pytest.raises(RuntimeError, match="worker-inherited"): + await registry.list_models("kimi", str(tmp_path)) + assert calls == [] + + +async def test_mcp_tool_wraps_success_and_error(catalog_registry, tmp_path): + registry, _ = catalog_registry + ctx = types.SimpleNamespace(request_context=types.SimpleNamespace(lifespan_context=registry)) + result = await list_models(ctx, "kimi", str(tmp_path)) + assert result["ok"] and result["default_model"] == "small" + assert not (await list_models(ctx, "unknown", str(tmp_path)))["ok"] + + +def test_model_discovery_config_overlay(tmp_path): + (tmp_path / "agents.toml").write_text("[models]\ncache_sec = 86400\ntimeout_sec = 12\n", encoding="utf-8") + config = load_config(tmp_path) + assert config.models.cache_sec == 86400 + assert config.models.timeout_sec == 12 + assert not config.warnings + assert ModelsConfig().cache_sec == 3600 + with pytest.raises(ValueError): + ModelsConfig(cache_sec=-1) + with pytest.raises(ValueError): + ModelsConfig(timeout_sec=0) + + +def test_capability_does_not_claim_unimplemented_agents(): + for name, protocol in [("kimi", "acp"), ("dsh", "acp"), ("claude", "acp"), ("codex", "codex"), ("antigravity", "agy")]: + cfg = AgentConfig(name=name, protocol=protocol, command=["unused"]) + assert model_discovery_capability(cfg)["supported"] + assert not model_discovery_capability(AgentConfig(name="grok", protocol="acp", command=["unused"]))["supported"] diff --git a/tests/test_model_discovery_acp.py b/tests/test_model_discovery_acp.py new file mode 100644 index 0000000..b80b582 --- /dev/null +++ b/tests/test_model_discovery_acp.py @@ -0,0 +1,374 @@ +from __future__ import annotations + +import asyncio +from types import SimpleNamespace + +import pytest +from acp.schema import ( + NewSessionResponse, + PermissionOption, + SessionConfigOptionBoolean, + SessionConfigOptionSelect, +) + +from agent_bridge.adapters import acp +from agent_bridge.adapters.acp import AcpAdapter, AcpError, _acp_model_catalog, _Live +from agent_bridge.config import AgentConfig + + +class FakeConn: + def __init__(self, response=None, fail_at=None, block_at=None): + self.response = response or NewSessionResponse(session_id="discovery") + self.fail_at = fail_at + self.block_at = block_at + self.calls = [] + self.started = asyncio.Event() + self.client = None + + async def _call(self, name, kwargs): + self.calls.append((name, kwargs)) + if name == self.fail_at: + raise RuntimeError(f"{name} failed") + if name == self.block_at: + self.started.set() + await asyncio.Event().wait() + + async def initialize(self, **kwargs): + await self._call("initialize", kwargs) + + async def new_session(self, **kwargs): + await self._call("new_session", kwargs) + return self.response + + async def close(self): + await self._call("close", {}) + + +@pytest.fixture +def discovery(monkeypatch, tmp_path): + """Fail on registry, persistence, or normal-session paths, even on errors.""" + def forbidden(*args, **kwargs): + pytest.fail("Discovery must not persist or configure a Bridge session") + + for name in ("append_event", "record_pid", "drop_pid"): + monkeypatch.setattr(acp, name, forbidden) + monkeypatch.setattr(acp, "resolve_command", lambda command, fallback: list(command)) + monkeypatch.setattr(acp, "resolve_dsh_command", lambda command, fallback: list(command)) + conn = FakeConn() + proc = SimpleNamespace(stdin=object(), stdout=object(), stderr=None, returncode=None) + spawns = [] + reaped = [] + + async def spawn(*args, **kwargs): + spawns.append((args, kwargs)) + return proc + + async def reap(value): + reaped.append(value) + + def connect(client, stdin, stdout): + assert (stdin, stdout) == (proc.stdin, proc.stdout) + conn.client = client + return conn + + monkeypatch.setattr(acp.asyncio, "create_subprocess_exec", spawn) + monkeypatch.setattr(acp, "connect_to_agent", connect) + monkeypatch.setattr(acp, "reap_subprocess", reap) + + def build(name="kimi", command=None, **kwargs): + adapter = AcpAdapter( + AgentConfig( + name=name, protocol="acp", command=command or [name, "acp"], + session_meta={"yoloMode": True, "modelId": "must-not-select"}, + permission_policy="allow_always", **kwargs, + ), + tmp_path / "home", + ) + monkeypatch.setattr(adapter, "_env", lambda: {"SAFE": "yes"}) + for method in ("_spawn", "ensure_session", "_sync_selection", "shutdown"): + monkeypatch.setattr(adapter, method, forbidden) + active = _Live() + adapter._live["existing-session"] = active + return adapter, active + + return SimpleNamespace( + conn=conn, proc=proc, spawns=spawns, reaped=reaped, build=build, home=tmp_path / "home", + ) + + +def select_option(option_id, current, choices, **kwargs): + return SessionConfigOptionSelect( + id=option_id, name=option_id, type="select", + current_value=current, options=choices, **kwargs, + ) + + +def snapshot(*options): + return NewSessionResponse(session_id="discovery", config_options=list(options)) + + +def test_grouped_model_and_effort_options(): + result = _acp_model_catalog(snapshot( + select_option("model", "model-b", [{ + "group": "provider", "name": "Provider", "options": [ + {"value": "model-a", "name": "Model A"}, + {"value": "model-b", "name": "Model B"}, + ], + }]), + select_option("thinking", "high", [{ + "group": "levels", "name": "Levels", "options": [ + {"value": "low", "name": "Low"}, {"value": "high", "name": "High"}, + ], + }]), + ), "kimi") + assert result == { + "source": "acp", + "models": [ + {"id": "model-a", "name": "Model A", "is_default": False, "supported_efforts": None}, + {"id": "model-b", "name": "Model B", "is_default": True, "supported_efforts": ["low", "high"]}, + ], + "default_model": "model-b", "warnings": [], + } + + +def test_model_and_effort_categories(): + result = _acp_model_catalog(snapshot( + select_option("custom-picker", "a", [{"value": "a", "name": "A"}], category="model"), + select_option("custom-depth", "high", [{"value": "high", "name": "High"}], category="thought_level"), + ), "kimi") + assert result["default_model"] == "a" + assert result["models"] == [ + {"id": "a", "name": "A", "is_default": True, "supported_efforts": ["high"]}, + ] + + +def test_missing_catalog_warns(): + result = _acp_model_catalog(NewSessionResponse(session_id="discovery"), "kimi") + assert result["models"] == [] + assert result["default_model"] is None + assert result["warnings"] + + +def test_current_model_is_not_added_to_advertised_choices(): + result = _acp_model_catalog(snapshot( + select_option("model", "current", [{"value": "offered", "name": "Offered"}]), + ), "kimi") + assert result["default_model"] == "current" + assert [model["id"] for model in result["models"]] == ["offered"] + + +@pytest.mark.parametrize("thinking", [ + SessionConfigOptionBoolean(id="thinking", name="Thinking", type="boolean", current_value=True), + select_option("thinking", "true", [ + {"value": "true", "name": "On"}, {"value": "false", "name": "Off"}, + ]), +]) +def test_boolean_thinking_is_not_reported_as_effort(thinking): + result = _acp_model_catalog(snapshot( + select_option("model", "a", [{"value": "a", "name": "A"}]), thinking, + ), "kimi") + assert result["models"][0]["supported_efforts"] is None + + +async def test_private_handshake_never_prompts_configures_or_persists(discovery): + adapter, active = discovery.build(cwd="process-directory") + discovery.conn.response = snapshot(select_option("model", "a", [{"value": "a", "name": "A"}])) + result = await adapter.list_models("workspace-directory") + assert result["models"][0]["id"] == "a" + assert [name for name, _ in discovery.conn.calls] == ["initialize", "new_session", "close"] + assert discovery.conn.calls[1][1] == {"cwd": "workspace-directory", "mcp_servers": []} + assert discovery.spawns[0][1]["cwd"] == "process-directory" + assert discovery.spawns[0][1]["env"] == {"SAFE": "yes"} + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + assert not discovery.home.exists() + + +async def test_discovery_denies_permission_even_with_allow_always_policy(discovery): + adapter, _active = discovery.build() + await adapter.list_models(".") + response = await discovery.conn.client.request_permission( + "private", {"kind": "edit"}, + [PermissionOption(option_id="allow", name="Allow", kind="allow_always")], + ) + assert response.outcome.outcome == "cancelled" + await discovery.conn.client.session_update("private", {"toolCallId": "ignored"}) + with pytest.raises(RuntimeError, match="disabled"): + await discovery.conn.client.write_text_file("private", "file", "content") + with pytest.raises(RuntimeError, match="disabled"): + await discovery.conn.client.create_terminal("private", "command") + assert not discovery.home.exists() + + +@pytest.mark.parametrize("fail_at", ["initialize", "new_session"]) +async def test_handshake_failure_reaps_private_process(discovery, fail_at): + adapter, active = discovery.build() + discovery.conn.fail_at = fail_at + with pytest.raises(AcpError, match=f"{fail_at} failed") as caught: + await adapter.list_models(".") + assert caught.value.failure.operation == "model_discovery" + assert caught.value.failure.prompt_may_have_been_sent is False + assert discovery.conn.calls[-1][0] == "close" + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + + +@pytest.mark.parametrize("block_at", ["initialize", "new_session"]) +@pytest.mark.parametrize("cancel_method", ["cancel", "timeout"]) +async def test_cancel_or_outer_timeout_reaps_private_process(discovery, block_at, cancel_method): + adapter, active = discovery.build() + discovery.conn.block_at = block_at + task = asyncio.create_task(adapter.list_models(".")) + await discovery.conn.started.wait() + if cancel_method == "cancel": + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + else: + with pytest.raises(TimeoutError): + await asyncio.wait_for(task, timeout=0.01) + assert discovery.conn.calls[-1][0] == "close" + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + + +async def test_connect_failure_still_reaps_process(discovery, monkeypatch): + adapter, _active = discovery.build() + + def fail(*args): + raise RuntimeError("connect failed") + + monkeypatch.setattr(acp, "connect_to_agent", fail) + with pytest.raises(AcpError, match="connect failed"): + await adapter.list_models(".") + assert discovery.reaped == [discovery.proc] + + +async def test_close_failure_still_reaps_process(discovery): + adapter, _active = discovery.build() + discovery.conn.fail_at = "close" + await adapter.list_models(".") + assert discovery.reaped == [discovery.proc] + + +async def test_cancellation_during_cleanup_still_waits_for_reaping(discovery, monkeypatch): + adapter, active = discovery.build() + closing = asyncio.Event() + finish_close = asyncio.Event() + + async def close(): + closing.set() + await finish_close.wait() + + monkeypatch.setattr(discovery.conn, "close", close) + task = asyncio.create_task(adapter.list_models(".")) + await closing.wait() + task.cancel() + await asyncio.sleep(0) + assert not task.done() + finish_close.set() + with pytest.raises(asyncio.CancelledError): + await task + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + + +async def test_native_dsh_uses_advertised_provider_model_ids(discovery, monkeypatch): + prepared = [] + + def prepare(command, env, **kwargs): + prepared.append(kwargs) + return command, env + + monkeypatch.setattr(acp, "prepare_dsh_launch", prepare) + adapter, _active = discovery.build("dsh", ["dsh", "--profile", "acp"]) + discovery.conn.response = snapshot( + select_option("model", '["openai","reasoner"]', [{ + "group": "openai", "name": "OpenAI", "options": [ + {"value": '["openai","reasoner"]', "name": "Reasoner"}, + {"value": '["openai","fast"]', "name": "Fast"}, + ], + }]), + select_option("reasoning_effort", "high", [ + {"value": "medium", "name": "Medium"}, {"value": "high", "name": "High"}, + ]), + ) + result = await adapter.list_models(".") + assert prepared == [{}] + assert result["default_model"] == "openai/reasoner" + assert [(m["id"], m["supported_efforts"]) for m in result["models"]] == [ + ("openai/reasoner", ["medium", "high"]), ("openai/fast", None), + ] + + +async def test_legacy_dsh_discovers_actual_advertised_catalog(discovery, monkeypatch): + prepared = [] + + def prepare(command, env, **kwargs): + prepared.append(kwargs) + return command, env + + monkeypatch.setattr(acp, "prepare_dsh_launch", prepare) + adapter, active = discovery.build("dsh", ["dsh-acp-demo"]) + discovery.conn.response = snapshot(select_option( + "model", "legacy-model", [{"value": "legacy-model", "name": "Legacy Model"}], + )) + result = await adapter.list_models(".") + assert prepared == [{}] + assert result["default_model"] == "legacy-model" + assert result["models"] == [{ + "id": "legacy-model", "name": "Legacy Model", + "is_default": True, "supported_efforts": None, + }] + assert result["warnings"] == [] + assert [name for name, _ in discovery.conn.calls] == ["initialize", "new_session", "close"] + assert len(discovery.spawns) == 1 + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + + +async def test_legacy_dsh_warns_only_after_handshake_without_catalog(discovery, monkeypatch): + monkeypatch.setattr(acp, "prepare_dsh_launch", lambda command, env: (command, env)) + adapter, active = discovery.build("dsh", ["dsh-acp-demo"]) + result = await adapter.list_models(".") + assert result["models"] == [] + assert result["default_model"] is None + assert "did not advertise a model catalog" in result["warnings"][0] + assert [name for name, _ in discovery.conn.calls] == ["initialize", "new_session", "close"] + assert len(discovery.spawns) == 1 + assert discovery.reaped == [discovery.proc] + assert adapter._live == {"existing-session": active} + + +async def test_legacy_dsh_handshake_error_is_failure_not_unsupported(discovery, monkeypatch): + monkeypatch.setattr(acp, "prepare_dsh_launch", lambda command, env: (command, env)) + adapter, _active = discovery.build("dsh", ["dsh-acp-demo"]) + discovery.conn.fail_at = "new_session" + with pytest.raises(AcpError, match="new_session failed"): + await adapter.list_models(".") + assert discovery.reaped == [discovery.proc] + + +async def test_claude_catalog_uses_current_model_effort(discovery): + adapter, active = discovery.build("claude") + discovery.conn.response = snapshot( + select_option("model", "opus", [ + {"value": "opus", "name": "Opus"}, + {"value": "sonnet", "name": "Sonnet"}, + ], category="model"), + select_option("effort", "default", [ + {"value": "default", "name": "Default"}, + {"value": "low", "name": "Low"}, + {"value": "high", "name": "High"}, + ], category="thought_level"), + ) + result = await adapter.list_models(".") + assert result["default_model"] == "opus" + assert result["models"] == [ + {"id": "opus", "name": "Opus", "is_default": True, + "supported_efforts": ["default", "low", "high"]}, + {"id": "sonnet", "name": "Sonnet", "is_default": False, "supported_efforts": None}, + ] + assert [name for name, _ in discovery.conn.calls] == ["initialize", "new_session", "close"] + assert adapter._live == {"existing-session": active} + assert discovery.reaped == [discovery.proc] diff --git a/tests/test_model_discovery_exec.py b/tests/test_model_discovery_exec.py new file mode 100644 index 0000000..4289198 --- /dev/null +++ b/tests/test_model_discovery_exec.py @@ -0,0 +1,318 @@ +from __future__ import annotations + +import asyncio +import json +import os +import sys + +import psutil +import pytest + +from agent_bridge import model_discovery_exec +from agent_bridge.adapters.antigravity import AgyAdapter +from agent_bridge.adapters.codex import CodexAdapter +from agent_bridge.config import AgentConfig, EnvConfig +from agent_bridge.model_discovery_exec import ( + codex_app_server_list_models, + parse_agy_models_output, + parse_codex_models, +) + +FAKE_AGY = r""" +import json +import os +import sys +import time + +pid_file = os.environ.get("FAKE_AGY_PID") +if pid_file: + with open(pid_file,"w") as f:f.write(str(os.getpid())) +mode = os.environ.get("FAKE_AGY_MODE", "text") + +if mode == "exit3": + print("Authorization: Bearer sk-testsecret123", file=sys.stderr) + print("boom: token=apikeyhunter2", file=sys.stderr) + sys.exit(3) + +if mode == "hang": + time.sleep(30) + sys.exit(0) + +print("gemini-4-argon-low\tGemini 4 Argon (Low)") +print("claude-sonnet-5-5-high\tClaude Sonnet 5.5 (High)") +report = os.environ.get("FAKE_AGY_REPORT") +if report: + with open(report, "w", encoding="utf-8") as fh: + json.dump({ + "cwd": os.getcwd(), + "denied_present": "DISCOVERY_SECRET" in os.environ, + "agent_env": os.environ.get("AGY_MARKER"), + "worker_context": os.environ.get("AGENT_BRIDGE_PARENT_CONTEXT"), + }, fh) +sys.exit(0) +""" + +FAKE_CODEX = r""" +import json +import os +import sys +import time + +argv = sys.argv[1:] + +if argv and argv[-1] != "app-server": + print("unknown command", file=sys.stderr) + sys.exit(2) + +report = os.environ.get("FAKE_CODEX_REPORT") +requests = [] + +def emit(payload): + text = json.dumps(payload) + print(text, flush=True) + +mode = os.environ.get("FAKE_CODEX_MODELS_MODE", "ok") + +if mode == "hang": + time.sleep(30) + sys.exit(0) + +for line in sys.stdin: + line = line.strip() + if not line: + continue + msg = json.loads(line) + requests.append(msg) + if report: + with open(report, "w", encoding="utf-8") as fh: + json.dump({"argv": argv, "cwd": os.getcwd(), "requests": requests}, fh) + method = msg.get("method") + if method == "initialize": + emit({"id": msg["id"], "result": {"userAgent": "fake-codex"}}) + continue + if method == "initialized": + continue + if method == "model/list": + params = msg.get("params") or {} + if mode == "rpc_error": + emit({"id": msg["id"], "error": {"code": -32000, + "message": "Authorization: Bearer sk-leakedtok987"}}) + continue + if mode == "bad_page": + result = {"data": "not-a-list"} + elif mode == "bad_cursor": + result = {"data": [], "nextCursor": 17} + elif mode == "malformed": + result = {"data": [ + {"id": "gpt-good", "displayName": "Good", "isDefault": True}, + "not-a-mapping", + {"displayName": "missing id"}, + ], "nextCursor": None} + elif mode == "cursor_loop": + result = {"data": [{"id": "gpt-a"}], "nextCursor": "again"} + elif params.get("cursor") == "page2": + result = {"data": [{"id": "gpt-b", "displayName": "B", "isDefault": False, + "supportedReasoningEfforts": [{"reasoningEffort": "high"}]}], + "nextCursor": None} + else: + result = {"data": [{"id": "gpt-a", "model": "gpt-a", "displayName": "A", + "isDefault": True, "hidden": False, + "supportedReasoningEfforts": [ + {"reasoningEffort": "medium"}, + {"reasoningEffort": "xhigh"}, + ]}], + "nextCursor": "page2"} + emit({"id": msg["id"], "result": result}) + continue + emit({"id": msg["id"], "error": {"code": -32601, "message": "unknown method"}}) + +if report: + with open(report, "w", encoding="utf-8") as fh: + json.dump({"argv": argv, "cwd": os.getcwd(), "requests": requests}, fh) +sys.exit(0) +""" + + +def script_file(tmp_path, name, source): + path = tmp_path / name + path.write_text(source, encoding="utf-8") + return path + + +def agy_adapter(tmp_path, script, env=None, env_config=None): + return AgyAdapter( + AgentConfig(name="antigravity", protocol="agy", command=[sys.executable, str(script)], env=env or {}), + tmp_path / "home", + env_config, + ) + + +def codex_adapter(tmp_path, monkeypatch, script, overrides=None): + monkeypatch.setattr( + "agent_bridge.adapters.codex.resolve_codex_command", lambda *args, **kwargs: [sys.executable, str(script)] + ) + return CodexAdapter( + AgentConfig(name="codex", protocol="codex", command=["unused"], config_overrides=overrides or []), + tmp_path / "home", + ) + + +def test_agy_verified_tsv_format(): + result = parse_agy_models_output("\x1b[32mmodel-a\tModel A\x1b[0m\nmodel-b\tModel B\n") + assert result == [ + {"id": "model-a", "name": "Model A", "is_default": False, "supported_efforts": None}, + {"id": "model-b", "name": "Model B", "is_default": False, "supported_efforts": None}, + ] + + +@pytest.mark.parametrize( + "text", + [ + "ERROR", + "Unauthorized", + "Models:\nmodel-a\tModel A", + '{"models":[{"id":"a"}]}', + "- model-a", + "model-a (default)", + "", + "model-a\t", + "bad id\tName", + ], +) +def test_agy_unverified_formats_and_diagnostics_are_not_catalogs(text): + with pytest.raises(RuntimeError): + parse_agy_models_output(text) + + +def test_codex_advertised_metadata_preserves_levels_and_unknowns(): + catalog = parse_codex_models( + [ + { + "id": "a", + "displayName": "A", + "isDefault": True, + "supportedReasoningEfforts": [{"reasoningEffort": "medium"}, {"reasoningEffort": "xhigh"}], + }, + {"id": "b", "supportedReasoningEfforts": []}, + {"id": "d"}, + ] + ) + assert catalog["default_model"] == "a" + assert [m["supported_efforts"] for m in catalog["models"]] == [["medium", "xhigh"], [], None] + assert catalog["models"][0]["name"] == "A" + assert catalog["warnings"] == [] + + +def test_codex_malformed_effort_metadata_fails(): + with pytest.raises(KeyError, match="reasoningEffort"): + parse_codex_models([{"id": "a", "supportedReasoningEfforts": [{"unexpected": "high"}]}]) + + +def test_codex_preserves_advertised_rows(): + catalog = parse_codex_models([ + {"id": "a", "displayName": "First", "isDefault": True}, + {"id": "a", "displayName": "Second", "isDefault": True}, + ]) + assert [model["name"] for model in catalog["models"]] == ["First", "Second"] + assert all(model["is_default"] for model in catalog["models"]) + + +async def test_agy_adapter_env_cwd_and_catalog(tmp_path): + script = script_file(tmp_path, "agy.py", FAKE_AGY) + report = tmp_path / "report.json" + adapter = agy_adapter(tmp_path, script, {"FAKE_AGY_REPORT": str(report), "AGY_MARKER": "yes"}) + result = await adapter.list_models(str(tmp_path)) + assert [m["id"] for m in result["models"]] == ["gemini-4-argon-low", "claude-sonnet-5-5-high"] + assert result["default_model"] is None and result["warnings"] == [] + data = json.loads(report.read_text()) + assert data["cwd"] == str(tmp_path) and data["agent_env"] == "yes" + assert data["worker_context"] == "worker" + + +async def test_agy_respects_env_deny(tmp_path, monkeypatch): + monkeypatch.setenv("DISCOVERY_SECRET", "secret") + script = script_file(tmp_path, "agy.py", FAKE_AGY) + report = tmp_path / "report.json" + adapter = agy_adapter(tmp_path, script, {"FAKE_AGY_REPORT": str(report)}, EnvConfig(deny=["DISCOVERY_*"])) + await adapter.list_models(str(tmp_path)) + assert not json.loads(report.read_text())["denied_present"] + + +async def test_agy_nonzero_exit_is_redacted_failure(tmp_path): + script = script_file(tmp_path, "agy.py", FAKE_AGY) + adapter = agy_adapter(tmp_path, script, {"FAKE_AGY_MODE": "exit3"}) + with pytest.raises(RuntimeError, match="exited with code 3") as exc: + await adapter.list_models(str(tmp_path)) + assert "sk-testsecret123" not in str(exc.value) + assert "apikeyhunter2" not in str(exc.value) + + +@pytest.mark.parametrize("timeout", [True, False]) +async def test_agy_timeout_or_cancel_reaps_child(tmp_path, monkeypatch, timeout): + script = script_file(tmp_path, "agy.py", FAKE_AGY) + adapter = agy_adapter(tmp_path, script, {"FAKE_AGY_MODE": "hang"}) + started = asyncio.Event() + children = [] + original = asyncio.create_subprocess_exec + + async def spawn(*args, **kwargs): + proc = await original(*args, **kwargs) + children.append(proc) + started.set() + return proc + + monkeypatch.setattr(asyncio, "create_subprocess_exec", spawn) + task = asyncio.create_task(adapter.list_models(str(tmp_path))) + await asyncio.wait_for(started.wait(), timeout=5) + if timeout: + with pytest.raises(TimeoutError): + await asyncio.wait_for(task, 0.01) + else: + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + assert not psutil.pid_exists(children[0].pid) + + +async def test_agy_output_limit_fails_and_reaps(tmp_path, monkeypatch): + script = script_file(tmp_path, "agy.py", 'print("x"*10000)') + monkeypatch.setattr(model_discovery_exec, "AGY_OUTPUT_LIMIT", 100) + with pytest.raises(RuntimeError, match="output limit"): + await agy_adapter(tmp_path, script).list_models(str(tmp_path)) + + +async def test_codex_pages_overrides_and_observed_defaults(tmp_path, monkeypatch): + script = script_file(tmp_path, "codex.py", FAKE_CODEX) + report = tmp_path / "report.json" + monkeypatch.setenv("FAKE_CODEX_REPORT", str(report)) + override = 'model_provider="custom"' + result = await codex_adapter(tmp_path, monkeypatch, script, [override]).list_models(str(tmp_path)) + assert [m["id"] for m in result["models"]] == ["gpt-a", "gpt-b"] + assert result["default_model"] == "gpt-a" + assert result["models"][0]["supported_efforts"] == ["medium", "xhigh"] + data = json.loads(report.read_text()) + assert data["argv"] == ["-c", override, "app-server"] + assert data["cwd"] == str(tmp_path) + requests = [r for r in data["requests"] if r.get("method") == "model/list"] + assert len(requests) == 2 and requests[1]["params"]["cursor"] == "page2" + assert requests[0]["params"]["includeHidden"] is False + + +@pytest.mark.parametrize( + "mode,match", + [ + ("rpc_error", "discovery failed"), + ("bad_page", "malformed"), + ("bad_cursor", "malformed"), + ("cursor_loop", "repeated"), + ], +) +async def test_codex_invalid_responses_fail(tmp_path, mode, match): + script = script_file(tmp_path, "codex.py", FAKE_CODEX) + with pytest.raises(RuntimeError, match=match) as exc: + await codex_app_server_list_models( + [sys.executable, str(script), "app-server"], + env={**os.environ, "FAKE_CODEX_MODELS_MODE": mode}, + cwd=str(tmp_path), + ) + assert "sk-leakedtok987" not in str(exc.value) diff --git a/tests/test_server_tools.py b/tests/test_server_tools.py index cfb1cf9..2c8a322 100644 --- a/tests/test_server_tools.py +++ b/tests/test_server_tools.py @@ -13,7 +13,7 @@ from agent_bridge.server import INSTRUCTIONS, _error, _registry, list_sessions, mcp -def test_ten_tools_registered(): +def test_eleven_tools_registered(): names = sorted(mcp._tool_manager._tools) assert names == [ "cancel_task", @@ -23,6 +23,7 @@ def test_ten_tools_registered(): "get_result", "get_transcript", "list_agents", + "list_models", "list_sessions", "set_preferences", "wait_task",