@sdods/agents 0.2.0

package/dist/adapter/codex.js

@@ -0,0 +1,252 @@
+import { sdodsMcpServerSpec, playwrightMcpSpec, requireCli, runJsonl, runQuiet, } from './cli-common.js';
+import { cliFailure } from './claude-code.js';
+import { AgentsConfigError, DEFAULT_MODELS, } from './types.js';
+const INSTALL_HINT = 'Install Codex (`npm i -g @openai/codex`) and run `codex login`, or use --adapter claude-code, --adapter claude with ANTHROPIC_API_KEY, or --dry-run.';
+/** Codex `exec --json` event stream → SDODS events. */
+export function normalizeCodexEvent(ev) {
+    const out = [];
+    const item = ev.item;
+    switch (ev.type) {
+        case 'item.started':
+            if (item && isToolItem(item.type))
+                out.push({ type: 'tool_call', id: item.id, name: toolName(item), input: toolInput(item) });
+            break;
+        case 'item.completed':
+            if (!item)
+                break;
+            if (item.type === 'agent_message' && typeof item.text === 'string')
+                out.push({ type: 'text', text: item.text });
+            else if (item.type === 'error')
+                out.push({ type: 'status', message: String(item.message ?? 'error') });
+            else if (item.type === 'reasoning') {
+                /* keep reasoning out of the transcript */
+            }
+            else if (isToolItem(item.type)) {
+                // Codex does not always emit item.started for tools; emit the call if we have not seen it.
+                out.push({
+                    type: 'tool_result',
+                    id: item.id,
+                    output: item.output ?? item.result ?? item.aggregated_output ?? item.changes ?? null,
+                    isError: item.status === 'failed' || item.status === 'error',
+                });
+            }
+            break;
+        case 'turn.failed':
+        case 'error':
+            out.push({
+                type: 'status',
+                message: String(ev.error?.message ?? ev.message ?? 'turn failed'),
+            });
+            break;
+        default:
+            break;
+    }
+    return out;
+}
+function isToolItem(type) {
+    return (type === 'mcp_tool_call' ||
+        type === 'command_execution' ||
+        type === 'file_change' ||
+        type === 'web_search' ||
+        type === 'tool_call');
+}
+function toolName(item) {
+    if (item.type === 'mcp_tool_call')
+        return `mcp__${item.server ?? 'mcp'}__${item.tool ?? item.name ?? 'tool'}`;
+    if (item.type === 'command_execution')
+        return 'shell';
+    if (item.type === 'file_change')
+        return 'file_change';
+    if (item.type === 'web_search')
+        return 'web_search';
+    return String(item.name ?? item.type);
+}
+function toolInput(item) {
+    return item.arguments ?? item.input ?? item.command ?? item.query ?? null;
+}
+export function codexUsage(u) {
+    if (!u)
+        return undefined;
+    return {
+        inputTokens: typeof u.input_tokens === 'number' ? u.input_tokens : undefined,
+        outputTokens: typeof u.output_tokens === 'number' ? u.output_tokens : undefined,
+        cacheReadTokens: typeof u.cached_input_tokens === 'number' ? u.cached_input_tokens : undefined,
+        cacheWriteTokens: typeof u.cache_write_input_tokens === 'number' ? u.cache_write_input_tokens : undefined,
+    };
+}
+/**
+ * Runs SDODS agent roles through the user's logged-in OpenAI Codex CLI (`codex exec --json`).
+ * No OPENAI_API_KEY is needed when Codex is logged in with a ChatGPT account. The sdods MCP
+ * server and the bundled Playwright MCP are injected with `-c mcp_servers.*` overrides; the run
+ * is ephemeral, read-only sandboxed, and the system prompt is prepended to the task.
+ */
+export class CodexCliAdapter {
+    ctx;
+    provider = 'codex';
+    defaultModel;
+    constructor(ctx = {}) {
+        this.ctx = ctx;
+        this.defaultModel = ctx.model ?? process.env.SDODS_CODEX_MODEL ?? DEFAULT_MODELS.codex;
+    }
+    bin() {
+        const bin = requireCli(this.ctx.bin ?? 'codex', INSTALL_HINT);
+        if (process.env.SDODS_SKIP_CLI_AUTH_CHECK !== '1') {
+            const r = runQuiet(bin, ['login', 'status']);
+            if (r.ok && /not logged in/i.test(r.stdout)) {
+                throw new AgentsConfigError('Codex is installed but not logged in.', 'Run `codex login` (ChatGPT account) or set OPENAI_API_KEY.');
+            }
+        }
+        return bin;
+    }
+    static loginStatus(bin = 'codex') {
+        const found = (() => {
+            try {
+                return requireCli(bin, '');
+            }
+            catch {
+                return null;
+            }
+        })();
+        if (!found)
+            return { installed: false, loggedIn: null, detail: 'not installed' };
+        const v = runQuiet(found, ['--version']);
+        const s = runQuiet(found, ['login', 'status']);
+        const loggedIn = s.ok ? !/not logged in/i.test(s.stdout) : null;
+        return {
+            installed: true,
+            loggedIn,
+            detail: `${v.stdout.trim().split('\n')[0] || 'installed'}${loggedIn ? ` · ${s.stdout.trim().split('\n')[0]}` : loggedIn === false ? ' · NOT logged in' : ''}`,
+        };
+    }
+    baseArgs(cwd, model) {
+        const m = model ?? this.defaultModel;
+        return [
+            'exec',
+            '--json',
+            '--skip-git-repo-check',
+            '--ephemeral',
+            '-s',
+            'read-only',
+            ...(cwd ? ['-C', cwd] : []),
+            ...(m && m !== 'default' ? ['-m', m] : []),
+        ];
+    }
+    mcpArgs(o) {
+        const sdods = sdodsMcpServerSpec({ ...this.ctx, rootDir: this.ctx.rootDir ?? o.cwd });
+        const args = [
+            '-c',
+            `mcp_servers.sdods.command=${tomlString(sdods.command)}`,
+            '-c',
+            `mcp_servers.sdods.args=${tomlArray(sdods.args)}`,
+        ];
+        if (this.ctx.withPlaywrightMcp !== false) {
+            const pw = playwrightMcpSpec();
+            args.push('-c', `mcp_servers.playwright.command=${tomlString(pw.command)}`, '-c', `mcp_servers.playwright.args=${tomlArray(pw.args)}`);
+        }
+        for (const [name, cfg] of Object.entries(o.mcpServers ?? {})) {
+            if (cfg.transport === 'http' && cfg.url) {
+                args.push('-c', `mcp_servers.${name}.url=${tomlString(cfg.url)}`);
+            }
+            else if (cfg.command) {
+                args.push('-c', `mcp_servers.${name}.command=${tomlString(cfg.command)}`, '-c', `mcp_servers.${name}.args=${tomlArray(cfg.args ?? [])}`);
+            }
+        }
+        return args;
+    }
+    async complete(req) {
+        const bin = this.bin();
+        let text = '';
+        let usage;
+        const prompt = req.system ? `${req.system}\n\n---\n\n${req.prompt}` : req.prompt;
+        const r = await runJsonl(bin, [...this.baseArgs(undefined, req.model), prompt], {
+            signal: req.signal,
+            onLine: (line) => {
+                if (typeof line !== 'object' || !line)
+                    return;
+                const ev = line;
+                for (const e of normalizeCodexEvent(ev))
+                    if (e.type === 'text')
+                        text += e.text;
+                if (ev.type === 'turn.completed')
+                    usage = codexUsage(ev.usage);
+            },
+        });
+        if (r.exitCode !== 0 && !text)
+            throw cliFailure('codex', r.exitCode, r.stderr);
+        return { text: text.trim(), usage };
+    }
+    async *stream(req) {
+        const r = await this.complete(req);
+        yield r.text;
+    }
+    async runAgent(o) {
+        const bin = this.bin();
+        const prompt = `${o.system}\n\n---\n\n${o.prompt}`;
+        const args = [...this.baseArgs(o.cwd, o.model), ...this.mcpArgs(o), prompt];
+        let text = '';
+        let turns = 0;
+        let toolCalls = 0;
+        let usage;
+        let failed = false;
+        const seenCalls = new Set();
+        const r = await runJsonl(bin, args, {
+            cwd: o.cwd,
+            signal: o.signal,
+            onLine: (line) => {
+                if (typeof line !== 'object' || !line)
+                    return;
+                const ev = line;
+                if (ev.type === 'turn.completed') {
+                    turns++;
+                    usage = codexUsage(ev.usage) ?? usage;
+                }
+                if (ev.type === 'turn.failed')
+                    failed = true;
+                for (const e of normalizeCodexEvent(ev)) {
+                    if (e.type === 'tool_call') {
+                        seenCalls.add(e.id);
+                        toolCalls++;
+                    }
+                    if (e.type === 'tool_result' && !seenCalls.has(e.id)) {
+                        // no item.started was emitted for this tool: count the call now
+                        seenCalls.add(e.id);
+                        toolCalls++;
+                        o.onEvent?.({ type: 'tool_call', id: e.id, name: 'tool', input: null });
+                    }
+                    o.onEvent?.(e);
+                    if (e.type === 'text')
+                        text += e.text;
+                }
+                if (o.maxTurns && turns >= o.maxTurns) {
+                    o.onEvent?.({ type: 'status', message: `max turns (${o.maxTurns}) reached` });
+                }
+            },
+        });
+        const isError = failed || (r.exitCode !== 0 && !text);
+        if (isError && !text)
+            throw cliFailure('codex', r.exitCode, r.stderr);
+        const result = {
+            text,
+            usage,
+            turns: Math.max(turns, 1),
+            stopReason: isError ? 'error' : 'end',
+            isError,
+            toolCalls,
+        };
+        o.onEvent?.({
+            type: 'result',
+            usage,
+            turns: result.turns,
+            stopReason: result.stopReason,
+            isError,
+        });
+        return result;
+    }
+}
+function tomlString(s) {
+    return JSON.stringify(s);
+}
+function tomlArray(items) {
+    return `[${items.map(tomlString).join(',')}]`;
+}
+//# sourceMappingURL=codex.js.map

