@synergenius/flow-weaver 0.22.6 → 0.22.8

package/dist/agent/agent-loop.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Provider-agnostic agent loop — streams LLM responses, collects tool calls,
+ * executes them via a caller-provided executor, and iterates.
+ *
+ * The loop never touches provider internals. Adding a new provider (Codex,
+ * Gemini, etc.) requires zero loop changes — just implement AgentProvider.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, ToolExecutor, AgentLoopOptions, AgentLoopResult } from './types.js';
+export declare function runAgentLoop(provider: AgentProvider, tools: ToolDefinition[], executor: ToolExecutor, messages: AgentMessage[], options?: AgentLoopOptions): Promise<AgentLoopResult>;
+//# sourceMappingURL=agent-loop.d.ts.map

package/dist/agent/agent-loop.js

@@ -0,0 +1,121 @@
+/**
+ * Provider-agnostic agent loop — streams LLM responses, collects tool calls,
+ * executes them via a caller-provided executor, and iterates.
+ *
+ * The loop never touches provider internals. Adding a new provider (Codex,
+ * Gemini, etc.) requires zero loop changes — just implement AgentProvider.
+ */
+const DEFAULT_MAX_ITERATIONS = 15;
+const TOOL_RESULT_CAP = 10_000; // bytes
+export async function runAgentLoop(provider, tools, executor, messages, options) {
+    const maxIterations = options?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const signal = options?.signal;
+    const onStreamEvent = options?.onStreamEvent;
+    const onToolEvent = options?.onToolEvent;
+    const conversation = [...messages];
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    let toolCallCount = 0;
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+        if (signal?.aborted) {
+            return buildResult(false, 'Aborted', conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
+        }
+        // Stream from provider
+        let text = '';
+        let finishReason = 'stop';
+        const collectedToolCalls = [];
+        const activeToolNames = new Map();
+        const stream = provider.stream(conversation, tools, {
+            systemPrompt: options?.systemPrompt,
+            model: options?.model,
+            maxTokens: options?.maxTokens,
+            signal,
+            executor,
+            onToolEvent,
+        });
+        for await (const event of stream) {
+            onStreamEvent?.(event);
+            switch (event.type) {
+                case 'text_delta':
+                    text += event.text;
+                    break;
+                case 'tool_use_start':
+                    activeToolNames.set(event.id, event.name);
+                    break;
+                case 'tool_use_delta':
+                    // Partial JSON — tracked by provider, nothing to do here
+                    break;
+                case 'tool_use_end':
+                    collectedToolCalls.push({
+                        id: event.id,
+                        name: activeToolNames.get(event.id) ?? 'unknown',
+                        arguments: event.arguments,
+                    });
+                    activeToolNames.delete(event.id);
+                    break;
+                case 'tool_result':
+                    // CLI handled tool internally via MCP — count it
+                    toolCallCount++;
+                    break;
+                case 'usage':
+                    totalPromptTokens += event.promptTokens;
+                    totalCompletionTokens += event.completionTokens;
+                    break;
+                case 'message_stop':
+                    finishReason = event.finishReason;
+                    break;
+            }
+        }
+        // Add assistant message to conversation
+        if (collectedToolCalls.length > 0) {
+            conversation.push({
+                role: 'assistant',
+                content: text || '',
+                toolCalls: collectedToolCalls,
+            });
+        }
+        else if (text) {
+            conversation.push({ role: 'assistant', content: text });
+        }
+        // If no tool calls, we're done
+        if (finishReason !== 'tool_calls' || collectedToolCalls.length === 0) {
+            return buildResult(finishReason !== 'error', text || 'Task completed', conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
+        }
+        // Execute tool calls and add results to conversation
+        for (const tc of collectedToolCalls) {
+            if (signal?.aborted)
+                break;
+            toolCallCount++;
+            onToolEvent?.({ type: 'tool_call_start', name: tc.name, args: tc.arguments });
+            let result;
+            let isError;
+            try {
+                const res = await executor(tc.name, tc.arguments);
+                result = res.result;
+                isError = res.isError;
+            }
+            catch (err) {
+                result = err instanceof Error ? err.message : String(err);
+                isError = true;
+            }
+            onToolEvent?.({ type: 'tool_call_result', name: tc.name, result: result.slice(0, 200), isError });
+            // Add tool result to conversation (cap size to prevent context overflow)
+            conversation.push({
+                role: 'tool',
+                content: result.slice(0, TOOL_RESULT_CAP),
+                toolCallId: tc.id,
+            });
+        }
+    }
+    return buildResult(false, `Reached max iterations (${maxIterations})`, conversation, toolCallCount, totalPromptTokens, totalCompletionTokens);
+}
+function buildResult(success, summary, messages, toolCallCount, promptTokens, completionTokens) {
+    return {
+        success,
+        summary,
+        messages,
+        toolCallCount,
+        usage: { promptTokens, completionTokens },
+    };
+}
+//# sourceMappingURL=agent-loop.js.map

package/dist/agent/cli-session.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Persistent CLI session manager — eliminates cold-start delay by keeping
+ * the Claude CLI process alive between messages.
+ *
+ * Instead of spawning a new CLI process per message (~5s cold start + MCP
+ * handshake), we spawn once with `--input-format stream-json` and feed
+ * messages via stdin. The CLI maintains conversation context internally.
+ *
+ * KEY LEARNINGS (Claude Code CLI v2.1.76):
+ *
+ * 1. Stdin message format (NDJSON):
+ *    {"type":"user","message":{"role":"user","content":"..."},"parent_tool_use_id":null}
+ *
+ * 2. The CLI stays alive between messages when stdin is kept open.
+ *    Each message gets its own system/init → stream_events → result cycle.
+ *
+ * 3. Turn boundary: the `result` event marks the end of a CLI turn, NOT
+ *    `message_stop` from stream_event.
+ *
+ * 4. The CLI uses NDJSON for MCP stdio transport (not Content-Length framing).
+ */
+import { type ChildProcess } from 'node:child_process';
+import type { StreamEvent, CliSessionOptions } from './types.js';
+export declare class CliSession {
+    private readonly options;
+    readonly sessionId: `${string}-${string}-${string}-${string}-${string}`;
+    private child;
+    private alive;
+    private stderrBuf;
+    private stdoutBuffer;
+    private activeTurn;
+    private idleTimer;
+    private cleanupFn;
+    private parser;
+    private readonly log;
+    private readonly spawnFn;
+    private readonly idleTimeout;
+    constructor(options: CliSessionOptions);
+    get ready(): boolean;
+    /**
+     * Inject a mock child process for testing.
+     * @internal — test only
+     */
+    _injectForTest(child: ChildProcess): void;
+    /**
+     * Spawn the CLI process. Must be called before send().
+     */
+    spawn(): Promise<void>;
+    /**
+     * Send a user message and stream back events.
+     * Auto-respawns if the process has died.
+     */
+    send(userMessage: string, systemPromptPrefix?: string): AsyncGenerator<StreamEvent>;
+    /**
+     * Kill the CLI process.
+     */
+    kill(): void;
+    private pushEvent;
+    private completeTurn;
+    private markDead;
+    private onStdoutData;
+    private resetIdleTimer;
+    private clearIdleTimer;
+}
+/**
+ * Get an existing session or create a new one.
+ */
+export declare function getOrCreateCliSession(key: string, options: CliSessionOptions): CliSession;
+/**
+ * Kill a specific session.
+ */
+export declare function killCliSession(key: string): void;
+/**
+ * Kill all CLI sessions (for shutdown).
+ */
+export declare function killAllCliSessions(): void;
+//# sourceMappingURL=cli-session.d.ts.map

package/dist/agent/cli-session.js

@@ -0,0 +1,309 @@
+/**
+ * Persistent CLI session manager — eliminates cold-start delay by keeping
+ * the Claude CLI process alive between messages.
+ *
+ * Instead of spawning a new CLI process per message (~5s cold start + MCP
+ * handshake), we spawn once with `--input-format stream-json` and feed
+ * messages via stdin. The CLI maintains conversation context internally.
+ *
+ * KEY LEARNINGS (Claude Code CLI v2.1.76):
+ *
+ * 1. Stdin message format (NDJSON):
+ *    {"type":"user","message":{"role":"user","content":"..."},"parent_tool_use_id":null}
+ *
+ * 2. The CLI stays alive between messages when stdin is kept open.
+ *    Each message gets its own system/init → stream_events → result cycle.
+ *
+ * 3. Turn boundary: the `result` event marks the end of a CLI turn, NOT
+ *    `message_stop` from stream_event.
+ *
+ * 4. The CLI uses NDJSON for MCP stdio transport (not Content-Length framing).
+ */
+import { randomUUID } from 'node:crypto';
+import { spawn as nodeSpawn } from 'node:child_process';
+import { StreamJsonParser } from './streaming.js';
+const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+export class CliSession {
+    options;
+    sessionId = randomUUID();
+    child = null;
+    alive = false;
+    stderrBuf = '';
+    stdoutBuffer = '';
+    activeTurn = null;
+    idleTimer = null;
+    cleanupFn = null;
+    parser;
+    log;
+    spawnFn;
+    idleTimeout;
+    constructor(options) {
+        this.options = options;
+        this.log = options.logger;
+        this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
+        this.idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT_MS;
+        // Parser delegates to pushEvent which routes to activeTurn
+        this.parser = new StreamJsonParser((event) => this.pushEvent(event));
+    }
+    get ready() {
+        return this.alive;
+    }
+    /**
+     * Inject a mock child process for testing.
+     * @internal — test only
+     */
+    _injectForTest(child) {
+        this.child = child;
+        this.alive = true;
+        this.stderrBuf = '';
+        this.stdoutBuffer = '';
+        child.stdout.on('data', (chunk) => {
+            this.onStdoutData(chunk.toString());
+        });
+        child.on('exit', () => this.markDead());
+        child.on('error', () => this.markDead());
+    }
+    /**
+     * Spawn the CLI process. Must be called before send().
+     */
+    async spawn() {
+        const { binPath, cwd, env, model, mcpConfigPath } = this.options;
+        const args = [
+            '-p',
+            '--input-format',
+            'stream-json',
+            '--output-format',
+            'stream-json',
+            '--include-partial-messages',
+            '--verbose',
+            '--dangerously-skip-permissions',
+            '--permission-mode',
+            'bypassPermissions',
+            '--setting-sources',
+            'user,local',
+            '--model',
+            model,
+        ];
+        if (mcpConfigPath) {
+            args.push('--mcp-config', mcpConfigPath, '--strict-mcp-config');
+        }
+        const spawnResult = this.spawnFn(binPath, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: env ?? process.env });
+        const child = 'child' in spawnResult ? spawnResult.child : spawnResult;
+        const cleanup = 'cleanup' in spawnResult ? spawnResult.cleanup : undefined;
+        this.child = child;
+        this.cleanupFn = cleanup ?? null;
+        this.alive = true;
+        this.stderrBuf = '';
+        this.stdoutBuffer = '';
+        child.stderr.on('data', (chunk) => {
+            this.stderrBuf += chunk.toString();
+        });
+        child.stdout.on('data', (chunk) => {
+            this.onStdoutData(chunk.toString());
+        });
+        child.on('exit', (code) => {
+            this.log?.info('CLI session process exited', { sessionId: this.sessionId, exitCode: code });
+            this.markDead();
+        });
+        child.on('error', (err) => {
+            this.log?.error('CLI session process error', { sessionId: this.sessionId, err });
+            this.markDead();
+        });
+        this.resetIdleTimer();
+        this.log?.info('CLI session spawned', { sessionId: this.sessionId, cwd, model });
+    }
+    /**
+     * Send a user message and stream back events.
+     * Auto-respawns if the process has died.
+     */
+    async *send(userMessage, systemPromptPrefix) {
+        if (!this.alive) {
+            this.log?.info('CLI session dead, respawning', { sessionId: this.sessionId });
+            await this.spawn();
+        }
+        this.resetIdleTimer();
+        this.parser.reset();
+        const content = systemPromptPrefix ? `${systemPromptPrefix}\n\n${userMessage}` : userMessage;
+        // Write NDJSON message to stdin
+        const ndjsonMessage = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content },
+            parent_tool_use_id: null,
+        }) + '\n';
+        const turn = { resolve: () => { }, events: [], done: false };
+        this.activeTurn = turn;
+        // Track whether this turn saw a 'result' event (definitive turn end)
+        let sawResult = false;
+        // Wrap pushEvent to detect result-driven message_stop as turn end
+        const originalPush = this.pushEvent.bind(this);
+        this.parser = new StreamJsonParser((event) => {
+            // The result event emits message_stop — but in session mode,
+            // we need to detect it as the turn boundary
+            if (event.type === 'message_stop' && !sawResult) {
+                // This is a stream_event message_stop (API turn), not CLI turn end.
+                // Push it but don't complete the turn.
+                originalPush(event);
+                return;
+            }
+            originalPush(event);
+        });
+        // Override parser feed to detect result events for turn completion
+        const baseFeed = this.parser.feed.bind(this.parser);
+        this.parser.feed = (line) => {
+            // Check if this line is a result event before parsing
+            try {
+                let parsed = JSON.parse(line);
+                if (parsed.type === 'stream_event' && parsed.event)
+                    parsed = parsed.event;
+                if (parsed.type === 'result') {
+                    sawResult = true;
+                }
+            }
+            catch {
+                // Not JSON, let parser handle it
+            }
+            baseFeed(line);
+            if (sawResult) {
+                this.completeTurn();
+            }
+        };
+        try {
+            this.child.stdin.write(ndjsonMessage, (err) => {
+                if (err) {
+                    this.log?.error('stdin write error', { sessionId: this.sessionId, err });
+                    this.markDead();
+                    turn.done = true;
+                    turn.resolve();
+                }
+            });
+        }
+        catch (err) {
+            this.log?.error('stdin write exception', { sessionId: this.sessionId, err });
+            this.markDead();
+            throw new Error('CLI session stdin write failed');
+        }
+        // Yield events as they arrive
+        while (!turn.done || turn.events.length > 0) {
+            if (turn.events.length > 0) {
+                yield turn.events.shift();
+            }
+            else {
+                await new Promise((r) => {
+                    turn.resolve = r;
+                    setTimeout(r, 50);
+                });
+            }
+        }
+        // Yield any remaining events
+        while (turn.events.length > 0) {
+            yield turn.events.shift();
+        }
+        this.activeTurn = null;
+        this.resetIdleTimer();
+    }
+    /**
+     * Kill the CLI process.
+     */
+    kill() {
+        this.clearIdleTimer();
+        if (this.child && this.alive) {
+            this.log?.info('Killing CLI session', { sessionId: this.sessionId });
+            this.child.kill('SIGTERM');
+            setTimeout(() => {
+                if (this.child && !this.child.killed) {
+                    this.child.kill('SIGKILL');
+                }
+            }, 2000);
+        }
+        this.markDead();
+    }
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    pushEvent(event) {
+        if (!this.activeTurn)
+            return;
+        this.activeTurn.events.push(event);
+        this.activeTurn.resolve();
+    }
+    completeTurn() {
+        if (!this.activeTurn)
+            return;
+        this.activeTurn.done = true;
+        this.activeTurn.resolve();
+    }
+    markDead() {
+        this.alive = false;
+        this.cleanupFn?.();
+        this.cleanupFn = null;
+        if (this.activeTurn && !this.activeTurn.done) {
+            if (!this.activeTurn.events.some((e) => e.type === 'message_stop')) {
+                this.activeTurn.events.push({ type: 'message_stop', finishReason: 'error' });
+            }
+            this.activeTurn.done = true;
+            this.activeTurn.resolve();
+        }
+    }
+    onStdoutData(data) {
+        this.stdoutBuffer += data;
+        const lines = this.stdoutBuffer.split('\n');
+        this.stdoutBuffer = lines.pop() || '';
+        for (const line of lines) {
+            this.parser.feed(line);
+        }
+    }
+    resetIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => {
+            this.log?.info('CLI session idle timeout, killing', { sessionId: this.sessionId });
+            this.kill();
+        }, this.idleTimeout);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Session manager — cache keyed by identifier
+// ---------------------------------------------------------------------------
+const sessions = new Map();
+/**
+ * Get an existing session or create a new one.
+ */
+export function getOrCreateCliSession(key, options) {
+    const existing = sessions.get(key);
+    if (existing && existing.ready) {
+        return existing;
+    }
+    // Kill stale session if present
+    if (existing) {
+        existing.kill();
+        sessions.delete(key);
+    }
+    const session = new CliSession(options);
+    sessions.set(key, session);
+    return session;
+}
+/**
+ * Kill a specific session.
+ */
+export function killCliSession(key) {
+    const session = sessions.get(key);
+    if (session) {
+        session.kill();
+        sessions.delete(key);
+    }
+}
+/**
+ * Kill all CLI sessions (for shutdown).
+ */
+export function killAllCliSessions() {
+    for (const [, session] of sessions) {
+        session.kill();
+    }
+    sessions.clear();
+}
+//# sourceMappingURL=cli-session.js.map

