@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/agent/cli-spawn-config.d.ts

@@ -1,15 +1,15 @@
 /**
- * Centralized CLI spawn configuration — single source of truth for all
+ * Centralized CLI spawn configuration: the single source of truth for all
  * Claude CLI invocations in automation contexts.
  *
  * RULE: Every automated CLI spawn MUST use getCliBaseArgs() or getCliSessionConfig().
  * Never construct CLI args manually. This ensures:
- * - --tools "" (disable all built-in tools)
+ * - --allowed-tools "" (disable all built-in tools)
  * - --strict-mcp-config (prevent user MCP server leakage)
  * - --dangerously-skip-permissions (no permission prompts in automation)
  *
- * Interactive user sessions (e.g., fw init) are exempt — they're the user's
- * own Claude session, not automated workers.
+ * Interactive user sessions (e.g., fw init) are exempt, since they're the
+ * user's own Claude session, not automated workers.
  */
 import type { CliSessionOptions } from './types.js';
 /**

package/dist/agent/gate.d.ts

@@ -0,0 +1,164 @@
+import { type AgentProfile } from './profiles.js';
+import { type AgentMessage, type AgentProvider, type ToolDefinition } from './types.js';
+/** The field schema the console derives from TypeScript types (`src/console/schema.ts`), structurally. */
+export type FieldSchema = {
+    type: 'string';
+    optional?: boolean;
+} | {
+    type: 'number';
+    optional?: boolean;
+} | {
+    type: 'boolean';
+    optional?: boolean;
+} | {
+    type: 'enum';
+    values: Array<string | number>;
+    optional?: boolean;
+} | {
+    type: 'array';
+    items: FieldSchema;
+    optional?: boolean;
+    text?: string;
+} | {
+    type: 'object';
+    fields?: Record<string, FieldSchema>;
+    text?: string;
+    optional?: boolean;
+} | {
+    type: 'any';
+    text?: string;
+    optional?: boolean;
+};
+/** What the coordinator recorded about the paused gate, plus what is known of its output shape. */
+export interface GateToAnswer {
+    node: string;
+    inputs: Record<string, unknown>;
+    absent: string[];
+    outputs: string[];
+    hasFailurePort: boolean;
+    outputSchema?: Record<string, FieldSchema> | null;
+    outputTypes?: Record<string, string>;
+}
+/** What the model is told the gate belongs to. */
+export interface GateWorkflow {
+    name: string;
+    description?: string;
+}
+export type GateOutcome = {
+    kind: 'answer';
+    answer: unknown;
+} | {
+    kind: 'reject';
+    reason: string;
+} | {
+    kind: 'failed';
+    error: string;
+};
+export interface GateUsage {
+    promptTokens: number;
+    completionTokens: number;
+    costUsd?: number;
+}
+/** One thing that happened while the model worked, compact enough to stream and to keep. */
+export type AgentGateEvent = {
+    type: 'agent';
+    phase: 'start';
+    profile: string;
+    provider: string;
+    model?: string;
+} | {
+    type: 'agent';
+    phase: 'text';
+    text: string;
+} | {
+    type: 'agent';
+    phase: 'thinking';
+    text: string;
+} | {
+    type: 'agent';
+    phase: 'tool';
+    stage: 'start' | 'result';
+    name: string;
+    args?: Record<string, unknown>;
+    result?: string;
+    isError?: boolean;
+} | {
+    type: 'agent';
+    phase: 'usage';
+    promptTokens: number;
+    completionTokens: number;
+    costUsd?: number;
+} | {
+    type: 'agent';
+    phase: 'done';
+    outcome: GateOutcome['kind'];
+    ms: number;
+    error?: string;
+    reason?: string;
+};
+export interface GateAgentResult {
+    outcome: GateOutcome;
+    usage: GateUsage;
+    toolCalls: number;
+    ms: number;
+    /** The conversation as it stood at the end, for the transcript. */
+    transcript: AgentMessage[];
+    /** What the model said in prose, if anything. */
+    text: string;
+}
+export interface AnswerGateOptions {
+    gate: GateToAnswer;
+    workflow: GateWorkflow;
+    profile: AgentProfile;
+    /** The provider to call, built from the profile and environment when omitted. */
+    provider?: AgentProvider;
+    env?: NodeJS.ProcessEnv;
+    /** Working directory for a CLI provider. */
+    cwd?: string;
+    signal?: AbortSignal;
+    onEvent?: (event: AgentGateEvent) => void;
+}
+export declare const SUBMIT_TOOL = "submit_answer";
+export declare const REJECT_TOOL = "reject";
+/** A provider for a profile, or a thrown error naming what is missing. */
+export declare function providerFor(profile: AgentProfile, env?: NodeJS.ProcessEnv, cwd?: string): AgentProvider;
+/** A field schema as JSON Schema, for a tool's input. */
+export declare function fieldToJsonSchema(f: FieldSchema | undefined): Record<string, unknown>;
+/**
+ * The `submit_answer` tool's schema for a gate, and how its arguments become
+ * the gate's answer. One object-shaped output is the tool's whole input;
+ * one scalar output rides under `value`; several outputs are one property
+ * each, all required, exactly as `buildGateResolution` will want them.
+ */
+export declare function answerTool(gate: GateToAnswer): {
+    tool: ToolDefinition;
+    unwrap: (args: Record<string, unknown>) => unknown;
+};
+/** The frame every gate-answering conversation is set in; the profile's own text comes first. */
+export declare function systemPromptFor(profile: AgentProfile, workflow: GateWorkflow, gate: GateToAnswer): string;
+/** The one user message: the inputs, and the prompt again on its own so it reads as the instruction. */
+export declare function userMessageFor(gate: GateToAnswer): string;
+export interface TryResult {
+    ok: boolean;
+    ms: number;
+    /** What the model said, trimmed. */
+    text?: string;
+    usage?: GateUsage;
+    error?: string;
+}
+/**
+ * One short round trip through a profile, to learn whether it works at all:
+ * the key is right, the endpoint answers, the model exists. No tools, one
+ * turn, a one-word task. The only way to know before a real gate depends
+ * on it.
+ */
+export declare function tryProfile(profile: AgentProfile, env?: NodeJS.ProcessEnv, opts?: {
+    provider?: AgentProvider;
+    cwd?: string;
+    signal?: AbortSignal;
+}): Promise<TryResult>;
+/** A last resort when the model answered in prose: JSON in the text that fits the outputs. */
+export declare function answerFromText(text: string, gate: GateToAnswer): unknown | undefined;
+/** Run the model against the gate and say what it decided. Never throws for a model failure; only for a misconfiguration. */
+export declare function answerGate(opts: AnswerGateOptions): Promise<GateAgentResult>;
+//# sourceMappingURL=gate.d.ts.map