package/dist/adapter/factory.d.ts

@@ -0,0 +1,41 @@
+import { type FakeAdapterOptions } from './fake.js';
+import { type LlmAdapter, type Provider } from './types.js';
+export interface CreateAdapterOptions {
+    provider?: Provider | string;
+    model?: string;
+    /** Endpoint for the model server (ollama, vLLM, LM Studio, Azure …). */
+    baseUrl?: string;
+    /** `options.num_ctx` for local models, and the ceiling their prompts are measured against. */
+    contextTokens?: number;
+    temperature?: number;
+    timeoutMs?: number;
+    fake?: FakeAdapterOptions;
+    /** repo root, project and env let the CLI adapters start the sdods MCP server */
+    rootDir?: string;
+    project?: string;
+    env?: string;
+    /** called when the provider was auto-detected (not set explicitly) */
+    onAutoDetect?: (provider: Provider, reason: string) => void;
+}
+export declare function normalizeProvider(raw: string): Provider;
+/**
+ * Detection order when nothing is set explicitly:
+ * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → OPENAI_API_KEY → Ollama → fake.
+ *
+ * A key or a CLI login is a deliberate statement of intent, so those come first; an installed
+ * Ollama still beats `fake`, which produces nothing. Detection is synchronous and must not touch
+ * the network, so it looks for `OLLAMA_HOST` or the binary; `detectProviderAsync` additionally
+ * probes the default host for callers that can await.
+ */
+export declare function detectProvider(env?: NodeJS.ProcessEnv): {
+    provider: Provider;
+    reason: string;
+};
+/** Detection plus a short probe of the default Ollama host, for callers that can await. */
+export declare function detectProviderAsync(env?: NodeJS.ProcessEnv): Promise<{
+    provider: Provider;
+    reason: string;
+}>;
+export declare function resolveProvider(explicit?: string, projectDefault?: string, onAutoDetect?: (provider: Provider, reason: string) => void): Provider;
+export declare function createAdapter(opts?: CreateAdapterOptions, projectDefault?: string): LlmAdapter;
+//# sourceMappingURL=factory.d.ts.map