package/dist/agent/env-allowlist.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Allowlisted environment variables for spawned CLI processes.
+ *
+ * Only these variables are forwarded from the host process to prevent
+ * leaking secrets, user identity, SSH agent sockets, workspace paths,
+ * and other sensitive host data to AI CLI tools.
+ */
+/**
+ * Minimal PATH for sandboxed AI CLI processes. Contains only standard
+ * system directories. CLI binaries are invoked via `process.execPath`
+ * (node) directly, bypassing shebang resolution, so the node binary
+ * directory is NOT needed here.
+ */
+export declare const MINIMAL_PATH = "/usr/local/bin:/usr/bin:/bin";
+export declare const ENV_ALLOWLIST: readonly string[];
+/**
+ * Build a safe environment object from the current process, forwarding
+ * only allowlisted keys. Callers can spread additional overrides on top.
+ */
+export declare function buildSafeEnv(overrides?: Record<string, string | undefined>): NodeJS.ProcessEnv;
+/**
+ * Convenience helper that returns both `cwd` and `env` in one object,
+ * making it harder to forget either when spawning a child process.
+ */
+export declare function buildSafeSpawnOpts(cwd: string, envOverrides?: Record<string, string | undefined>): {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+};
+//# sourceMappingURL=env-allowlist.d.ts.map