package/dist/agent/index.d.ts

@@ -12,13 +12,13 @@ export type { AnthropicProviderOptions } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
 export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
 export type { OpenAICompatProviderOptions } from './providers/openai-compat.js';
-export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
-export type { PlatformProviderOptions } from './providers/platform.js';
 export { createMcpBridge } from './mcp-bridge.js';
 export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
 export { getCliBaseArgs, getCliSessionConfig } from './cli-spawn-config.js';
 export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
 export { StreamJsonParser } from './streaming.js';
-export { DeviceConnection } from './device-connection.js';
-export type { DeviceConnectionOptions, DeviceInfo, DeviceEvent } from './device-connection.js';
+export { loadAgentProfiles, saveAgentProfiles, validateProfile, profileForGate, readiness, keyEnvOf, agentsFile, STARTER_AGENTS_YAML, DEFAULT_MODEL, DEFAULT_MAX_ITERATIONS, SUGGESTED_MODELS, } from './profiles.js';
+export type { AgentProfile, AgentProfiles, AgentProviderKind, Readiness } from './profiles.js';
+export { answerGate, tryProfile, providerFor, answerTool, fieldToJsonSchema, systemPromptFor, userMessageFor, answerFromText, SUBMIT_TOOL, REJECT_TOOL } from './gate.js';
+export type { GateToAnswer, GateWorkflow, GateOutcome, GateUsage, AgentGateEvent, GateAgentResult, AnswerGateOptions, TryResult } from './gate.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -1,28 +1,174 @@
-/**
- * @synergenius/flow-weaver/agent
- *
- * Provider-agnostic agent loop with MCP bridge for tool execution.
- * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
- */
-// Prompt utilities
-export { joinSplitPrompt, stripMcpToolPrefix } from './types.js';
-// Agent loop
-export { runAgentLoop } from './agent-loop.js';
-// Providers
-export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
-export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
-export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
-export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
-// MCP bridge
-export { createMcpBridge } from './mcp-bridge.js';
-// CLI session (warm persistent sessions)
-export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
-// CLI spawn configuration (centralized lockdown for automated sessions)
-export { getCliBaseArgs, getCliSessionConfig } from './cli-spawn-config.js';
-// Env utilities
-export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
-// Stream parser (for custom providers)
-export { StreamJsonParser } from './streaming.js';
-// Device connection (mount local machine into platform Studio)
-export { DeviceConnection } from './device-connection.js';
-//# sourceMappingURL=index.js.map
+import {
+  AnthropicProvider,
+  ClaudeCliProvider,
+  DEFAULT_MAX_ITERATIONS,
+  DEFAULT_MODEL,
+  OpenAICompatProvider,
+  REJECT_TOOL,
+  STARTER_AGENTS_YAML,
+  SUBMIT_TOOL,
+  SUGGESTED_MODELS,
+  StreamJsonParser,
+  agentsFile,
+  answerFromText,
+  answerGate,
+  answerTool,
+  createAnthropicProvider,
+  createClaudeCliProvider,
+  createOpenAICompatProvider,
+  fieldToJsonSchema,
+  joinSplitPrompt,
+  keyEnvOf,
+  loadAgentProfiles,
+  profileForGate,
+  providerFor,
+  readiness,
+  runAgentLoop,
+  saveAgentProfiles,
+  stripMcpToolPrefix,
+  systemPromptFor,
+  tryProfile,
+  userMessageFor,
+  validateProfile
+} from "../chunks/chunk-Q6MDDZMT.js";
+import "../chunks/chunk-DUO6H5PR.js";
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/agent/index.ts
+import { createMcpBridge } from "./mcp-bridge.js";
+import {
+  CliSession,
+  getOrCreateCliSession,
+  killCliSession,
+  killAllCliSessions
+} from "./cli-session.js";
+
+// src/agent/cli-spawn-config.ts
+function getCliBaseArgs(options) {
+  const args = [
+    "-p",
+    "--dangerously-skip-permissions",
+    // Disable ALL built-in tools, so only pack/MCP tools are visible to model
+    "--allowed-tools",
+    "",
+    // Prevent user/project MCP servers from leaking into sessions
+    "--strict-mcp-config"
+  ];
+  if (options?.outputFormat) {
+    args.push("--output-format", options.outputFormat);
+  }
+  if (options?.includePartialMessages) {
+    args.push("--include-partial-messages");
+  }
+  if (options?.model) {
+    args.push("--model", options.model);
+  }
+  if (options?.systemPrompt) {
+    args.push("--system-prompt", options.systemPrompt);
+  }
+  if (options?.appendSystemPrompt) {
+    args.push("--append-system-prompt", options.appendSystemPrompt);
+  }
+  if (options?.jsonSchema) {
+    args.push("--json-schema", options.jsonSchema);
+  }
+  return args;
+}
+function getCliSessionConfig(options) {
+  return {
+    binPath: options.binPath ?? "claude",
+    cwd: options.cwd,
+    model: options.model,
+    mcpConfigPath: options.mcpConfigPath,
+    disallowedTools: options.disallowedTools,
+    // Mandatory lockdown, cannot be overridden by callers
+    allowedTools: [],
+    strictMcpConfig: true,
+    appendSystemPrompt: options.appendSystemPrompt,
+    systemPrompt: options.systemPrompt
+  };
+}
+
+// src/agent/env-allowlist.ts
+var MINIMAL_PATH = "/usr/local/bin:/usr/bin:/bin";
+var 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"
+];
+function buildSafeEnv(overrides) {
+  const env = {};
+  for (const key of ENV_ALLOWLIST) {
+    if (process.env[key] !== void 0) {
+      env[key] = process.env[key];
+    }
+  }
+  if (overrides) {
+    Object.assign(env, overrides);
+  }
+  return env;
+}
+function buildSafeSpawnOpts(cwd, envOverrides) {
+  return { cwd, env: buildSafeEnv(envOverrides) };
+}
+export {
+  AnthropicProvider,
+  ClaudeCliProvider,
+  CliSession,
+  DEFAULT_MAX_ITERATIONS,
+  DEFAULT_MODEL,
+  ENV_ALLOWLIST,
+  MINIMAL_PATH,
+  OpenAICompatProvider,
+  REJECT_TOOL,
+  STARTER_AGENTS_YAML,
+  SUBMIT_TOOL,
+  SUGGESTED_MODELS,
+  StreamJsonParser,
+  agentsFile,
+  answerFromText,
+  answerGate,
+  answerTool,
+  buildSafeEnv,
+  buildSafeSpawnOpts,
+  createAnthropicProvider,
+  createClaudeCliProvider,
+  createMcpBridge,
+  createOpenAICompatProvider,
+  fieldToJsonSchema,
+  getCliBaseArgs,
+  getCliSessionConfig,
+  getOrCreateCliSession,
+  joinSplitPrompt,
+  keyEnvOf,
+  killAllCliSessions,
+  killCliSession,
+  loadAgentProfiles,
+  profileForGate,
+  providerFor,
+  readiness,
+  runAgentLoop,
+  saveAgentProfiles,
+  stripMcpToolPrefix,
+  systemPromptFor,
+  tryProfile,
+  userMessageFor,
+  validateProfile
+};

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