package/dist/adapter/factory.js

@@ -0,0 +1,102 @@
+import { ClaudeAdapter } from './claude.js';
+import { ClaudeCodeCliAdapter } from './claude-code.js';
+import { findOnPath } from './cli-common.js';
+import { CodexCliAdapter } from './codex.js';
+import { FakeAdapter } from './fake.js';
+import { OllamaAdapter } from './ollama.js';
+import { OpenAiCompatibleAdapter } from './openai-compat.js';
+import { AgentsConfigError } from './types.js';
+export function normalizeProvider(raw) {
+    const p = raw.toLowerCase();
+    if (p === 'claude' || p === 'anthropic')
+        return 'claude';
+    if (p === 'claude-code' || p === 'claudecode' || p === 'claude-cli')
+        return 'claude-code';
+    if (p === 'codex' || p === 'codex-cli' || p === 'openai-codex')
+        return 'codex';
+    if (p === 'ollama' || p === 'local')
+        return 'ollama';
+    if (p === 'openai' ||
+        p === 'openai-compatible' ||
+        p === 'azure' ||
+        p === 'vllm' ||
+        p === 'lmstudio')
+        return 'openai-compatible';
+    if (p === 'fake' || p === 'dry-run')
+        return 'fake';
+    throw new AgentsConfigError(`Unknown LLM provider "${raw}".`, 'Use claude, claude-code, codex, openai-compatible, ollama or fake.');
+}
+/**
+ * Detection order when nothing is set explicitly:
+ * ANTHROPIC_API_KEY → `claude` CLI → `codex` CLI → OPENAI_API_KEY → Ollama → fake.
+ *
+ * A key or a CLI login is a deliberate statement of intent, so those come first; an installed
+ * Ollama still beats `fake`, which produces nothing. Detection is synchronous and must not touch
+ * the network, so it looks for `OLLAMA_HOST` or the binary; `detectProviderAsync` additionally
+ * probes the default host for callers that can await.
+ */
+export function detectProvider(env = process.env) {
+    if (env.ANTHROPIC_API_KEY)
+        return { provider: 'claude', reason: 'ANTHROPIC_API_KEY is set' };
+    if (findOnPath('claude'))
+        return { provider: 'claude-code', reason: 'claude CLI found on PATH' };
+    if (findOnPath('codex'))
+        return { provider: 'codex', reason: 'codex CLI found on PATH' };
+    if (env.OPENAI_API_KEY)
+        return { provider: 'openai-compatible', reason: 'OPENAI_API_KEY is set' };
+    if (env.OLLAMA_HOST)
+        return { provider: 'ollama', reason: 'OLLAMA_HOST is set' };
+    if (findOnPath('ollama'))
+        return { provider: 'ollama', reason: 'ollama found on PATH' };
+    return {
+        provider: 'fake',
+        reason: 'no API key and no claude/codex CLI found; using the fake adapter',
+    };
+}
+/** Detection plus a short probe of the default Ollama host, for callers that can await. */
+export async function detectProviderAsync(env = process.env) {
+    const sync = detectProvider(env);
+    if (sync.provider !== 'fake')
+        return sync;
+    if (await OllamaAdapter.reachable())
+        return { provider: 'ollama', reason: 'a local Ollama server answered' };
+    return sync;
+}
+export function resolveProvider(explicit, projectDefault, onAutoDetect) {
+    const chosen = explicit ?? process.env.SDODS_LLM_PROVIDER ?? projectDefault;
+    if (chosen)
+        return normalizeProvider(chosen);
+    const d = detectProvider();
+    onAutoDetect?.(d.provider, d.reason);
+    return d.provider;
+}
+export function createAdapter(opts = {}, projectDefault) {
+    const provider = resolveProvider(opts.provider, projectDefault, opts.onAutoDetect);
+    const cliCtx = { rootDir: opts.rootDir, project: opts.project, env: opts.env, model: opts.model };
+    switch (provider) {
+        case 'claude':
+            return new ClaudeAdapter({ model: opts.model });
+        case 'claude-code':
+            return new ClaudeCodeCliAdapter(cliCtx);
+        case 'codex':
+            return new CodexCliAdapter(cliCtx);
+        case 'openai-compatible':
+            return new OpenAiCompatibleAdapter({
+                model: opts.model,
+                baseUrl: opts.baseUrl,
+                temperature: opts.temperature,
+                timeoutMs: opts.timeoutMs,
+            });
+        case 'ollama':
+            return new OllamaAdapter({
+                model: opts.model,
+                baseUrl: opts.baseUrl,
+                contextTokens: opts.contextTokens,
+                temperature: opts.temperature,
+                timeoutMs: opts.timeoutMs,
+            });
+        case 'fake':
+            return new FakeAdapter(opts.fake);
+    }
+}
+//# sourceMappingURL=factory.js.map