package/dist/agent/env-allowlist.js

@@ -0,0 +1,60 @@
+/**
+ * Allowlisted environment variables for spawned CLI processes.
+ *
+ * Only these variables are forwarded from the host process to prevent
+ * leaking secrets, user identity, SSH agent sockets, workspace paths,
+ * and other sensitive host data to AI CLI tools.
+ */
+/**
+ * Minimal PATH for sandboxed AI CLI processes. Contains only standard
+ * system directories. CLI binaries are invoked via `process.execPath`
+ * (node) directly, bypassing shebang resolution, so the node binary
+ * directory is NOT needed here.
+ */
+export const MINIMAL_PATH = '/usr/local/bin:/usr/bin:/bin';
+export const ENV_ALLOWLIST = [
+    // System basics
+    'PATH',
+    'LANG',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'TMPDIR',
+    'TZ',
+    // Node/runtime
+    'NODE_ENV',
+    'NO_COLOR',
+    'FORCE_COLOR',
+    // TLS/certificates
+    'NODE_EXTRA_CA_CERTS',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+    // Network proxy (needed behind corporate proxies)
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+];
+/**
+ * Build a safe environment object from the current process, forwarding
+ * only allowlisted keys. Callers can spread additional overrides on top.
+ */
+export function buildSafeEnv(overrides) {
+    const env = {};
+    for (const key of ENV_ALLOWLIST) {
+        if (process.env[key] !== undefined) {
+            env[key] = process.env[key];
+        }
+    }
+    if (overrides) {
+        Object.assign(env, overrides);
+    }
+    return env;
+}
+/**
+ * Convenience helper that returns both `cwd` and `env` in one object,
+ * making it harder to forget either when spawning a child process.
+ */
+export function buildSafeSpawnOpts(cwd, envOverrides) {
+    return { cwd, env: buildSafeEnv(envOverrides) };
+}
+//# sourceMappingURL=env-allowlist.js.map

