@contractspec/lib.ai-agent 1.57.0 → 1.59.0

package/dist/interop/tool-consumer.js

@@ -1,220 +1,419 @@
-import { specToolToClaudeAgentTool } from "../providers/claude-agent-sdk/tool-bridge.js";
-import { specToolToOpenCodeTool } from "../providers/opencode-sdk/tool-bridge.js";
-
-//#region src/interop/tool-consumer.ts
-/**
-* Simple MCP-compatible tool server.
-*/
-var MCPToolServer = class {
-	tools;
-	name;
-	version;
-	running = false;
-	constructor(config) {
-		this.tools = /* @__PURE__ */ new Map();
-		this.name = config.name ?? "contractspec-tools";
-		this.version = config.version ?? "1.0.0";
-		for (const tool of config.tools) this.tools.set(tool.config.name, tool);
-	}
-	async start() {
-		if (this.running) return;
-		this.running = true;
-		console.log(`[MCPToolServer] Started ${this.name}@${this.version} with ${this.tools.size} tools`);
-	}
-	async stop() {
-		if (!this.running) return;
-		this.running = false;
-		console.log(`[MCPToolServer] Stopped ${this.name}`);
-	}
-	isRunning() {
-		return this.running;
-	}
-	getTools() {
-		return Array.from(this.tools.values()).map((t) => t.config);
-	}
-	async executeTool(toolName, args, context) {
-		const tool = this.tools.get(toolName);
-		if (!tool) throw new Error(`Tool not found: ${toolName}`);
-		if (!tool.handler) throw new Error(`No handler registered for tool: ${toolName}`);
-		const fullContext = {
-			agentId: context?.agentId ?? "mcp-server",
-			sessionId: context?.sessionId ?? "mcp-session",
-			tenantId: context?.tenantId,
-			actorId: context?.actorId,
-			metadata: context?.metadata,
-			signal: context?.signal
-		};
-		return await tool.handler(args, fullContext);
-	}
-	/**
-	* Get MCP-compatible tool definitions.
-	*/
-	getMCPToolDefinitions() {
-		const definitions = [];
-		for (const [name, tool] of this.tools) definitions.push({
-			name,
-			description: tool.config.description ?? "",
-			inputSchema: tool.config.schema ?? {
-				type: "object",
-				properties: {}
-			}
-		});
-		return definitions;
-	}
-	/**
-	* Get server info for MCP.
-	*/
-	getServerInfo() {
-		return {
-			name: this.name,
-			version: this.version,
-			tools: this.tools.size,
-			running: this.running
-		};
-	}
-};
-/**
-* ContractSpec tool consumer for external agents.
-*/
-var ContractSpecToolConsumer = class {
-	tools;
-	constructor(config) {
-		this.tools = /* @__PURE__ */ new Map();
-		for (const tool of config.tools) this.tools.set(tool.config.name, tool);
-	}
-	/**
-	* Create an MCP server exposing the tools.
-	*/
-	createToolServer(config) {
-		return new MCPToolServer({
-			tools: Array.from(this.tools.values()),
-			...config
-		});
-	}
-	/**
-	* Export tools for a specific SDK format.
-	*/
-	exportToolsForSDK(format) {
-		const tools = Array.from(this.tools.values());
-		const defaultContext = {
-			agentId: "export",
-			sessionId: "export"
-		};
-		switch (format) {
-			case "claude-agent": return tools.filter((tool) => !!tool.handler).map((tool) => specToolToClaudeAgentTool(tool.config, tool.handler, defaultContext));
-			case "opencode": return tools.map((tool) => specToolToOpenCodeTool(tool.config));
-			case "mcp": return tools.map((tool) => ({
-				name: tool.config.name,
-				description: tool.config.description ?? "",
-				inputSchema: tool.config.schema ?? {
-					type: "object",
-					properties: {}
-				}
-			}));
-			case "openai": return tools.map((tool) => ({
-				type: "function",
-				function: {
-					name: tool.config.name,
-					description: tool.config.description ?? "",
-					parameters: tool.config.schema ?? {
-						type: "object",
-						properties: {}
-					}
-				}
-			}));
-			default: throw new Error(`Unknown export format: ${format}`);
-		}
-	}
-	/**
-	* Create a bridged handler for a specific SDK.
-	*/
-	createBridgedHandler(toolName, _format) {
-		const tool = this.tools.get(toolName);
-		if (!tool || !tool.handler) return;
-		const handler = tool.handler;
-		return async (args) => {
-			return handler(args, {
-				agentId: "bridge",
-				sessionId: "bridge"
-			});
-		};
-	}
-	/**
-	* Get all tools.
-	*/
-	getTools() {
-		return Array.from(this.tools.values()).map((t) => t.config);
-	}
-	/**
-	* Get a specific tool.
-	*/
-	getTool(name) {
-		return this.tools.get(name)?.config;
-	}
-	/**
-	* Check if a tool exists.
-	*/
-	hasTool(name) {
-		return this.tools.has(name);
-	}
-	/**
-	* Execute a tool.
-	*/
-	async executeTool(name, args, context) {
-		const tool = this.tools.get(name);
-		if (!tool) throw new Error(`Tool not found: ${name}`);
-		if (!tool.handler) throw new Error(`No handler for tool: ${name}`);
-		const fullContext = {
-			agentId: context?.agentId ?? "consumer",
-			sessionId: context?.sessionId ?? "consumer-session",
-			tenantId: context?.tenantId,
-			actorId: context?.actorId,
-			metadata: context?.metadata,
-			signal: context?.signal
-		};
-		return await tool.handler(args, fullContext);
-	}
-	/**
-	* Add a tool.
-	*/
-	addTool(config, handler) {
-		this.tools.set(config.name, {
-			config,
-			handler
-		});
-	}
-	/**
-	* Remove a tool.
-	*/
-	removeTool(name) {
-		return this.tools.delete(name);
-	}
-	/**
-	* Get tool count.
-	*/
-	getToolCount() {
-		return this.tools.size;
-	}
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-/**
-* Create a new tool consumer.
-*/
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/providers/claude-agent-sdk/tool-bridge.ts
+function specToolToClaudeAgentTool(tool, handler, context) {
+  return {
+    name: tool.name,
+    description: tool.description ?? `Execute ${tool.name}`,
+    input_schema: normalizeSchema(tool.schema),
+    requires_confirmation: tool.requiresApproval ?? !tool.automationSafe,
+    execute: async (input) => {
+      const fullContext = {
+        agentId: context.agentId ?? "unknown",
+        sessionId: context.sessionId ?? "unknown",
+        tenantId: context.tenantId,
+        actorId: context.actorId,
+        metadata: context.metadata,
+        signal: context.signal
+      };
+      return handler(input, fullContext);
+    }
+  };
+}
+function specToolsToClaudeAgentTools(tools, handlers, context) {
+  return tools.filter((tool) => handlers.has(tool.name)).map((tool) => {
+    const handler = handlers.get(tool.name);
+    if (!handler) {
+      throw new Error(`Handler not found for tool ${tool.name}`);
+    }
+    return specToolToClaudeAgentTool(tool, handler, context);
+  });
+}
+function claudeAgentToolToSpecTool(claudeTool, execute) {
+  const config = {
+    name: claudeTool.name,
+    description: claudeTool.description,
+    schema: claudeTool.input_schema,
+    requiresApproval: claudeTool.requires_confirmation,
+    automationSafe: !claudeTool.requires_confirmation
+  };
+  const handler = execute ? async (input, _ctx) => String(await execute(input)) : undefined;
+  return { config, handler };
+}
+function claudeAgentToolsToSpecTools(claudeTools) {
+  const configs = [];
+  const handlers = new Map;
+  for (const claudeTool of claudeTools) {
+    const { config, handler } = claudeAgentToolToSpecTool(claudeTool, claudeTool.execute);
+    configs.push(config);
+    if (handler) {
+      handlers.set(config.name, handler);
+    }
+  }
+  return { configs, handlers };
+}
+function specToolToExternalTool(tool, handler, context) {
+  return {
+    name: tool.name,
+    description: tool.description ?? `Execute ${tool.name}`,
+    inputSchema: tool.schema ?? { type: "object" },
+    requiresApproval: tool.requiresApproval ?? !tool.automationSafe,
+    execute: handler ? async (input) => {
+      const fullContext = {
+        agentId: context?.agentId ?? "unknown",
+        sessionId: context?.sessionId ?? "unknown",
+        tenantId: context?.tenantId,
+        actorId: context?.actorId,
+        metadata: context?.metadata,
+        signal: context?.signal
+      };
+      return handler(input, fullContext);
+    } : undefined
+  };
+}
+function normalizeSchema(schema) {
+  if (!schema) {
+    return { type: "object" };
+  }
+  if (schema.type === "object") {
+    return schema;
+  }
+  return {
+    type: "object",
+    properties: {
+      value: schema
+    },
+    required: ["value"]
+  };
+}
+function extractToolCalls(response) {
+  if (!response.content) {
+    return [];
+  }
+  return response.content.filter((block) => block.type === "tool_use").map((block) => ({
+    toolCallId: block.id ?? "",
+    toolName: block.name ?? "",
+    args: block.input
+  }));
+}
+
+// src/providers/opencode-sdk/tool-bridge.ts
+function specToolToOpenCodeTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description ?? `Execute ${tool.name}`,
+    parameters: normalizeToOpenCodeParameters(tool.schema),
+    permission: getPermissionLevel(tool)
+  };
+}
+function specToolsToOpenCodeTools(tools) {
+  return tools.map(specToolToOpenCodeTool);
+}
+function getPermissionLevel(tool) {
+  if (tool.requiresApproval) {
+    return "ask";
+  }
+  if (tool.automationSafe === false) {
+    return "ask";
+  }
+  return "allow";
+}
+function openCodeToolToSpecTool(openCodeTool) {
+  return {
+    name: openCodeTool.name,
+    description: openCodeTool.description,
+    schema: openCodeTool.parameters,
+    requiresApproval: openCodeTool.permission === "ask",
+    automationSafe: openCodeTool.permission === "allow"
+  };
+}
+function openCodeToolsToSpecTools(openCodeTools) {
+  return openCodeTools.map(openCodeToolToSpecTool);
+}
+function specToolToExternalToolForOpenCode(tool, handler, context) {
+  return {
+    name: tool.name,
+    description: tool.description ?? `Execute ${tool.name}`,
+    inputSchema: tool.schema ?? { type: "object" },
+    requiresApproval: tool.requiresApproval ?? !tool.automationSafe,
+    execute: handler ? async (input) => {
+      const fullContext = {
+        agentId: context?.agentId ?? "unknown",
+        sessionId: context?.sessionId ?? "unknown",
+        tenantId: context?.tenantId,
+        actorId: context?.actorId,
+        metadata: context?.metadata,
+        signal: context?.signal
+      };
+      return handler(input, fullContext);
+    } : undefined
+  };
+}
+function normalizeToOpenCodeParameters(schema) {
+  if (!schema) {
+    return { type: "object" };
+  }
+  if (schema.type === "object") {
+    return {
+      type: "object",
+      properties: schema.properties,
+      required: schema.required
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      value: convertToOpenCodeParameter(schema)
+    },
+    required: ["value"]
+  };
+}
+function convertToOpenCodeParameter(schema) {
+  const param = {
+    type: schema.type ?? "string"
+  };
+  if (schema.description) {
+    param.description = schema.description;
+  }
+  if (schema.enum) {
+    param.enum = schema.enum;
+  }
+  if (schema.default !== undefined) {
+    param.default = schema.default;
+  }
+  return param;
+}
+function createToolHandlerMap(tools) {
+  const handlers = new Map;
+  for (const [name, tool] of Object.entries(tools)) {
+    if (tool.execute) {
+      handlers.set(name, tool.execute);
+    }
+  }
+  return handlers;
+}
+async function executeToolCall(toolCall, handlers) {
+  const handler = handlers.get(toolCall.name);
+  if (!handler) {
+    return {
+      tool_call_id: toolCall.id,
+      output: `Error: Tool '${toolCall.name}' not found`,
+      is_error: true
+    };
+  }
+  try {
+    const result = await handler(toolCall.arguments);
+    return {
+      tool_call_id: toolCall.id,
+      output: typeof result === "string" ? result : JSON.stringify(result)
+    };
+  } catch (error) {
+    return {
+      tool_call_id: toolCall.id,
+      output: `Error: ${error instanceof Error ? error.message : String(error)}`,
+      is_error: true
+    };
+  }
+}
+
+// src/interop/tool-consumer.ts
+class MCPToolServer {
+  tools;
+  name;
+  version;
+  running = false;
+  constructor(config) {
+    this.tools = new Map;
+    this.name = config.name ?? "contractspec-tools";
+    this.version = config.version ?? "1.0.0";
+    for (const tool of config.tools) {
+      this.tools.set(tool.config.name, tool);
+    }
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    console.log(`[MCPToolServer] Started ${this.name}@${this.version} with ${this.tools.size} tools`);
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    console.log(`[MCPToolServer] Stopped ${this.name}`);
+  }
+  isRunning() {
+    return this.running;
+  }
+  getTools() {
+    return Array.from(this.tools.values()).map((t) => t.config);
+  }
+  async executeTool(toolName, args, context) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    if (!tool.handler) {
+      throw new Error(`No handler registered for tool: ${toolName}`);
+    }
+    const fullContext = {
+      agentId: context?.agentId ?? "mcp-server",
+      sessionId: context?.sessionId ?? "mcp-session",
+      tenantId: context?.tenantId,
+      actorId: context?.actorId,
+      metadata: context?.metadata,
+      signal: context?.signal
+    };
+    return await tool.handler(args, fullContext);
+  }
+  getMCPToolDefinitions() {
+    const definitions = [];
+    for (const [name, tool] of this.tools) {
+      definitions.push({
+        name,
+        description: tool.config.description ?? "",
+        inputSchema: tool.config.schema ?? { type: "object", properties: {} }
+      });
+    }
+    return definitions;
+  }
+  getServerInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      tools: this.tools.size,
+      running: this.running
+    };
+  }
+}
+
+class ContractSpecToolConsumer {
+  tools;
+  constructor(config) {
+    this.tools = new Map;
+    for (const tool of config.tools) {
+      this.tools.set(tool.config.name, tool);
+    }
+  }
+  createToolServer(config) {
+    return new MCPToolServer({
+      tools: Array.from(this.tools.values()),
+      ...config
+    });
+  }
+  exportToolsForSDK(format) {
+    const tools = Array.from(this.tools.values());
+    const defaultContext = {
+      agentId: "export",
+      sessionId: "export"
+    };
+    switch (format) {
+      case "claude-agent":
+        return tools.filter((tool) => !!tool.handler).map((tool) => specToolToClaudeAgentTool(tool.config, tool.handler, defaultContext));
+      case "opencode":
+        return tools.map((tool) => specToolToOpenCodeTool(tool.config));
+      case "mcp":
+        return tools.map((tool) => ({
+          name: tool.config.name,
+          description: tool.config.description ?? "",
+          inputSchema: tool.config.schema ?? { type: "object", properties: {} }
+        }));
+      case "openai":
+        return tools.map((tool) => ({
+          type: "function",
+          function: {
+            name: tool.config.name,
+            description: tool.config.description ?? "",
+            parameters: tool.config.schema ?? {
+              type: "object",
+              properties: {}
+            }
+          }
+        }));
+      default:
+        throw new Error(`Unknown export format: ${format}`);
+    }
+  }
+  createBridgedHandler(toolName, _format) {
+    const tool = this.tools.get(toolName);
+    if (!tool || !tool.handler) {
+      return;
+    }
+    const handler = tool.handler;
+    return async (args) => {
+      const context = {
+        agentId: "bridge",
+        sessionId: "bridge"
+      };
+      return handler(args, context);
+    };
+  }
+  getTools() {
+    return Array.from(this.tools.values()).map((t) => t.config);
+  }
+  getTool(name) {
+    return this.tools.get(name)?.config;
+  }
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+  async executeTool(name, args, context) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    if (!tool.handler) {
+      throw new Error(`No handler for tool: ${name}`);
+    }
+    const fullContext = {
+      agentId: context?.agentId ?? "consumer",
+      sessionId: context?.sessionId ?? "consumer-session",
+      tenantId: context?.tenantId,
+      actorId: context?.actorId,
+      metadata: context?.metadata,
+      signal: context?.signal
+    };
+    return await tool.handler(args, fullContext);
+  }
+  addTool(config, handler) {
+    this.tools.set(config.name, { config, handler });
+  }
+  removeTool(name) {
+    return this.tools.delete(name);
+  }
+  getToolCount() {
+    return this.tools.size;
+  }
+}
 function createToolConsumer(config) {
-	return new ContractSpecToolConsumer(config);
+  return new ContractSpecToolConsumer(config);
 }
-/**
-* Create an MCP tool server from tools.
-*/
 function createToolServer(config) {
-	return new MCPToolServer(config);
+  return new MCPToolServer(config);
 }
-/**
-* Export tools to a specific SDK format.
-*/
 function exportToolsForExternalSDK(tools, format) {
-	return new ContractSpecToolConsumer({ tools: tools.map((config) => ({ config })) }).exportToolsForSDK(format);
+  const consumer = new ContractSpecToolConsumer({
+    tools: tools.map((config) => ({ config }))
+  });
+  return consumer.exportToolsForSDK(format);
 }
-
-//#endregion
-export { ContractSpecToolConsumer, createToolConsumer, createToolServer, exportToolsForExternalSDK };
-//# sourceMappingURL=tool-consumer.js.map
+export {
+  exportToolsForExternalSDK,
+  createToolServer,
+  createToolConsumer,
+  ContractSpecToolConsumer
+};