package/dist/adapter/fake.d.ts

@@ -0,0 +1,39 @@
+import { type CompleteRequest, type CompleteResult, type LlmAdapter, type RunAgentOptions, type RunAgentResult } from './types.js';
+export type FakeStep = {
+    text: string;
+} | {
+    toolCall: {
+        name: string;
+        input: Record<string, unknown>;
+    };
+} | {
+    fn: (ctx: {
+        prompt: string;
+        system: string;
+        lastToolOutput?: unknown;
+    }) => FakeStep | FakeStep[] | undefined;
+};
+export interface FakeAdapterOptions {
+    /** scripted sequence; tool calls execute the REAL registry handlers */
+    script?: FakeStep[];
+    completion?: string | ((req: CompleteRequest) => string);
+    costPerTurnUsd?: number;
+}
+/** Deterministic adapter for tests and `--dry-run`: no network, real tool handlers. */
+export declare class FakeAdapter implements LlmAdapter {
+    private readonly opts;
+    readonly provider: "fake";
+    readonly defaultModel: string;
+    readonly calls: Array<{
+        name: string;
+        input: unknown;
+        output: unknown;
+    }>;
+    constructor(opts?: FakeAdapterOptions);
+    complete(req: CompreteOrCompleteRequest): Promise<CompleteResult>;
+    stream(req: CompleteRequest): AsyncIterable<string>;
+    runAgent(o: RunAgentOptions): Promise<RunAgentResult>;
+}
+type CompreteOrCompleteRequest = CompleteRequest;
+export {};
+//# sourceMappingURL=fake.d.ts.map