package/dist/agent/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @synergenius/flow-weaver/agent
+ *
+ * Provider-agnostic agent loop with MCP bridge for tool execution.
+ * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ */
+export type { StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
+export { runAgentLoop } from './agent-loop.js';
+export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
+export type { AnthropicProviderOptions } from './providers/anthropic.js';
+export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+export { createMcpBridge } from './mcp-bridge.js';
+export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
+export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
+export { StreamJsonParser } from './streaming.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -0,0 +1,20 @@
+/**
+ * @synergenius/flow-weaver/agent
+ *
+ * Provider-agnostic agent loop with MCP bridge for tool execution.
+ * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ */
+// Agent loop
+export { runAgentLoop } from './agent-loop.js';
+// Providers
+export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
+export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+// MCP bridge
+export { createMcpBridge } from './mcp-bridge.js';
+// CLI session (warm persistent sessions)
+export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
+// Env utilities
+export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
+// Stream parser (for custom providers)
+export { StreamJsonParser } from './streaming.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,22 @@
+/**
+ * MCP bridge — creates a Unix domain socket server that the MCP tool server
+ * connects to for executing tools. Also generates the temporary MCP config
+ * and tool definition files needed by the Claude CLI.
+ *
+ * Usage:
+ *   const bridge = await createMcpBridge(tools, executor, onToolEvent);
+ *   // pass bridge.configPath to --mcp-config
+ *   // ...run CLI...
+ *   bridge.cleanup();
+ */
+import type { ToolDefinition, ToolExecutor, ToolEvent, McpBridge, Logger } from './types.js';
+/**
+ * Create an MCP bridge that the Claude CLI can connect to for tool execution.
+ *
+ * @param tools       Tool definitions to advertise to the CLI
+ * @param executor    Function that executes a tool call
+ * @param onToolEvent Optional callback for relaying tool events
+ * @param logger      Optional logger
+ */
+export declare function createMcpBridge(tools: ToolDefinition[], executor: ToolExecutor, onToolEvent?: (event: ToolEvent) => void, logger?: Logger): Promise<McpBridge>;
+//# sourceMappingURL=mcp-bridge.d.ts.map