@@ -1,5 +1,5 @@
 /**
- * MCP bridge — creates a Unix domain socket server that the MCP tool server
+ * 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.
  *

package/dist/agent/mcp-bridge.js

@@ -1,132 +1,118 @@
-/**
- * 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 * as net from 'node:net';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { fileURLToPath } from 'node:url';
-/**
- * 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 async function createMcpBridge(tools, executor, onToolEvent, logger) {
-    // Create temp directory for bridge files
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fw-mcp-bridge-'));
-    fs.chmodSync(tmpDir, 0o700);
-    const socketPath = path.join(tmpDir, 'bridge.sock');
-    const defsPath = path.join(tmpDir, 'tools.json');
-    const configPath = path.join(tmpDir, 'mcp-config.json');
-    // Write tool definitions in MCP format
-    const mcpToolDefs = tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        inputSchema: t.inputSchema,
-    }));
-    fs.writeFileSync(defsPath, JSON.stringify(mcpToolDefs), 'utf-8');
-    // Resolve the MCP tool server script path.
-    // In prod: sibling .js file. In dev (tsx): sibling .ts file.
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const jsPath = path.resolve(__dirname, 'mcp-tool-server.js');
-    const tsPath = path.resolve(__dirname, 'mcp-tool-server.ts');
-    const scriptPath = fs.existsSync(jsPath) ? jsPath : tsPath;
-    // In dev the script is .ts — use tsx as the loader.
-    const mcpCommand = process.execPath; // node
-    let mcpArgs = [scriptPath];
-    if (scriptPath.endsWith('.ts')) {
-        // Look for tsx in the package's node_modules
-        const tsxCli = path.resolve(__dirname, '../../node_modules/tsx/dist/cli.mjs');
-        if (fs.existsSync(tsxCli)) {
-            mcpArgs = [tsxCli, scriptPath];
+// src/agent/mcp-bridge.ts
+import * as net from "node:net";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { fileURLToPath } from "node:url";
+
+// src/utils/error-utils.ts
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/agent/mcp-bridge.ts
+async function createMcpBridge(tools, executor, onToolEvent, logger) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fw-mcp-bridge-"));
+  fs.chmodSync(tmpDir, 448);
+  const socketPath = path.join(tmpDir, "bridge.sock");
+  const defsPath = path.join(tmpDir, "tools.json");
+  const configPath = path.join(tmpDir, "mcp-config.json");
+  const mcpToolDefs = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema
+  }));
+  fs.writeFileSync(defsPath, JSON.stringify(mcpToolDefs), "utf-8");
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const jsPath = path.resolve(__dirname, "mcp-tool-server.js");
+  const tsPath = path.resolve(__dirname, "mcp-tool-server.ts");
+  const scriptPath = fs.existsSync(jsPath) ? jsPath : tsPath;
+  const mcpCommand = process.execPath;
+  let mcpArgs = [scriptPath];
+  if (scriptPath.endsWith(".ts")) {
+    const tsxCli = path.resolve(__dirname, "../../node_modules/tsx/dist/cli.mjs");
+    if (fs.existsSync(tsxCli)) {
+      mcpArgs = [tsxCli, scriptPath];
+    }
+  }
+  const mcpConfig = {
+    mcpServers: {
+      "fw-agent": {
+        type: "stdio",
+        command: mcpCommand,
+        args: mcpArgs,
+        env: {
+          FW_TOOL_SOCKET: socketPath,
+          FW_TOOL_DEFS: defsPath
         }
+      }
     }
-    // Write MCP config
-    const mcpConfig = {
-        mcpServers: {
-            'fw-agent': {
-                type: 'stdio',
-                command: mcpCommand,
-                args: mcpArgs,
-                env: {
-                    FW_TOOL_SOCKET: socketPath,
-                    FW_TOOL_DEFS: defsPath,
-                },
-            },
-        },
-    };
-    fs.writeFileSync(configPath, JSON.stringify(mcpConfig), 'utf-8');
-    // Mutable handlers — swapped per request via setHandlers()
-    let currentExecutor = executor;
-    let currentOnToolEvent = onToolEvent;
-    // Create Unix domain socket server.
-    // The tool server sends a newline-terminated JSON request and waits for a
-    // JSON response on the same connection.
-    const server = net.createServer((conn) => {
-        let buf = '';
-        conn.on('data', async (chunk) => {
-            buf += chunk.toString();
-            const nlIdx = buf.indexOf('\n');
-            if (nlIdx === -1)
-                return; // wait for complete line
-            const line = buf.slice(0, nlIdx).trim();
-            buf = ''; // consume — one request per connection
-            try {
-                const { name, args } = JSON.parse(line);
-                currentOnToolEvent?.({ type: 'tool_call_start', name, args });
-                const { result, isError } = await currentExecutor(name, args);
-                currentOnToolEvent?.({ type: 'tool_call_result', name, result, isError });
-                conn.end(JSON.stringify({ result, isError }));
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                logger?.error('MCP bridge tool execution error', err);
-                conn.end(JSON.stringify({ result: msg, isError: true }));
-            }
-        });
-    });
-    await new Promise((resolve, reject) => {
-        server.on('error', reject);
-        server.listen(socketPath, () => resolve());
+  };
+  fs.writeFileSync(configPath, JSON.stringify(mcpConfig), "utf-8");
+  let currentExecutor = executor;
+  let currentOnToolEvent = onToolEvent;
+  const answer = async (line) => {
+    try {
+      const { name, args } = JSON.parse(line);
+      currentOnToolEvent?.({ type: "tool_call_start", name, args });
+      const { result, isError } = await currentExecutor(name, args);
+      currentOnToolEvent?.({ type: "tool_call_result", name, result, isError });
+      return JSON.stringify({ result, isError });
+    } catch (err) {
+      const msg = getErrorMessage(err);
+      try {
+        logger?.error("MCP bridge tool execution error", err);
+      } catch {
+      }
+      return JSON.stringify({ result: msg, isError: true });
+    }
+  };
+  const server = net.createServer((conn) => {
+    let buf = "";
+    conn.on("data", (chunk) => {
+      buf += chunk.toString();
+      const nlIdx = buf.indexOf("\n");
+      if (nlIdx === -1) return;
+      const line = buf.slice(0, nlIdx).trim();
+      buf = "";
+      answer(line).then((reply) => conn.end(reply)).catch(() => conn.destroy());
     });
-    let cleaned = false;
-    const cleanup = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        server.close();
-        try {
-            fs.unlinkSync(socketPath);
-        }
-        catch { }
-        try {
-            fs.unlinkSync(defsPath);
-        }
-        catch { }
-        try {
-            fs.unlinkSync(configPath);
-        }
-        catch { }
-        try {
-            fs.rmdirSync(tmpDir);
-        }
-        catch { }
-    };
-    const setHandlers = (exec, onEvt) => {
-        currentExecutor = exec;
-        currentOnToolEvent = onEvt;
-    };
-    return { configPath, setHandlers, cleanup };
+  });
+  await new Promise((resolve2, reject) => {
+    server.on("error", reject);
+    server.listen(socketPath, () => resolve2());
+  });
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    server.close();
+    try {
+      fs.unlinkSync(socketPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(defsPath);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(configPath);
+    } catch {
+    }
+    try {
+      fs.rmdirSync(tmpDir);
+    } catch {
+    }
+  };
+  const setHandlers = (exec, onEvt) => {
+    currentExecutor = exec;
+    currentOnToolEvent = onEvt;
+  };
+  return { configPath, setHandlers, cleanup };
 }
-//# sourceMappingURL=mcp-bridge.js.map
+export {
+  createMcpBridge
+};