package/dist/adapter/fake.js

@@ -0,0 +1,91 @@
+import { DEFAULT_MODELS, } from './types.js';
+/** Deterministic adapter for tests and `--dry-run`: no network, real tool handlers. */
+export class FakeAdapter {
+    opts;
+    provider = 'fake';
+    defaultModel = DEFAULT_MODELS.fake;
+    calls = [];
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async complete(req) {
+        const c = this.opts.completion;
+        const text = typeof c === 'function' ? c(req) : (c ?? `[fake completion for: ${req.prompt.slice(0, 80)}]`);
+        return {
+            text,
+            usage: { inputTokens: req.prompt.length, outputTokens: text.length },
+            costUsd: 0,
+            model: this.defaultModel,
+        };
+    }
+    async *stream(req) {
+        yield (await this.complete(req)).text;
+    }
+    async runAgent(o) {
+        const byName = new Map(o.tools.map((t) => [t.name, t]));
+        const queue = [
+            ...(this.opts.script ?? [
+                { text: `[fake agent] tools available: ${o.tools.map((t) => t.name).join(', ')}` },
+            ]),
+        ];
+        let text = '';
+        let turns = 0;
+        let toolCalls = 0;
+        let lastToolOutput;
+        const cost = () => turns * (this.opts.costPerTurnUsd ?? 0);
+        while (queue.length) {
+            if (o.maxTurns && turns >= o.maxTurns)
+                return finish('error_max_turns', true);
+            if (o.maxBudgetUsd !== undefined && cost() > o.maxBudgetUsd)
+                return finish('error_max_budget_usd', true);
+            const step = queue.shift();
+            turns++;
+            if ('fn' in step) {
+                const next = step.fn({ prompt: o.prompt, system: o.system, lastToolOutput });
+                if (next)
+                    queue.unshift(...(Array.isArray(next) ? next : [next]));
+                continue;
+            }
+            if ('text' in step) {
+                text += step.text;
+                o.onEvent?.({ type: 'text', text: step.text });
+                continue;
+            }
+            const id = `call_${toolCalls + 1}`;
+            toolCalls++;
+            o.onEvent?.({ type: 'tool_call', id, name: step.toolCall.name, input: step.toolCall.input });
+            const tool = byName.get(step.toolCall.name);
+            const result = tool
+                ? await tool.handler(step.toolCall.input)
+                : {
+                    content: [{ type: 'text', text: `Unknown tool ${step.toolCall.name}` }],
+                    isError: true,
+                };
+            lastToolOutput = result;
+            this.calls.push({ name: step.toolCall.name, input: step.toolCall.input, output: result });
+            o.onEvent?.({ type: 'tool_result', id, output: result.content, isError: result.isError });
+        }
+        return finish('end_turn', false);
+        function finish(stopReason, isError) {
+            const r = {
+                text,
+                costUsd: cost(),
+                usage: { inputTokens: 0, outputTokens: text.length },
+                turns,
+                stopReason,
+                isError,
+                toolCalls,
+            };
+            o.onEvent?.({
+                type: 'result',
+                costUsd: r.costUsd,
+                usage: r.usage,
+                turns,
+                stopReason,
+                isError,
+            });
+            return r;
+        }
+    }
+}
+//# sourceMappingURL=fake.js.map

package/dist/adapter/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './claude.js';
+export * from './claude-code.js';
+export * from './codex.js';
+export * from './cli-common.js';
+export * from './mcp-bridge.js';
+export * from './ollama.js';
+export * from './openai-compat.js';
+export * from './fake.js';
+export * from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapter/index.js

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './claude.js';
+export * from './claude-code.js';
+export * from './codex.js';
+export * from './cli-common.js';
+export * from './mcp-bridge.js';
+export * from './ollama.js';
+export * from './openai-compat.js';
+export * from './fake.js';
+export * from './factory.js';
+//# sourceMappingURL=index.js.map

package/dist/adapter/json-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/**
+ * Tool parameters as a JSON schema the widest range of servers accepts.
+ *
+ * Two details matter and both bite. Zod's `toJSONSchema` defaults to `io: 'output'`, which marks
+ * every field carrying a `.default()` as **required** — telling the model it must invent a value
+ * it could have omitted. And the `$schema` key it adds is rejected by some grammar-constrained
+ * local servers. Neither belongs in a function definition.
+ */
+export declare function toolParameters(shape: Parameters<typeof z.object>[0], jsonSchema?: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/adapter/json-schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * Tool parameters as a JSON schema the widest range of servers accepts.
+ *
+ * Two details matter and both bite. Zod's `toJSONSchema` defaults to `io: 'output'`, which marks
+ * every field carrying a `.default()` as **required** — telling the model it must invent a value
+ * it could have omitted. And the `$schema` key it adds is rejected by some grammar-constrained
+ * local servers. Neither belongs in a function definition.
+ */
+export function toolParameters(shape, jsonSchema) {
+    const schema = jsonSchema
+        ? { ...jsonSchema }
+        : z.toJSONSchema(z.object(shape), { io: 'input' });
+    delete schema.$schema;
+    return schema;
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/adapter/mcp-bridge.d.ts

@@ -0,0 +1,35 @@
+import type { AgentSdkToolDef } from '@sdods/mcp';
+import type { AgentEvent, ExternalMcpServerConfig } from './types.js';
+/**
+ * Lets an adapter that drives a chat endpoint itself use MCP servers.
+ *
+ * The Claude and CLI adapters hand `mcpServers` to something that already speaks MCP — the Agent
+ * SDK, or the `claude`/`codex` binary. The chat-completions adapters had nowhere to hand them, so
+ * they dropped them with a note, which quietly meant the planner, generator and healer ran without
+ * a browser: they are the roles whose whole job is to look at the application. That was true of
+ * every OpenAI-compatible provider, hosted or local, and it is the reason a local model could not
+ * do the interesting half of the work.
+ *
+ * This connects the servers as a client, lists their tools, and presents them as ordinary function
+ * definitions named `mcp__<server>__<tool>` — the same convention Claude Code uses, so prompts and
+ * allowlists read the same everywhere.
+ */
+export interface BridgedTools {
+    tools: AgentSdkToolDef[];
+    close(): Promise<void>;
+}
+export interface BridgeOptions {
+    servers?: Record<string, ExternalMcpServerConfig>;
+    /** Adds `npx playwright mcp --headless`, the way the Claude adapter does for browser roles. */
+    withPlaywright?: boolean;
+    /**
+     * Ceiling on the tools taken from each server. The browser server alone offers 24, which is
+     * more than a small model can choose between, so the small profile keeps the ones a test author
+     * actually uses and drops the rest.
+     */
+    maxToolsPerServer?: number;
+    cwd?: string;
+    onEvent?: (e: AgentEvent) => void;
+}
+export declare function bridgeMcpServers(opts: BridgeOptions): Promise<BridgedTools>;
+//# sourceMappingURL=mcp-bridge.d.ts.map