@contractspec/lib.ai-agent 1.57.0 → 1.59.0

package/dist/node/index.js

@@ -0,0 +1,3337 @@
+import { createRequire } from "node:module";
+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
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/spec/spec.ts
+function defineAgent(spec) {
+  if (!spec.meta?.key) {
+    throw new Error("Agent key is required");
+  }
+  if (typeof spec.meta.version !== "string") {
+    throw new Error(`Agent ${spec.meta.key} is missing a string version`);
+  }
+  if (!spec.instructions?.trim()) {
+    throw new Error(`Agent ${spec.meta.key} requires instructions`);
+  }
+  if (!spec.tools?.length) {
+    throw new Error(`Agent ${spec.meta.key} must expose at least one tool`);
+  }
+  const toolNames = new Set;
+  for (const tool of spec.tools) {
+    if (toolNames.has(tool.name)) {
+      throw new Error(`Agent ${spec.meta.key} has duplicate tool name: ${tool.name}`);
+    }
+    toolNames.add(tool.name);
+  }
+  return Object.freeze(spec);
+}
+function agentKey(meta) {
+  return `${meta.key}.v${meta.version}`;
+}
+
+// src/schema/json-schema-to-zod.ts
+import { z } from "zod";
+function jsonSchemaToZod(schema) {
+  const s = schema;
+  const makeNullable = (zodSchema) => {
+    return s.nullable ? z.union([zodSchema, z.null()]) : zodSchema;
+  };
+  if (s.const !== undefined) {
+    return z.literal(s.const);
+  }
+  if (s.enum) {
+    const values = s.enum;
+    return makeNullable(z.enum(values.map(String)));
+  }
+  if (s.anyOf && s.anyOf.length > 0) {
+    const schemas = s.anyOf.map((sub) => jsonSchemaToZod(sub));
+    if (schemas.length === 1)
+      return schemas[0] ?? z.unknown();
+    return z.union([
+      schemas[0] ?? z.unknown(),
+      schemas[1] ?? z.unknown(),
+      ...schemas.slice(2)
+    ]);
+  }
+  if (s.oneOf && s.oneOf.length > 0) {
+    const schemas = s.oneOf.map((sub) => jsonSchemaToZod(sub));
+    if (schemas.length === 1)
+      return schemas[0] ?? z.unknown();
+    return z.union([
+      schemas[0] ?? z.unknown(),
+      schemas[1] ?? z.unknown(),
+      ...schemas.slice(2)
+    ]);
+  }
+  if (s.allOf && s.allOf.length > 0) {
+    const schemas = s.allOf.map((sub) => jsonSchemaToZod(sub));
+    return schemas.reduce((acc, curr) => z.intersection(acc, curr));
+  }
+  switch (s.type) {
+    case "string":
+      return makeNullable(buildStringSchema(s));
+    case "number":
+    case "integer":
+      return makeNullable(buildNumberSchema(s));
+    case "boolean":
+      return makeNullable(z.boolean());
+    case "null":
+      return z.null();
+    case "array":
+      return makeNullable(buildArraySchema(s));
+    case "object":
+      return makeNullable(buildObjectSchema(s));
+    default:
+      return z.unknown();
+  }
+}
+function buildStringSchema(schema) {
+  let zodSchema = z.string();
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  switch (schema.format) {
+    case "email":
+      zodSchema = zodSchema.email();
+      break;
+    case "uri":
+    case "url":
+      zodSchema = zodSchema.url();
+      break;
+    case "uuid":
+      zodSchema = zodSchema.uuid();
+      break;
+    case "date-time":
+      zodSchema = zodSchema.datetime();
+      break;
+    case "date":
+      zodSchema = zodSchema.date();
+      break;
+  }
+  if (schema.minLength !== undefined) {
+    zodSchema = zodSchema.min(schema.minLength);
+  }
+  if (schema.maxLength !== undefined) {
+    zodSchema = zodSchema.max(schema.maxLength);
+  }
+  if (schema.pattern) {
+    zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+  }
+  return zodSchema;
+}
+function buildNumberSchema(schema) {
+  let zodSchema = schema.type === "integer" ? z.number().int() : z.number();
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  if (schema.minimum !== undefined) {
+    zodSchema = zodSchema.min(schema.minimum);
+  }
+  if (schema.maximum !== undefined) {
+    zodSchema = zodSchema.max(schema.maximum);
+  }
+  return zodSchema;
+}
+function buildArraySchema(schema) {
+  const itemsSchema = schema.items ? jsonSchemaToZod(schema.items) : z.unknown();
+  let zodSchema = z.array(itemsSchema);
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  return zodSchema;
+}
+function buildObjectSchema(schema) {
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const shape = {};
+  for (const [key, propSchema] of Object.entries(properties)) {
+    const zodProp = jsonSchemaToZod(propSchema);
+    shape[key] = required.has(key) ? zodProp : zodProp.optional();
+  }
+  let zodSchema = z.object(shape);
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  return zodSchema;
+}
+function jsonSchemaToZodSafe(schema) {
+  if (!schema || Object.keys(schema).length === 0) {
+    return z.object({});
+  }
+  return jsonSchemaToZod(schema);
+}
+var init_json_schema_to_zod = () => {};
+
+// src/tools/tool-adapter.ts
+import { tool } from "ai";
+function specToolToAISDKTool(specTool, handler, context = {}) {
+  return tool({
+    description: specTool.description ?? specTool.name,
+    inputSchema: jsonSchemaToZodSafe(specTool.schema),
+    needsApproval: specTool.requiresApproval ?? !specTool.automationSafe,
+    execute: async (input) => {
+      const result = await handler(input, {
+        agentId: context.agentId ?? "unknown",
+        sessionId: context.sessionId ?? "unknown",
+        tenantId: context.tenantId,
+        actorId: context.actorId,
+        metadata: context.metadata,
+        signal: context.signal
+      });
+      return typeof result === "string" ? result : JSON.stringify(result);
+    }
+  });
+}
+function specToolsToAISDKTools(specTools, handlers, context = {}) {
+  const tools = {};
+  for (const specTool of specTools) {
+    const handler = handlers.get(specTool.name);
+    if (!handler) {
+      throw new Error(`Missing handler for tool: ${specTool.name}`);
+    }
+    tools[specTool.name] = specToolToAISDKTool(specTool, handler, context);
+  }
+  return tools;
+}
+function createToolHandler(handler) {
+  return async (input, context) => {
+    return handler(input, context);
+  };
+}
+function buildToolHandlers(handlersObj) {
+  return new Map(Object.entries(handlersObj));
+}
+var init_tool_adapter = __esm(() => {
+  init_json_schema_to_zod();
+});
+
+// src/tools/knowledge-tool.ts
+import { tool as tool2 } from "ai";
+import * as z2 from "zod";
+function createKnowledgeQueryTool(retriever, knowledgeRefs) {
+  const optionalSpaces = knowledgeRefs.filter((k) => !k.required).map((k) => k.key).filter((key) => retriever.supportsSpace(key));
+  if (optionalSpaces.length === 0) {
+    return null;
+  }
+  const spaceDescriptions = knowledgeRefs.filter((k) => !k.required && retriever.supportsSpace(k.key)).map((k) => `- ${k.key}: ${k.instructions ?? "Knowledge space"}`).join(`
+`);
+  return tool2({
+    description: `Query knowledge bases for relevant information. Use this tool when you need to look up specific information that may not be in your context.
+
+Available knowledge spaces:
+${spaceDescriptions}`,
+    inputSchema: z2.object({
+      query: z2.string().describe("The question or search query to find relevant information"),
+      spaceKey: z2.enum(optionalSpaces).optional().describe("Specific knowledge space to query. If omitted, searches all available spaces."),
+      topK: z2.number().optional().default(5).describe("Maximum number of results to return")
+    }),
+    execute: async ({ query, spaceKey, topK }) => {
+      const spacesToSearch = spaceKey ? [spaceKey] : optionalSpaces;
+      const allResults = [];
+      for (const space of spacesToSearch) {
+        try {
+          const results = await retriever.retrieve(query, {
+            spaceKey: space,
+            topK: topK ?? 5
+          });
+          for (const result of results) {
+            allResults.push({
+              space,
+              content: result.content,
+              score: result.score
+            });
+          }
+        } catch (error) {
+          console.warn(`Failed to query knowledge space ${space}:`, error);
+        }
+      }
+      if (allResults.length === 0) {
+        return "No relevant information found in the knowledge bases.";
+      }
+      allResults.sort((a, b) => b.score - a.score);
+      const topResults = allResults.slice(0, topK ?? 5);
+      return topResults.map((r, i) => `[Source ${i + 1} - ${r.space}] (relevance: ${(r.score * 100).toFixed(0)}%)
+${r.content}`).join(`
+
+---
+
+`);
+    }
+  });
+}
+var init_knowledge_tool = () => {};
+
+// src/knowledge/injector.ts
+async function injectStaticKnowledge(instructions, knowledgeRefs, retriever) {
+  if (!retriever)
+    return instructions;
+  const requiredRefs = knowledgeRefs.filter((ref) => ref.required);
+  if (requiredRefs.length === 0)
+    return instructions;
+  const blocks = [];
+  for (const ref of requiredRefs) {
+    if (!retriever.supportsSpace(ref.key)) {
+      console.warn(`Required knowledge space "${ref.key}" is not available`);
+      continue;
+    }
+    try {
+      const content = await retriever.getStatic(ref.key);
+      if (content) {
+        const header = ref.instructions ? `## ${ref.key}
+${ref.instructions}` : `## ${ref.key}`;
+        blocks.push(`${header}
+
+${content}`);
+      }
+    } catch (error) {
+      console.warn(`Failed to load required knowledge "${ref.key}":`, error);
+    }
+  }
+  if (blocks.length === 0)
+    return instructions;
+  return `${instructions}
+
+---
+
+# Reference Knowledge
+
+The following information is provided for your reference. Use it to inform your responses.
+
+${blocks.join(`
+
+---
+
+`)}`;
+}
+function createKnowledgeInjector(retriever) {
+  return {
+    inject: (instructions, knowledgeRefs) => injectStaticKnowledge(instructions, knowledgeRefs, retriever),
+    hasSpace: (spaceKey) => retriever?.supportsSpace(spaceKey) ?? false,
+    listSpaces: () => retriever?.listSpaces() ?? []
+  };
+}
+
+// src/session/store.ts
+class InMemorySessionStore {
+  sessions = new Map;
+  async get(sessionId) {
+    return this.sessions.get(sessionId) ?? null;
+  }
+  async create(session) {
+    const now = new Date;
+    const fullSession = {
+      ...session,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.sessions.set(session.sessionId, fullSession);
+    return fullSession;
+  }
+  async appendStep(sessionId, step) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.steps.push(step);
+      session.updatedAt = new Date;
+    }
+  }
+  async appendMessage(sessionId, message) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.messages.push(message);
+      session.updatedAt = new Date;
+    }
+  }
+  async update(sessionId, updates) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      Object.assign(session, updates, { updatedAt: new Date });
+    }
+  }
+  async delete(sessionId) {
+    return this.sessions.delete(sessionId);
+  }
+  async listByAgent(agentId, limit = 100) {
+    const results = [];
+    for (const session of this.sessions.values()) {
+      if (session.agentId === agentId) {
+        results.push(session);
+        if (results.length >= limit)
+          break;
+      }
+    }
+    return results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  }
+  async listByTenant(tenantId, limit = 100) {
+    const results = [];
+    for (const session of this.sessions.values()) {
+      if (session.tenantId === tenantId) {
+        results.push(session);
+        if (results.length >= limit)
+          break;
+      }
+    }
+    return results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  }
+  clear() {
+    this.sessions.clear();
+  }
+}
+function createInMemorySessionStore() {
+  return new InMemorySessionStore;
+}
+function generateSessionId() {
+  return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+
+// src/telemetry/adapter.ts
+function parseAgentId(agentId) {
+  const match = agentId.match(/^(.+)\.v(\s+)$/);
+  if (match) {
+    return { name: match[1], version: match[2] };
+  }
+  return { name: agentId, version: "1.0.0" };
+}
+async function trackAgentStep(collector, agentId, step, durationMs) {
+  const { name, version } = parseAgentId(agentId);
+  for (const toolCall of step.toolCalls ?? []) {
+    const toolSample = {
+      operation: { name: `${name}.${toolCall.toolName}`, version },
+      durationMs: durationMs ?? 0,
+      success: step.toolResults?.some((r) => r.toolCallId === toolCall.toolCallId && r.output !== undefined) ?? false,
+      timestamp: new Date,
+      metadata: {
+        agentId,
+        toolName: toolCall.toolName,
+        finishReason: step.finishReason
+      }
+    };
+    await collector.collect(toolSample);
+  }
+  const stepSample = {
+    operation: { name, version },
+    durationMs: durationMs ?? 0,
+    success: step.finishReason !== "error",
+    timestamp: new Date,
+    metadata: {
+      agentId,
+      finishReason: step.finishReason,
+      tokenUsage: step.usage,
+      toolCallCount: step.toolCalls?.length ?? 0
+    }
+  };
+  await collector.collect(stepSample);
+}
+
+class InMemoryTelemetryCollector {
+  samples = [];
+  async collect(sample) {
+    this.samples.push(sample);
+  }
+  getSamples() {
+    return [...this.samples];
+  }
+  getSamplesForOperation(operationName) {
+    return this.samples.filter((s) => s.operation.name === operationName);
+  }
+  clear() {
+    this.samples.length = 0;
+  }
+}
+function createInMemoryTelemetryCollector() {
+  return new InMemoryTelemetryCollector;
+}
+var noopTelemetryCollector;
+var init_adapter = __esm(() => {
+  noopTelemetryCollector = {
+    collect: async () => {}
+  };
+});
+
+// src/agent/contract-spec-agent.ts
+var exports_contract_spec_agent = {};
+__export(exports_contract_spec_agent, {
+  ContractSpecAgent: () => ContractSpecAgent
+});
+import {
+  Experimental_Agent as ToolLoopAgent,
+  stepCountIs
+} from "ai";
+import * as z3 from "zod";
+
+class ContractSpecAgent {
+  version = "agent-v1";
+  id;
+  spec;
+  tools;
+  inner;
+  config;
+  instructions;
+  constructor(config, instructions, tools) {
+    this.config = config;
+    this.spec = config.spec;
+    this.id = agentKey(config.spec.meta);
+    this.tools = tools;
+    this.instructions = instructions;
+    this.inner = new ToolLoopAgent({
+      model: config.model,
+      instructions,
+      tools,
+      stopWhen: stepCountIs(config.spec.maxSteps ?? 10),
+      callOptionsSchema: ContractSpecCallOptionsSchema,
+      onStepFinish: async (step) => {
+        await this.handleStepFinish(step);
+      }
+    });
+  }
+  static async create(config) {
+    const instructions = await injectStaticKnowledge(config.spec.instructions, config.spec.knowledge ?? [], config.knowledgeRetriever);
+    const specTools = specToolsToAISDKTools(config.spec.tools, config.toolHandlers, { agentId: agentKey(config.spec.meta) });
+    const knowledgeTool = config.knowledgeRetriever ? createKnowledgeQueryTool(config.knowledgeRetriever, config.spec.knowledge ?? []) : null;
+    const tools = {
+      ...specTools,
+      ...knowledgeTool ? { query_knowledge: knowledgeTool } : {},
+      ...config.additionalTools ?? {}
+    };
+    return new ContractSpecAgent(config, instructions, tools);
+  }
+  async generate(params) {
+    const sessionId = params.options?.sessionId ?? generateSessionId();
+    if (this.config.sessionStore) {
+      const existing = await this.config.sessionStore.get(sessionId);
+      if (!existing) {
+        await this.config.sessionStore.create({
+          sessionId,
+          agentId: this.id,
+          tenantId: params.options?.tenantId,
+          actorId: params.options?.actorId,
+          status: "running",
+          messages: [],
+          steps: [],
+          metadata: params.options?.metadata
+        });
+      }
+    }
+    const prompt = params.systemOverride ? `${this.instructions}
+
+${params.systemOverride}
+
+${params.prompt}` : params.prompt;
+    const result = await this.inner.generate({
+      prompt,
+      abortSignal: params.signal,
+      options: {
+        tenantId: params.options?.tenantId,
+        actorId: params.options?.actorId,
+        sessionId,
+        metadata: params.options?.metadata
+      }
+    });
+    if (this.config.sessionStore) {
+      await this.config.sessionStore.update(sessionId, {
+        status: "completed"
+      });
+    }
+    return {
+      text: result.text,
+      steps: result.steps,
+      toolCalls: result.toolCalls.map((tc) => ({
+        type: "tool-call",
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        args: "args" in tc ? tc.args : ("input" in tc) ? tc.input : undefined
+      })),
+      toolResults: result.toolResults.map((tr) => ({
+        type: "tool-result",
+        toolCallId: tr.toolCallId,
+        toolName: tr.toolName,
+        output: tr.output
+      })),
+      finishReason: result.finishReason,
+      usage: result.usage
+    };
+  }
+  async stream(params) {
+    const sessionId = params.options?.sessionId ?? generateSessionId();
+    const prompt = params.systemOverride ? `${this.instructions}
+
+${params.systemOverride}
+
+${params.prompt}` : params.prompt;
+    return this.inner.stream({
+      prompt,
+      abortSignal: params.signal,
+      options: {
+        tenantId: params.options?.tenantId,
+        actorId: params.options?.actorId,
+        sessionId,
+        metadata: params.options?.metadata
+      }
+    });
+  }
+  async handleStepFinish(step) {
+    const sessionId = step.options?.sessionId;
+    if (sessionId && this.config.sessionStore) {
+      await this.config.sessionStore.appendStep(sessionId, step);
+    }
+    if (this.config.telemetryCollector) {
+      await trackAgentStep(this.config.telemetryCollector, this.id, step);
+    }
+  }
+}
+var ContractSpecCallOptionsSchema;
+var init_contract_spec_agent = __esm(() => {
+  init_tool_adapter();
+  init_knowledge_tool();
+  init_adapter();
+  ContractSpecCallOptionsSchema = z3.object({
+    tenantId: z3.string().optional(),
+    actorId: z3.string().optional(),
+    sessionId: z3.string().optional(),
+    metadata: z3.record(z3.string(), z3.unknown()).optional()
+  });
+});
+
+// src/providers/types.ts
+var ExternalProviderError, ProviderNotAvailableError, ProviderExecutionError, ContextCreationError;
+var init_types = __esm(() => {
+  ExternalProviderError = class ExternalProviderError extends Error {
+    provider;
+    code;
+    cause;
+    constructor(message, provider, code, cause) {
+      super(message);
+      this.provider = provider;
+      this.code = code;
+      this.cause = cause;
+      this.name = "ExternalProviderError";
+    }
+  };
+  ProviderNotAvailableError = class ProviderNotAvailableError extends ExternalProviderError {
+    constructor(provider, reason) {
+      super(`Provider '${provider}' is not available${reason ? `: ${reason}` : ""}`, provider, "PROVIDER_NOT_AVAILABLE");
+      this.name = "ProviderNotAvailableError";
+    }
+  };
+  ProviderExecutionError = class ProviderExecutionError extends ExternalProviderError {
+    constructor(provider, message, cause) {
+      super(message, provider, "EXECUTION_FAILED", cause);
+      this.name = "ProviderExecutionError";
+    }
+  };
+  ContextCreationError = class ContextCreationError extends ExternalProviderError {
+    constructor(provider, message, cause) {
+      super(message, provider, "CONTEXT_CREATION_FAILED", cause);
+      this.name = "ContextCreationError";
+    }
+  };
+});
+
+// src/providers/claude-agent-sdk/tool-bridge.ts
+function specToolToClaudeAgentTool(tool3, handler, context) {
+  return {
+    name: tool3.name,
+    description: tool3.description ?? `Execute ${tool3.name}`,
+    input_schema: normalizeSchema(tool3.schema),
+    requires_confirmation: tool3.requiresApproval ?? !tool3.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((tool3) => handlers.has(tool3.name)).map((tool3) => {
+    const handler = handlers.get(tool3.name);
+    if (!handler) {
+      throw new Error(`Handler not found for tool ${tool3.name}`);
+    }
+    return specToolToClaudeAgentTool(tool3, 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(tool3, handler, context) {
+  return {
+    name: tool3.name,
+    description: tool3.description ?? `Execute ${tool3.name}`,
+    inputSchema: tool3.schema ?? { type: "object" },
+    requiresApproval: tool3.requiresApproval ?? !tool3.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/claude-agent-sdk/session-bridge.ts
+function toClaudeAgentSession(state) {
+  const messages = [];
+  for (const msg of state.messages) {
+    if (msg.role === "user" || msg.role === "assistant") {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      messages.push({
+        role: msg.role,
+        content
+      });
+    }
+  }
+  return {
+    sessionId: state.sessionId,
+    messages,
+    metadata: {
+      agentId: state.agentId,
+      tenantId: state.tenantId,
+      actorId: state.actorId
+    }
+  };
+}
+function createClaudeAgentSession(options) {
+  return {
+    sessionId: options?.sessionId,
+    messages: [],
+    metadata: {
+      tenantId: options?.tenantId,
+      actorId: options?.actorId,
+      ...options?.metadata
+    }
+  };
+}
+function createEmptyClaudeSession() {
+  return createClaudeAgentSession();
+}
+function buildClaudeAgentContext(options) {
+  return {
+    tenantId: options?.tenantId,
+    actorId: options?.actorId,
+    sessionId: options?.sessionId,
+    ...options?.metadata
+  };
+}
+function appendUserMessage(session, content) {
+  return {
+    ...session,
+    messages: [...session.messages, { role: "user", content }]
+  };
+}
+function appendAssistantMessage(session, content) {
+  return {
+    ...session,
+    messages: [...session.messages, { role: "assistant", content }]
+  };
+}
+function clearSession(session) {
+  return {
+    ...session,
+    messages: []
+  };
+}
+function getRecentMessages(session, count) {
+  return session.messages.slice(-count);
+}
+function extractToolUseBlocks(content) {
+  if (typeof content === "string") {
+    return [];
+  }
+  return content.filter((block) => block.type === "tool_use");
+}
+function createToolResultBlock(toolUseId, result, isError = false) {
+  return {
+    type: "tool_result",
+    tool_use_id: toolUseId,
+    content: typeof result === "string" ? result : JSON.stringify(result),
+    is_error: isError
+  };
+}
+function updateSessionMetadata(session, metadata) {
+  return {
+    ...session,
+    metadata: {
+      ...session.metadata,
+      ...metadata
+    }
+  };
+}
+function getMessageCount(session) {
+  return session.messages.length;
+}
+function estimateTokens(session) {
+  let chars = 0;
+  for (const msg of session.messages) {
+    if (typeof msg.content === "string") {
+      chars += msg.content.length;
+    } else {
+      chars += JSON.stringify(msg.content).length;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+function summarizeSession(session) {
+  let userMessages = 0;
+  let assistantMessages = 0;
+  for (const msg of session.messages) {
+    if (msg.role === "user") {
+      userMessages++;
+    } else {
+      assistantMessages++;
+    }
+  }
+  return {
+    messageCount: session.messages.length,
+    userMessages,
+    assistantMessages,
+    estimatedTokens: estimateTokens(session)
+  };
+}
+
+// src/providers/claude-agent-sdk/adapter.ts
+class ClaudeAgentSDKProvider {
+  name = "claude-agent-sdk";
+  version = "1.0.0";
+  config;
+  sdkAvailable = null;
+  constructor(config = {}) {
+    this.config = {
+      model: "claude-sonnet-4-20250514",
+      extendedThinking: false,
+      computerUse: false,
+      maxTokens: 4096,
+      temperature: 0.7,
+      ...config
+    };
+  }
+  isAvailable() {
+    if (this.sdkAvailable !== null) {
+      return this.sdkAvailable;
+    }
+    try {
+      __require.resolve("@anthropic-ai/claude-agent-sdk");
+      const apiKey = this.config.apiKey ?? process.env.ANTHROPIC_API_KEY;
+      this.sdkAvailable = Boolean(apiKey);
+    } catch {
+      this.sdkAvailable = false;
+    }
+    return this.sdkAvailable;
+  }
+  async createContext(spec) {
+    if (!this.isAvailable()) {
+      throw new ProviderNotAvailableError(this.name, "SDK not installed or API key not configured");
+    }
+    try {
+      const toolSet = {};
+      for (const tool3 of spec.tools) {
+        toolSet[tool3.name] = specToolToExternalTool(tool3);
+      }
+      const instructions = await injectStaticKnowledge(spec.instructions, spec.knowledge ?? [], undefined);
+      const contextId = `claude-${agentKey(spec.meta)}-${Date.now()}`;
+      const metadata = {
+        computerUseEnabled: this.config.computerUse ?? false,
+        extendedThinkingEnabled: this.config.extendedThinking ?? false,
+        mcpServerIds: this.config.mcpServers?.map((s) => s.name) ?? []
+      };
+      return {
+        id: contextId,
+        spec: {
+          ...spec,
+          instructions
+        },
+        tools: toolSet,
+        metadata,
+        cleanup: async () => {}
+      };
+    } catch (error) {
+      throw new ContextCreationError(this.name, `Failed to create context: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async execute(context, params) {
+    try {
+      const sdk = await this.loadSDK();
+      const systemPrompt = params.systemOverride ? `${context.spec.instructions}
+
+${params.systemOverride}` : context.spec.instructions;
+      const claudeContext = buildClaudeAgentContext(params.options);
+      let session = createEmptyClaudeSession();
+      session = appendUserMessage(session, params.prompt);
+      const claudeTools = this.prepareToolsForSDK(context, params);
+      const rawResponse = await sdk.execute({
+        model: this.config.model,
+        system: systemPrompt,
+        messages: session.messages,
+        tools: claudeTools,
+        max_tokens: this.config.maxTokens,
+        temperature: this.config.temperature,
+        metadata: claudeContext,
+        extended_thinking: this.config.extendedThinking,
+        computer_use: this.config.computerUse
+      });
+      const response = rawResponse;
+      const toolCalls = extractToolCalls(response);
+      const toolResults = await this.executeTools(toolCalls, context, params);
+      if (response.content) {
+        const content = response.content;
+        session = appendAssistantMessage(session, content);
+      }
+      return {
+        text: this.extractTextContent(response),
+        toolCalls: toolCalls.map((tc) => ({
+          type: "tool-call",
+          toolCallId: tc.toolCallId,
+          toolName: tc.toolName,
+          args: tc.args
+        })),
+        toolResults: toolResults.map((tr) => ({
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.output
+        })),
+        usage: {
+          inputTokens: response.usage?.input_tokens ?? 0,
+          outputTokens: response.usage?.output_tokens ?? 0
+        },
+        finishReason: this.mapStopReason(response.stop_reason),
+        metadata: {
+          sessionId: context.metadata?.sessionId,
+          model: response.model
+        }
+      };
+    } catch (error) {
+      throw new ProviderExecutionError(this.name, `Execution failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async* stream(context, params) {
+    try {
+      const sdk = await this.loadSDK();
+      const systemPrompt = params.systemOverride ? `${context.spec.instructions}
+
+${params.systemOverride}` : context.spec.instructions;
+      const claudeContext = buildClaudeAgentContext(params.options);
+      const claudeTools = this.prepareToolsForSDK(context, params);
+      const stream = await sdk.stream({
+        model: this.config.model,
+        system: systemPrompt,
+        messages: [{ role: "user", content: params.prompt }],
+        tools: claudeTools,
+        max_tokens: this.config.maxTokens,
+        temperature: this.config.temperature,
+        metadata: claudeContext,
+        extended_thinking: this.config.extendedThinking,
+        computer_use: this.config.computerUse
+      });
+      let fullText = "";
+      const allToolCalls = [];
+      const allToolResults = [];
+      let stepIndex = 0;
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+          const text = event.delta.text ?? "";
+          fullText += text;
+          yield { type: "text", text };
+        }
+        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+          const toolCall = {
+            toolCallId: event.content_block.id ?? "",
+            toolName: event.content_block.name ?? "",
+            args: event.content_block.input
+          };
+          allToolCalls.push(toolCall);
+          yield {
+            type: "tool-call",
+            toolCall: {
+              type: "tool-call",
+              ...toolCall
+            }
+          };
+        }
+        if (event.type === "message_stop") {
+          stepIndex++;
+          yield { type: "step-complete", stepIndex };
+        }
+      }
+      for (const toolCall of allToolCalls) {
+        const result = await this.executeTool(toolCall, context, params);
+        allToolResults.push(result);
+        yield {
+          type: "tool-result",
+          toolResult: {
+            type: "tool-result",
+            ...result
+          }
+        };
+      }
+      yield {
+        type: "done",
+        result: {
+          text: fullText,
+          toolCalls: allToolCalls.map((tc) => ({
+            type: "tool-call",
+            ...tc
+          })),
+          toolResults: allToolResults.map((tr) => ({
+            type: "tool-result",
+            ...tr
+          })),
+          usage: { inputTokens: 0, outputTokens: 0 },
+          finishReason: "stop"
+        }
+      };
+    } catch (error) {
+      throw new ProviderExecutionError(this.name, `Stream failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async loadSDK() {
+    try {
+      const module = __require("@anthropic-ai/claude-agent-sdk");
+      return module.default ?? module;
+    } catch {
+      throw new ProviderNotAvailableError(this.name, "@anthropic-ai/claude-agent-sdk is not installed");
+    }
+  }
+  prepareToolsForSDK(context, params) {
+    const handlers = new Map;
+    for (const tool3 of context.spec.tools) {
+      const externalTool = context.tools[tool3.name];
+      if (externalTool?.execute) {
+        handlers.set(tool3.name, async (input) => {
+          if (!externalTool.execute) {
+            throw new Error(`Tool ${tool3.name} has no execute handler`);
+          }
+          const result = await externalTool.execute(input);
+          return typeof result === "string" ? result : JSON.stringify(result);
+        });
+      }
+    }
+    return specToolsToClaudeAgentTools(context.spec.tools, handlers, {
+      agentId: context.id,
+      sessionId: params.options?.sessionId,
+      tenantId: params.options?.tenantId,
+      actorId: params.options?.actorId,
+      metadata: params.options?.metadata,
+      signal: params.signal
+    });
+  }
+  async executeTool(toolCall, context, _params) {
+    const tool3 = context.tools[toolCall.toolName];
+    if (!tool3?.execute) {
+      return {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: `Error: Tool '${toolCall.toolName}' not found or has no handler`
+      };
+    }
+    try {
+      const output = await tool3.execute(toolCall.args);
+      return {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output
+      };
+    } catch (error) {
+      return {
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: `Error: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  async executeTools(toolCalls, context, params) {
+    return Promise.all(toolCalls.map((tc) => this.executeTool(tc, context, params)));
+  }
+  extractTextContent(response) {
+    if (!response.content) {
+      return "";
+    }
+    return response.content.filter((block) => typeof block === "object" && block !== null && block.type === "text").map((block) => block.text).join("");
+  }
+  mapStopReason(stopReason) {
+    switch (stopReason) {
+      case "end_turn":
+      case "stop_sequence":
+        return "stop";
+      case "tool_use":
+        return "tool-calls";
+      case "max_tokens":
+        return "length";
+      default:
+        return "stop";
+    }
+  }
+}
+var init_adapter2 = __esm(() => {
+  init_types();
+});
+
+// src/providers/claude-agent-sdk/index.ts
+var exports_claude_agent_sdk = {};
+__export(exports_claude_agent_sdk, {
+  updateSessionMetadata: () => updateSessionMetadata,
+  toClaudeAgentSession: () => toClaudeAgentSession,
+  summarizeSession: () => summarizeSession,
+  specToolsToClaudeAgentTools: () => specToolsToClaudeAgentTools,
+  specToolToExternalTool: () => specToolToExternalTool,
+  specToolToClaudeAgentTool: () => specToolToClaudeAgentTool,
+  getRecentMessages: () => getRecentMessages,
+  getMessageCount: () => getMessageCount,
+  extractToolUseBlocks: () => extractToolUseBlocks,
+  extractToolCalls: () => extractToolCalls,
+  estimateTokens: () => estimateTokens,
+  createToolResultBlock: () => createToolResultBlock,
+  createEmptyClaudeSession: () => createEmptyClaudeSession,
+  createClaudeAgentSession: () => createClaudeAgentSession,
+  clearSession: () => clearSession,
+  claudeAgentToolsToSpecTools: () => claudeAgentToolsToSpecTools,
+  claudeAgentToolToSpecTool: () => claudeAgentToolToSpecTool,
+  buildClaudeAgentContext: () => buildClaudeAgentContext,
+  appendUserMessage: () => appendUserMessage,
+  appendAssistantMessage: () => appendAssistantMessage,
+  ClaudeAgentSDKProvider: () => ClaudeAgentSDKProvider
+});
+var init_claude_agent_sdk = __esm(() => {
+  init_adapter2();
+});
+
+// src/providers/opencode-sdk/tool-bridge.ts
+function specToolToOpenCodeTool(tool3) {
+  return {
+    name: tool3.name,
+    description: tool3.description ?? `Execute ${tool3.name}`,
+    parameters: normalizeToOpenCodeParameters(tool3.schema),
+    permission: getPermissionLevel(tool3)
+  };
+}
+function specToolsToOpenCodeTools(tools) {
+  return tools.map(specToolToOpenCodeTool);
+}
+function getPermissionLevel(tool3) {
+  if (tool3.requiresApproval) {
+    return "ask";
+  }
+  if (tool3.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(tool3, handler, context) {
+  return {
+    name: tool3.name,
+    description: tool3.description ?? `Execute ${tool3.name}`,
+    inputSchema: tool3.schema ?? { type: "object" },
+    requiresApproval: tool3.requiresApproval ?? !tool3.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, tool3] of Object.entries(tools)) {
+    if (tool3.execute) {
+      handlers.set(name, tool3.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/providers/opencode-sdk/agent-bridge.ts
+function inferAgentType(spec) {
+  const hasCodeTools = spec.tools.some((tool3) => [
+    "write_file",
+    "edit_file",
+    "create_file",
+    "delete_file",
+    "bash",
+    "execute",
+    "run_command",
+    "terminal"
+  ].includes(tool3.name.toLowerCase()));
+  const instructionsLower = spec.instructions.toLowerCase();
+  const hasPlanningKeywords = /\b(plan|design|architect|strategy|analyze|review|assess|evaluate)\b/.test(instructionsLower);
+  const hasExplorationKeywords = /\b(search|find|explore|discover|locate|grep|pattern)\b/.test(instructionsLower);
+  const hasResearchKeywords = /\b(research|investigate|understand|learn|gather|collect)\b/.test(instructionsLower);
+  if (hasCodeTools) {
+    return "build";
+  }
+  if (hasPlanningKeywords && !hasCodeTools) {
+    return "plan";
+  }
+  if (hasExplorationKeywords && !hasResearchKeywords) {
+    return "explore";
+  }
+  return "general";
+}
+function specToOpenCodeConfig(spec, options) {
+  const agentType = options?.agentType ?? inferAgentType(spec);
+  return {
+    name: spec.meta.key,
+    version: spec.meta.version,
+    description: spec.description ?? spec.meta.description,
+    instructions: spec.instructions,
+    agent_type: agentType,
+    tools: specToolsToOpenCodeTools(spec.tools),
+    config: {
+      max_steps: options?.maxSteps ?? spec.maxSteps ?? 10,
+      temperature: options?.temperature ?? 0.7,
+      model: options?.model,
+      permissions: buildPermissions(spec)
+    }
+  };
+}
+function buildPermissions(spec) {
+  const permissions = {};
+  for (const tool3 of spec.tools) {
+    if (tool3.requiresApproval) {
+      permissions[tool3.name] = "ask";
+    } else if (tool3.automationSafe === false) {
+      permissions[tool3.name] = "ask";
+    } else {
+      permissions[tool3.name] = "allow";
+    }
+  }
+  return permissions;
+}
+function specToOpenCodeMarkdown(spec, options) {
+  const agentType = options?.agentType ?? inferAgentType(spec);
+  return {
+    frontmatter: {
+      name: spec.meta.key,
+      type: agentType,
+      version: spec.meta.version,
+      model: options?.model,
+      temperature: options?.temperature ?? 0.7,
+      max_steps: options?.maxSteps ?? spec.maxSteps ?? 10,
+      tools: spec.tools.map((t) => t.name)
+    },
+    body: buildMarkdownBody(spec)
+  };
+}
+function buildMarkdownBody(spec) {
+  const lines = [];
+  lines.push(`# ${spec.meta.key}`);
+  lines.push("");
+  if (spec.description ?? spec.meta.description) {
+    lines.push(spec.description ?? spec.meta.description ?? "");
+    lines.push("");
+  }
+  lines.push("## Instructions");
+  lines.push("");
+  lines.push(spec.instructions);
+  lines.push("");
+  if (spec.tools.length > 0) {
+    lines.push("## Tools");
+    lines.push("");
+    for (const tool3 of spec.tools) {
+      const permission = tool3.requiresApproval ? "(requires approval)" : tool3.automationSafe === false ? "(ask mode)" : "";
+      lines.push(`- **${tool3.name}**: ${tool3.description ?? "No description"} ${permission}`.trim());
+    }
+    lines.push("");
+  }
+  if (spec.knowledge && spec.knowledge.length > 0) {
+    lines.push("## Knowledge Sources");
+    lines.push("");
+    for (const k of spec.knowledge) {
+      const required = k.required ? "(required)" : "(optional)";
+      lines.push(`- ${k.key} ${required}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function serializeOpenCodeMarkdown(markdown) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${markdown.frontmatter.name}`);
+  lines.push(`type: ${markdown.frontmatter.type}`);
+  if (markdown.frontmatter.version) {
+    lines.push(`version: ${markdown.frontmatter.version}`);
+  }
+  if (markdown.frontmatter.model) {
+    lines.push(`model: ${markdown.frontmatter.model}`);
+  }
+  if (markdown.frontmatter.temperature !== undefined) {
+    lines.push(`temperature: ${markdown.frontmatter.temperature}`);
+  }
+  if (markdown.frontmatter.max_steps !== undefined) {
+    lines.push(`max_steps: ${markdown.frontmatter.max_steps}`);
+  }
+  if (markdown.frontmatter.tools && markdown.frontmatter.tools.length > 0) {
+    lines.push(`tools:`);
+    for (const tool3 of markdown.frontmatter.tools) {
+      lines.push(`  - ${tool3}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(markdown.body);
+  return lines.join(`
+`);
+}
+function openCodeConfigToSpec(config) {
+  return {
+    meta: {
+      key: config.name,
+      version: config.version ?? "1.0.0",
+      description: config.description ?? "",
+      stability: "experimental",
+      owners: [],
+      tags: []
+    },
+    description: config.description,
+    instructions: config.instructions ?? "",
+    tools: config.tools?.map((tool3) => ({
+      name: tool3.name,
+      description: tool3.description,
+      schema: tool3.parameters,
+      requiresApproval: tool3.permission === "ask",
+      automationSafe: tool3.permission === "allow"
+    })) ?? [],
+    maxSteps: config.config?.max_steps ?? 10
+  };
+}
+var init_agent_bridge = () => {};
+
+// src/providers/opencode-sdk/adapter.ts
+class OpenCodeSDKProvider {
+  name = "opencode-sdk";
+  version = "1.0.0";
+  config;
+  sdkAvailable = null;
+  constructor(config = {}) {
+    this.config = {
+      serverUrl: "http://127.0.0.1:4096",
+      port: 4096,
+      agentType: "general",
+      temperature: 0.7,
+      timeout: 30000,
+      ...config
+    };
+    if (!config.serverUrl && config.port) {
+      this.config.serverUrl = `http://127.0.0.1:${config.port}`;
+    }
+  }
+  isAvailable() {
+    if (this.sdkAvailable !== null) {
+      return this.sdkAvailable;
+    }
+    try {
+      __require.resolve("@opencode-ai/sdk");
+      this.sdkAvailable = true;
+    } catch {
+      this.sdkAvailable = false;
+    }
+    return this.sdkAvailable;
+  }
+  async createContext(spec) {
+    if (!this.isAvailable()) {
+      throw new ProviderNotAvailableError(this.name, "SDK not installed");
+    }
+    try {
+      const sdk = await this.loadSDK();
+      const { client } = await sdk.createOpencode({
+        hostname: this.getHostname(),
+        port: this.config.port ?? 4096,
+        timeout: this.config.timeout
+      });
+      const session = await client.session.create({
+        agent: this.config.agentType ?? inferAgentType(spec),
+        model: this.config.model
+      });
+      const toolSet = {};
+      for (const tool3 of spec.tools) {
+        toolSet[tool3.name] = specToolToExternalToolForOpenCode(tool3);
+      }
+      const instructions = await injectStaticKnowledge(spec.instructions, spec.knowledge ?? [], undefined);
+      const contextId = `opencode-${agentKey(spec.meta)}-${Date.now()}`;
+      const metadata = {
+        sessionId: session.id,
+        agentType: this.config.agentType ?? inferAgentType(spec),
+        serverUrl: this.config.serverUrl ?? `http://127.0.0.1:${this.config.port ?? 4096}`
+      };
+      return {
+        id: contextId,
+        spec: {
+          ...spec,
+          instructions
+        },
+        tools: toolSet,
+        metadata,
+        cleanup: async () => {
+          try {
+            await client.session.delete({ id: session.id });
+          } catch {}
+        }
+      };
+    } catch (error) {
+      throw new ContextCreationError(this.name, `Failed to create context: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async execute(context, params) {
+    try {
+      const sdk = await this.loadSDK();
+      const metadata = context.metadata;
+      const { client } = await sdk.createOpencodeClient({
+        baseUrl: metadata.serverUrl
+      });
+      const systemPrompt = params.systemOverride ? `${context.spec.instructions}
+
+${params.systemOverride}` : context.spec.instructions;
+      const response = await client.session.prompt({
+        id: metadata.sessionId,
+        body: {
+          content: params.prompt,
+          system: systemPrompt
+        }
+      });
+      const toolCalls = this.extractToolCalls(response);
+      const toolHandlers = createToolHandlerMap(context.tools);
+      const toolResults = await Promise.all(toolCalls.map((tc) => executeToolCall(tc, toolHandlers)));
+      return {
+        text: this.extractTextContent(response),
+        toolCalls: toolCalls.map((tc) => ({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          args: tc.arguments
+        })),
+        toolResults: toolResults.map((tr) => ({
+          type: "tool-result",
+          toolCallId: tr.tool_call_id,
+          toolName: toolCalls.find((tc) => tc.id === tr.tool_call_id)?.name ?? "",
+          output: tr.output
+        })),
+        usage: {
+          inputTokens: response.usage?.input_tokens ?? 0,
+          outputTokens: response.usage?.output_tokens ?? 0
+        },
+        finishReason: this.mapFinishReason(response.finish_reason),
+        metadata: {
+          sessionId: metadata.sessionId,
+          agentType: metadata.agentType
+        }
+      };
+    } catch (error) {
+      throw new ProviderExecutionError(this.name, `Execution failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async* stream(context, params) {
+    try {
+      const sdk = await this.loadSDK();
+      const metadata = context.metadata;
+      const { client } = await sdk.createOpencodeClient({
+        baseUrl: metadata.serverUrl
+      });
+      const systemPrompt = params.systemOverride ? `${context.spec.instructions}
+
+${params.systemOverride}` : context.spec.instructions;
+      const events = client.session.subscribe({
+        id: metadata.sessionId
+      });
+      await client.session.prompt({
+        id: metadata.sessionId,
+        body: {
+          content: params.prompt,
+          system: systemPrompt
+        }
+      });
+      let fullText = "";
+      const allToolCalls = [];
+      const toolHandlers = createToolHandlerMap(context.tools);
+      let stepIndex = 0;
+      for await (const event of events) {
+        if (event.type === "message.delta") {
+          const text = event.delta?.content ?? "";
+          fullText += text;
+          yield { type: "text", text };
+        }
+        if (event.type === "tool.call") {
+          const toolCall = {
+            id: event.tool_call_id ?? `tc-${Date.now()}`,
+            name: event.tool_name ?? "",
+            arguments: event.arguments ?? {}
+          };
+          allToolCalls.push(toolCall);
+          yield {
+            type: "tool-call",
+            toolCall: {
+              type: "tool-call",
+              toolCallId: toolCall.id,
+              toolName: toolCall.name,
+              args: toolCall.arguments
+            }
+          };
+        }
+        if (event.type === "step.complete") {
+          stepIndex++;
+          yield { type: "step-complete", stepIndex };
+        }
+        if (event.type === "message.complete") {
+          break;
+        }
+      }
+      for (const toolCall of allToolCalls) {
+        const result = await executeToolCall(toolCall, toolHandlers);
+        yield {
+          type: "tool-result",
+          toolResult: {
+            type: "tool-result",
+            toolCallId: result.tool_call_id,
+            toolName: toolCall.name,
+            output: result.output
+          }
+        };
+      }
+      yield {
+        type: "done",
+        result: {
+          text: fullText,
+          toolCalls: allToolCalls.map((tc) => ({
+            type: "tool-call",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            args: tc.arguments
+          })),
+          toolResults: [],
+          usage: { inputTokens: 0, outputTokens: 0 },
+          finishReason: "stop"
+        }
+      };
+    } catch (error) {
+      throw new ProviderExecutionError(this.name, `Stream failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+    }
+  }
+  async loadSDK() {
+    try {
+      const module = __require("@opencode-ai/sdk");
+      return module;
+    } catch {
+      throw new ProviderNotAvailableError(this.name, "@opencode-ai/sdk is not installed");
+    }
+  }
+  getHostname() {
+    if (!this.config.serverUrl) {
+      return "127.0.0.1";
+    }
+    try {
+      const url = new URL(this.config.serverUrl);
+      return url.hostname;
+    } catch {
+      return "127.0.0.1";
+    }
+  }
+  extractToolCalls(response) {
+    if (!response.tool_calls) {
+      return [];
+    }
+    return response.tool_calls.map((tc) => ({
+      id: tc.id,
+      name: tc.name,
+      arguments: tc.arguments ?? {}
+    }));
+  }
+  extractTextContent(response) {
+    return response.content ?? response.message?.content ?? "";
+  }
+  mapFinishReason(finishReason) {
+    switch (finishReason) {
+      case "stop":
+      case "end":
+        return "stop";
+      case "tool_use":
+      case "tool_calls":
+        return "tool-calls";
+      case "length":
+      case "max_tokens":
+        return "length";
+      default:
+        return "stop";
+    }
+  }
+}
+var init_adapter3 = __esm(() => {
+  init_types();
+  init_agent_bridge();
+});
+
+// src/providers/opencode-sdk/index.ts
+var exports_opencode_sdk = {};
+__export(exports_opencode_sdk, {
+  specToolsToOpenCodeTools: () => specToolsToOpenCodeTools,
+  specToolToOpenCodeTool: () => specToolToOpenCodeTool,
+  specToolToExternalToolForOpenCode: () => specToolToExternalToolForOpenCode,
+  specToOpenCodeMarkdown: () => specToOpenCodeMarkdown,
+  specToOpenCodeConfig: () => specToOpenCodeConfig,
+  serializeOpenCodeMarkdown: () => serializeOpenCodeMarkdown,
+  openCodeToolsToSpecTools: () => openCodeToolsToSpecTools,
+  openCodeToolToSpecTool: () => openCodeToolToSpecTool,
+  openCodeConfigToSpec: () => openCodeConfigToSpec,
+  inferAgentType: () => inferAgentType,
+  executeToolCall: () => executeToolCall,
+  createToolHandlerMap: () => createToolHandlerMap,
+  OpenCodeSDKProvider: () => OpenCodeSDKProvider
+});
+var init_opencode_sdk = __esm(() => {
+  init_adapter3();
+  init_agent_bridge();
+});
+
+// src/agent/json-runner.ts
+init_contract_spec_agent();
+import { createProvider } from "@contractspec/lib.ai-providers/factory";
+import { StabilityEnum } from "@contractspec/lib.contracts/ownership";
+var JSON_ONLY_RULES = [
+  "You MUST output valid JSON ONLY.",
+  "Do not wrap the output in markdown fences.",
+  "Do not include commentary or explanation.",
+  "Use double quotes for all keys and string values.",
+  "Do not include trailing commas."
+].join(`
+`);
+var DEFAULT_SPEC = {
+  meta: {
+    key: "agent.json-runner",
+    version: "1.0.0",
+    description: "JSON-only agent runner for deterministic pipelines.",
+    stability: StabilityEnum.Experimental,
+    owners: ["platform.core"],
+    tags: ["json", "agent"]
+  },
+  instructions: "You are a precise JSON generator.",
+  tools: []
+};
+function resolveModel(options) {
+  if (options.model)
+    return options.model;
+  if (options.provider) {
+    return createProvider(options.provider).getModel();
+  }
+  throw new Error("createAgentJsonRunner requires a model or provider config");
+}
+function applyModelSettings(model, settings) {
+  const { temperature } = settings;
+  if (temperature === undefined)
+    return model;
+  const withSettings = model;
+  if (typeof withSettings.withSettings === "function") {
+    return withSettings.withSettings({ temperature });
+  }
+  return model;
+}
+function buildInstructions(base, system) {
+  return [base, JSON_ONLY_RULES, system].filter(Boolean).join(`
+
+`);
+}
+function ensureToolHandlers(spec, handlers) {
+  for (const tool3 of spec.tools) {
+    if (!handlers.has(tool3.name)) {
+      throw new Error(`Missing handler for tool: ${tool3.name}`);
+    }
+  }
+}
+async function createAgentJsonRunner(options) {
+  const model = applyModelSettings(resolveModel(options), {
+    temperature: options.temperature ?? 0
+  });
+  const baseSpec = options.spec ?? DEFAULT_SPEC;
+  const spec = {
+    ...baseSpec,
+    instructions: buildInstructions(baseSpec.instructions, options.system),
+    maxSteps: options.maxSteps ?? baseSpec.maxSteps
+  };
+  const toolHandlers = options.toolHandlers ?? new Map;
+  ensureToolHandlers(spec, toolHandlers);
+  const agent = await ContractSpecAgent.create({
+    spec,
+    model,
+    toolHandlers
+  });
+  return {
+    async generateJson(prompt) {
+      const result = await agent.generate({ prompt });
+      return result.text;
+    }
+  };
+}
+
+// src/agent/unified-agent.ts
+import { createProvider as createProvider2 } from "@contractspec/lib.ai-providers/factory";
+
+class UnifiedAgent {
+  spec;
+  config;
+  tools;
+  provider;
+  context;
+  state;
+  constructor(spec, config) {
+    this.spec = spec;
+    this.config = config;
+    this.tools = config.tools ?? new Map;
+    this.state = {
+      backend: config.backend,
+      isReady: false,
+      messageCount: 0
+    };
+  }
+  async initialize() {
+    const backend = this.config.backend;
+    try {
+      switch (backend) {
+        case "ai-sdk":
+          this.state.isReady = true;
+          break;
+        case "claude-agent-sdk":
+          await this.initializeClaudeAgentSDK();
+          break;
+        case "opencode-sdk":
+          await this.initializeOpenCodeSDK();
+          break;
+        default:
+          throw new Error(`Unknown backend: ${backend}`);
+      }
+    } catch (error) {
+      this.state.lastError = error instanceof Error ? error : new Error(String(error));
+      if (this.config.fallbackBackend && this.config.fallbackBackend !== backend) {
+        console.warn(`[UnifiedAgent] ${backend} failed, falling back to ${this.config.fallbackBackend}`);
+        this.state.backend = this.config.fallbackBackend;
+        await this.initialize();
+      } else {
+        throw error;
+      }
+    }
+  }
+  async initializeClaudeAgentSDK() {
+    try {
+      const { ClaudeAgentSDKProvider: ClaudeAgentSDKProvider2 } = await Promise.resolve().then(() => (init_claude_agent_sdk(), exports_claude_agent_sdk));
+      const config = this.config.config;
+      this.provider = new ClaudeAgentSDKProvider2(config ?? {});
+      if (!this.provider.isAvailable()) {
+        throw new Error("Claude Agent SDK not available. Install @anthropic-ai/claude-agent-sdk");
+      }
+      this.context = await this.provider.createContext(this.spec);
+      this.state.isReady = true;
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("Claude Agent SDK not installed. Run: npm install @anthropic-ai/claude-agent-sdk");
+      }
+      throw error;
+    }
+  }
+  async initializeOpenCodeSDK() {
+    try {
+      const { OpenCodeSDKProvider: OpenCodeSDKProvider2 } = await Promise.resolve().then(() => (init_opencode_sdk(), exports_opencode_sdk));
+      const config = this.config.config;
+      this.provider = new OpenCodeSDKProvider2(config ?? {});
+      if (!this.provider.isAvailable()) {
+        throw new Error("OpenCode SDK not available. Install @opencode-ai/sdk");
+      }
+      this.context = await this.provider.createContext(this.spec);
+      this.state.isReady = true;
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("OpenCode SDK not installed. Run: npm install @opencode-ai/sdk");
+      }
+      throw error;
+    }
+  }
+  async run(message, options) {
+    if (!this.state.isReady) {
+      await this.initialize();
+    }
+    const backend = options?.backend ?? this.state.backend;
+    this.state.messageCount++;
+    try {
+      switch (backend) {
+        case "ai-sdk":
+          return await this.runWithAISDK(message, options);
+        case "claude-agent-sdk":
+        case "opencode-sdk":
+          return await this.runWithExternalProvider(message, options);
+        default:
+          throw new Error(`Unknown backend: ${backend}`);
+      }
+    } catch (error) {
+      this.state.lastError = error instanceof Error ? error : new Error(String(error));
+      throw error;
+    }
+  }
+  async runWithAISDK(message, options) {
+    const { ContractSpecAgent: ContractSpecAgent2 } = await Promise.resolve().then(() => (init_contract_spec_agent(), exports_contract_spec_agent));
+    const model = await this.resolveAISDKModel();
+    const agent = await ContractSpecAgent2.create({
+      spec: this.spec,
+      model,
+      toolHandlers: this.tools
+    });
+    return await agent.generate({
+      prompt: message,
+      options
+    });
+  }
+  async runWithExternalProvider(message, options) {
+    if (!this.provider || !this.context) {
+      throw new Error("Provider not initialized");
+    }
+    const result = await this.provider.execute(this.context, {
+      prompt: message,
+      options
+    });
+    return this.convertExternalResult(result);
+  }
+  convertExternalResult(result) {
+    return {
+      text: result.text,
+      steps: [],
+      toolCalls: result.toolCalls.map((tc) => ({
+        type: "tool-call",
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        args: tc.args
+      })),
+      toolResults: result.toolResults.map((tr) => ({
+        type: "tool-result",
+        toolCallId: tr.toolCallId,
+        toolName: tr.toolName,
+        output: tr.output
+      })),
+      finishReason: result.finishReason,
+      usage: result.usage ? {
+        promptTokens: result.usage.inputTokens,
+        completionTokens: result.usage.outputTokens,
+        totalTokens: result.usage.totalTokens ?? result.usage.inputTokens + result.usage.outputTokens
+      } : undefined
+    };
+  }
+  getAISDKConfig() {
+    if (this.config.backend !== "ai-sdk")
+      return;
+    return this.config.config;
+  }
+  async resolveAISDKModel() {
+    const backendConfig = this.getAISDKConfig();
+    let model;
+    if (backendConfig?.modelInstance) {
+      model = backendConfig.modelInstance;
+    } else if (backendConfig?.provider) {
+      model = createProvider2(backendConfig.provider).getModel();
+    } else {
+      const { anthropic } = await import("@ai-sdk/anthropic");
+      model = anthropic(backendConfig?.model ?? "claude-3-5-sonnet-20240620");
+    }
+    return this.applyModelSettings(model, {
+      temperature: backendConfig?.temperature,
+      maxTokens: backendConfig?.maxTokens
+    });
+  }
+  applyModelSettings(model, settings) {
+    if (settings.temperature === undefined && settings.maxTokens === undefined) {
+      return model;
+    }
+    const withSettings = model;
+    if (typeof withSettings.withSettings === "function") {
+      return withSettings.withSettings({
+        temperature: settings.temperature,
+        maxTokens: settings.maxTokens
+      });
+    }
+    return model;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getSpec() {
+    return this.spec;
+  }
+  getBackend() {
+    return this.state.backend;
+  }
+  async isBackendAvailable(backend) {
+    switch (backend) {
+      case "ai-sdk":
+        return true;
+      case "claude-agent-sdk":
+        try {
+          const { ClaudeAgentSDKProvider: ClaudeAgentSDKProvider2 } = await Promise.resolve().then(() => (init_claude_agent_sdk(), exports_claude_agent_sdk));
+          const provider = new ClaudeAgentSDKProvider2({});
+          return provider.isAvailable();
+        } catch {
+          return false;
+        }
+      case "opencode-sdk":
+        try {
+          const { OpenCodeSDKProvider: OpenCodeSDKProvider2 } = await Promise.resolve().then(() => (init_opencode_sdk(), exports_opencode_sdk));
+          const provider = new OpenCodeSDKProvider2({});
+          return provider.isAvailable();
+        } catch {
+          return false;
+        }
+      default:
+        return false;
+    }
+  }
+  async switchBackend(backend) {
+    if (backend === this.state.backend) {
+      return;
+    }
+    this.state.backend = backend;
+    this.state.isReady = false;
+    this.provider = undefined;
+    this.context = undefined;
+    await this.initialize();
+  }
+  reset() {
+    this.state.messageCount = 0;
+    this.state.sessionId = undefined;
+    this.state.lastError = undefined;
+    this.context = undefined;
+  }
+  addTool(name, handler) {
+    this.tools.set(name, handler);
+  }
+  removeTool(name) {
+    return this.tools.delete(name);
+  }
+}
+function createUnifiedAgent(spec, config) {
+  return new UnifiedAgent(spec, config);
+}
+function createAISDKAgent(spec, options) {
+  return new UnifiedAgent(spec, {
+    backend: "ai-sdk",
+    tools: options?.tools,
+    config: {
+      model: options?.model,
+      modelInstance: options?.modelInstance,
+      provider: options?.provider,
+      temperature: options?.temperature,
+      maxTokens: options?.maxTokens
+    }
+  });
+}
+function createClaudeAgentSDKAgent(spec, config) {
+  const { tools, ...sdkConfig } = config ?? {};
+  return new UnifiedAgent(spec, {
+    backend: "claude-agent-sdk",
+    tools,
+    config: sdkConfig
+  });
+}
+function createOpenCodeSDKAgent(spec, config) {
+  const { tools, ...sdkConfig } = config ?? {};
+  return new UnifiedAgent(spec, {
+    backend: "opencode-sdk",
+    tools,
+    config: sdkConfig
+  });
+}
+async function getAvailableBackends() {
+  const backends = ["ai-sdk"];
+  try {
+    const { ClaudeAgentSDKProvider: ClaudeAgentSDKProvider2 } = await Promise.resolve().then(() => (init_claude_agent_sdk(), exports_claude_agent_sdk));
+    const provider = new ClaudeAgentSDKProvider2({});
+    if (provider.isAvailable()) {
+      backends.push("claude-agent-sdk");
+    }
+  } catch {}
+  try {
+    const { OpenCodeSDKProvider: OpenCodeSDKProvider2 } = await Promise.resolve().then(() => (init_opencode_sdk(), exports_opencode_sdk));
+    const provider = new OpenCodeSDKProvider2({});
+    if (provider.isAvailable()) {
+      backends.push("opencode-sdk");
+    }
+  } catch {}
+  return backends;
+}
+
+// src/agent/index.ts
+init_contract_spec_agent();
+
+// src/approval/workflow.ts
+import { randomUUID } from "node:crypto";
+
+class InMemoryApprovalStore {
+  items = new Map;
+  async create(request) {
+    this.items.set(request.id, request);
+  }
+  async get(id) {
+    return this.items.get(id) ?? null;
+  }
+  async getByToolCallId(toolCallId) {
+    for (const request of this.items.values()) {
+      if (request.toolCallId === toolCallId) {
+        return request;
+      }
+    }
+    return null;
+  }
+  async update(id, updates) {
+    const existing = this.items.get(id);
+    if (existing) {
+      this.items.set(id, { ...existing, ...updates });
+    }
+  }
+  async list(options) {
+    let results = [...this.items.values()];
+    if (options?.status) {
+      results = results.filter((r) => r.status === options.status);
+    }
+    if (options?.agentId) {
+      results = results.filter((r) => r.agentId === options.agentId);
+    }
+    if (options?.tenantId) {
+      results = results.filter((r) => r.tenantId === options.tenantId);
+    }
+    return results.sort((a, b) => b.requestedAt.getTime() - a.requestedAt.getTime());
+  }
+  clear() {
+    this.items.clear();
+  }
+}
+
+class ApprovalWorkflow {
+  store;
+  constructor(store = new InMemoryApprovalStore) {
+    this.store = store;
+  }
+  async requestApproval(params) {
+    const request = {
+      id: randomUUID(),
+      sessionId: params.sessionId,
+      agentId: params.agentId,
+      tenantId: params.tenantId,
+      toolName: params.toolName,
+      toolCallId: params.toolCallId,
+      toolArgs: params.toolArgs,
+      reason: params.reason,
+      requestedAt: new Date,
+      status: "pending",
+      payload: params.payload
+    };
+    await this.store.create(request);
+    return request;
+  }
+  async requestApprovalFromToolCall(toolCall, context) {
+    return this.requestApproval({
+      sessionId: context.sessionId,
+      agentId: context.agentId,
+      tenantId: context.tenantId,
+      toolName: toolCall.toolName,
+      toolCallId: toolCall.toolCallId,
+      toolArgs: toolCall.args,
+      reason: context.reason ?? `Tool "${toolCall.toolName}" requires approval`
+    });
+  }
+  async approve(id, reviewer, notes) {
+    await this.store.update(id, {
+      status: "approved",
+      reviewer,
+      resolvedAt: new Date,
+      notes
+    });
+  }
+  async reject(id, reviewer, notes) {
+    await this.store.update(id, {
+      status: "rejected",
+      reviewer,
+      resolvedAt: new Date,
+      notes
+    });
+  }
+  async getStatus(toolCallId) {
+    const request = await this.store.getByToolCallId(toolCallId);
+    return request?.status ?? null;
+  }
+  async isApproved(toolCallId) {
+    const status = await this.getStatus(toolCallId);
+    return status === "approved";
+  }
+  async listPending(options) {
+    return this.store.list({ ...options, status: "pending" });
+  }
+  async get(id) {
+    return this.store.get(id);
+  }
+}
+function createApprovalWorkflow(store) {
+  return new ApprovalWorkflow(store);
+}
+// src/exporters/claude-agent-exporter.ts
+class ClaudeAgentExporter {
+  format = "claude-agent";
+  export(spec, options = {}) {
+    const tools = this.exportTools(spec);
+    const config = this.buildConfig(spec, tools, options);
+    const claudeMd = options.generateClaudeMd ? this.generateClaudeMd(spec, options) : undefined;
+    return {
+      config,
+      claudeMd,
+      tools,
+      exportedAt: new Date,
+      sourceSpec: agentKey(spec.meta)
+    };
+  }
+  exportMany(specs, options = {}) {
+    return specs.map((spec) => this.export(spec, options));
+  }
+  validate(spec) {
+    const errors = [];
+    if (!spec.meta?.key) {
+      errors.push("Spec must have a meta.key");
+    }
+    if (!spec.instructions) {
+      errors.push("Spec must have instructions");
+    }
+    if (!spec.tools || spec.tools.length === 0) {
+      errors.push("Spec must have at least one tool");
+    }
+    for (const tool3 of spec.tools ?? []) {
+      if (!tool3.name) {
+        errors.push("All tools must have a name");
+      }
+      if (!tool3.description && !tool3.name) {
+        errors.push(`Tool must have a description or name`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  buildConfig(spec, tools, options) {
+    const config = {
+      model: options.model ?? "claude-sonnet-4-20250514",
+      system: this.buildSystemPrompt(spec, options),
+      tools,
+      max_turns: spec.maxSteps ?? 10
+    };
+    if (options.computerUse) {
+      config.computer_use = true;
+    }
+    if (options.extendedThinking) {
+      config.extended_thinking = true;
+    }
+    if (options.mcpServers && options.mcpServers.length > 0) {
+      config.mcp_servers = options.mcpServers;
+    }
+    return config;
+  }
+  buildSystemPrompt(spec, options) {
+    const parts = [];
+    parts.push(spec.instructions);
+    if (spec.knowledge && spec.knowledge.length > 0) {
+      parts.push("");
+      parts.push("## Knowledge Sources");
+      for (const k of spec.knowledge) {
+        if (k.instructions) {
+          parts.push(`- ${k.key}: ${k.instructions}`);
+        }
+      }
+    }
+    if (spec.policy) {
+      parts.push("");
+      parts.push("## Policy");
+      if (spec.policy.confidence?.min) {
+        parts.push(`- Minimum confidence: ${spec.policy.confidence.min}`);
+      }
+      if (spec.policy.escalation) {
+        parts.push("- Escalation policy is configured");
+      }
+    }
+    if (options.metadata) {
+      parts.push("");
+      parts.push("## Additional Context");
+      for (const [key, value] of Object.entries(options.metadata)) {
+        parts.push(`- ${key}: ${String(value)}`);
+      }
+    }
+    return parts.join(`
+`);
+  }
+  exportTools(spec) {
+    return spec.tools.map((tool3) => ({
+      name: tool3.name,
+      description: tool3.description ?? `Execute ${tool3.name}`,
+      input_schema: this.normalizeSchema(tool3.schema),
+      requires_confirmation: tool3.requiresApproval ?? !tool3.automationSafe
+    }));
+  }
+  normalizeSchema(schema) {
+    if (!schema) {
+      return { type: "object" };
+    }
+    if (schema.type === "object") {
+      return {
+        type: "object",
+        properties: schema.properties,
+        required: schema.required
+      };
+    }
+    return {
+      type: "object",
+      properties: { value: schema },
+      required: ["value"]
+    };
+  }
+  generateClaudeMd(spec, options) {
+    const lines = [];
+    lines.push("# Agent Configuration");
+    lines.push("");
+    if (spec.description) {
+      lines.push(`> ${spec.description}`);
+      lines.push("");
+    }
+    lines.push("## Metadata");
+    lines.push("");
+    lines.push(`- **Name**: ${spec.meta.key}`);
+    lines.push(`- **Version**: ${spec.meta.version}`);
+    if (spec.meta.owners && spec.meta.owners.length > 0) {
+      lines.push(`- **Owners**: ${spec.meta.owners.join(", ")}`);
+    }
+    if (options.model) {
+      lines.push(`- **Model**: ${options.model}`);
+    }
+    lines.push("");
+    lines.push("## Instructions");
+    lines.push("");
+    lines.push(spec.instructions);
+    lines.push("");
+    if (spec.tools.length > 0) {
+      lines.push("## Available Tools");
+      lines.push("");
+      for (const tool3 of spec.tools) {
+        const flags = [];
+        if (tool3.requiresApproval) {
+          flags.push("requires approval");
+        }
+        if (tool3.automationSafe === false) {
+          flags.push("not automation safe");
+        }
+        const flagStr = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        lines.push(`### ${tool3.name}${flagStr}`);
+        lines.push("");
+        if (tool3.description) {
+          lines.push(tool3.description);
+          lines.push("");
+        }
+        if (tool3.schema) {
+          lines.push("**Parameters:**");
+          lines.push("```json");
+          lines.push(JSON.stringify(tool3.schema, null, 2));
+          lines.push("```");
+          lines.push("");
+        }
+      }
+    }
+    if (spec.knowledge && spec.knowledge.length > 0) {
+      lines.push("## Knowledge Sources");
+      lines.push("");
+      for (const k of spec.knowledge) {
+        const required = k.required ? "(required)" : "(optional)";
+        lines.push(`- **${k.key}** ${required}`);
+        if (k.instructions) {
+          lines.push(`  - ${k.instructions}`);
+        }
+      }
+      lines.push("");
+    }
+    if (spec.policy) {
+      lines.push("## Policy");
+      lines.push("");
+      if (spec.policy.confidence?.min) {
+        lines.push(`- Minimum confidence: ${spec.policy.confidence.min}`);
+      }
+      if (spec.policy.escalation) {
+        lines.push("- Escalation policy configured");
+      }
+      if (spec.policy.flags && spec.policy.flags.length > 0) {
+        lines.push(`- Feature flags: ${spec.policy.flags.join(", ")}`);
+      }
+      lines.push("");
+    }
+    if (options.mcpServers && options.mcpServers.length > 0) {
+      lines.push("## MCP Servers");
+      lines.push("");
+      for (const server of options.mcpServers) {
+        lines.push(`- **${server.name}**: \`${server.command}${server.args ? " " + server.args.join(" ") : ""}\``);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(`*Generated from ContractSpec: ${agentKey(spec.meta)}*`);
+    return lines.join(`
+`);
+  }
+}
+function exportToClaudeAgent(spec, options) {
+  const exporter = new ClaudeAgentExporter;
+  return exporter.export(spec, options);
+}
+function generateClaudeMd(spec, options) {
+  const exporter = new ClaudeAgentExporter;
+  const result = exporter.export(spec, { ...options, generateClaudeMd: true });
+  return result.claudeMd ?? "";
+}
+function validateForClaudeAgent(spec) {
+  const exporter = new ClaudeAgentExporter;
+  return exporter.validate(spec);
+}
+// src/exporters/opencode-exporter.ts
+init_agent_bridge();
+
+class OpenCodeExporter {
+  format = "opencode";
+  export(spec, options = {}) {
+    const jsonConfig = this.buildJsonConfig(spec, options);
+    const markdownConfig = this.generateMarkdown(spec, jsonConfig, options);
+    return {
+      jsonConfig,
+      markdownConfig,
+      exportedAt: new Date,
+      sourceSpec: agentKey(spec.meta)
+    };
+  }
+  exportMany(specs, options = {}) {
+    return specs.map((spec) => this.export(spec, options));
+  }
+  validate(spec) {
+    const errors = [];
+    if (!spec.meta?.key) {
+      errors.push("Spec must have a meta.key");
+    }
+    if (!spec.instructions) {
+      errors.push("Spec must have instructions");
+    }
+    for (const tool3 of spec.tools ?? []) {
+      if (!tool3.name) {
+        errors.push("All tools must have a name");
+      }
+      if (tool3.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tool3.name)) {
+        errors.push(`Tool name '${tool3.name}' should be a valid identifier (letters, numbers, underscores)`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  buildJsonConfig(spec, options) {
+    const agentType = options.agentType ?? inferAgentType(spec);
+    return {
+      name: spec.meta.key,
+      version: spec.meta.version,
+      description: spec.description,
+      type: agentType,
+      instructions: spec.instructions,
+      tools: this.exportTools(spec),
+      config: {
+        max_steps: options.maxSteps ?? spec.maxSteps ?? 10,
+        temperature: options.temperature ?? 0.7,
+        model: options.model
+      }
+    };
+  }
+  exportTools(spec) {
+    return spec.tools.map((tool3) => ({
+      name: tool3.name,
+      description: tool3.description ?? `Execute ${tool3.name}`,
+      schema: tool3.schema ?? { type: "object" },
+      requires_approval: tool3.requiresApproval ?? !tool3.automationSafe
+    }));
+  }
+  generateMarkdown(spec, jsonConfig, options) {
+    const lines = [];
+    lines.push("---");
+    lines.push(`name: ${jsonConfig.name}`);
+    lines.push(`type: ${jsonConfig.type}`);
+    if (jsonConfig.version) {
+      lines.push(`version: ${jsonConfig.version}`);
+    }
+    if (jsonConfig.config.model) {
+      lines.push(`model: ${jsonConfig.config.model}`);
+    }
+    if (jsonConfig.config.temperature !== undefined) {
+      lines.push(`temperature: ${jsonConfig.config.temperature}`);
+    }
+    if (jsonConfig.config.max_steps !== undefined) {
+      lines.push(`max_steps: ${jsonConfig.config.max_steps}`);
+    }
+    if (jsonConfig.tools.length > 0) {
+      lines.push("tools:");
+      for (const tool3 of jsonConfig.tools) {
+        const permission = tool3.requires_approval ? " # requires approval" : "";
+        lines.push(`  - ${tool3.name}${permission}`);
+      }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(`# ${spec.meta.key}`);
+    lines.push("");
+    if (spec.description) {
+      lines.push(spec.description);
+      lines.push("");
+    }
+    lines.push(`> Agent type: **${jsonConfig.type}**`);
+    lines.push("");
+    lines.push(this.getAgentTypeDescription(jsonConfig.type));
+    lines.push("");
+    lines.push("## Instructions");
+    lines.push("");
+    lines.push(spec.instructions);
+    lines.push("");
+    if (spec.tools.length > 0) {
+      lines.push("## Tools");
+      lines.push("");
+      for (const tool3 of spec.tools) {
+        const approval = tool3.requiresApproval ? " *(requires approval)*" : "";
+        const safe = tool3.automationSafe === false ? " *(not automation safe)*" : "";
+        lines.push(`### ${tool3.name}${approval}${safe}`);
+        lines.push("");
+        if (tool3.description) {
+          lines.push(tool3.description);
+          lines.push("");
+        }
+        if (tool3.schema && options.includeComments !== false) {
+          lines.push("**Parameters:**");
+          lines.push("");
+          lines.push("```json");
+          lines.push(JSON.stringify(tool3.schema, null, options.prettyPrint !== false ? 2 : 0));
+          lines.push("```");
+          lines.push("");
+        }
+      }
+    }
+    if (spec.knowledge && spec.knowledge.length > 0) {
+      lines.push("## Knowledge Sources");
+      lines.push("");
+      for (const k of spec.knowledge) {
+        const required = k.required ? "(required)" : "(optional)";
+        lines.push(`- **${k.key}** ${required}`);
+        if (k.instructions) {
+          lines.push(`  - ${k.instructions}`);
+        }
+      }
+      lines.push("");
+    }
+    if (spec.policy) {
+      lines.push("## Policy");
+      lines.push("");
+      if (spec.policy.confidence?.min) {
+        lines.push(`- Minimum confidence: ${spec.policy.confidence.min}`);
+      }
+      if (spec.policy.escalation) {
+        lines.push("- Escalation policy configured");
+      }
+      lines.push("");
+    }
+    lines.push("## Configuration");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(jsonConfig.config, null, options.prettyPrint !== false ? 2 : 0));
+    lines.push("```");
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    lines.push(`*Generated from ContractSpec: ${agentKey(spec.meta)}*`);
+    lines.push(`*Exported at: ${new Date().toISOString()}*`);
+    return lines.join(`
+`);
+  }
+  getAgentTypeDescription(type) {
+    switch (type) {
+      case "build":
+        return "Primary agent with full tool access for code generation and modification.";
+      case "plan":
+        return "Restricted agent for analysis and planning. File edits and bash commands require approval.";
+      case "general":
+        return "General-purpose subagent for complex questions and multi-step tasks.";
+      case "explore":
+        return "Fast subagent optimized for codebase exploration and pattern searching.";
+      default:
+        return "";
+    }
+  }
+}
+function exportToOpenCode(spec, options) {
+  const exporter = new OpenCodeExporter;
+  return exporter.export(spec, options);
+}
+function generateOpenCodeMarkdown(spec, options) {
+  const exporter = new OpenCodeExporter;
+  const result = exporter.export(spec, options);
+  return result.markdownConfig;
+}
+function generateOpenCodeJSON(spec, options) {
+  const exporter = new OpenCodeExporter;
+  const result = exporter.export(spec, options);
+  return result.jsonConfig;
+}
+function validateForOpenCode(spec) {
+  const exporter = new OpenCodeExporter;
+  return exporter.validate(spec);
+}
+// src/spec/registry.ts
+import { compareVersions } from "compare-versions";
+import { SpecContractRegistry } from "@contractspec/lib.contracts/registry";
+
+class AgentRegistry extends SpecContractRegistry {
+  constructor(items) {
+    super("agent", items);
+  }
+  listNames() {
+    const names = new Set;
+    for (const spec of this.items.values()) {
+      names.add(spec.meta.key);
+    }
+    return [...names];
+  }
+  require(name, version) {
+    const spec = this.get(name, version);
+    if (!spec) {
+      throw new Error(`Agent spec not found for ${name}${version != null ? `.v${version}` : ""}`);
+    }
+    return spec;
+  }
+  has(name, version) {
+    return this.get(name, version) !== undefined;
+  }
+  getVersions(name) {
+    const versions = [];
+    for (const spec of this.items.values()) {
+      if (spec.meta.key === name) {
+        versions.push(spec);
+      }
+    }
+    return versions.sort((a, b) => compareVersions(a.meta.version, b.meta.version));
+  }
+}
+function createAgentRegistry() {
+  return new AgentRegistry;
+}
+// src/tools/mcp-client.ts
+import { experimental_createMCPClient } from "@ai-sdk/mcp";
+import { Experimental_StdioMCPTransport as StdioClientTransport } from "@ai-sdk/mcp/mcp-stdio";
+async function mcpServerToTools(config) {
+  const transport = new StdioClientTransport({
+    command: config.command,
+    args: config.args,
+    env: config.env
+  });
+  const client = await experimental_createMCPClient({ transport });
+  const tools = await client.tools();
+  return {
+    tools,
+    cleanup: () => client.close()
+  };
+}
+async function createMcpToolsets(configs) {
+  const results = await Promise.all(configs.map(mcpServerToTools));
+  const combinedTools = {};
+  for (const result of results) {
+    Object.assign(combinedTools, result.tools);
+  }
+  return {
+    tools: combinedTools,
+    cleanup: async () => {
+      await Promise.all(results.map((r) => r.cleanup()));
+    }
+  };
+}
+
+// src/tools/mcp-server.ts
+init_json_schema_to_zod();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z4 from "zod";
+function agentToMcpServer(agent, spec2) {
+  const server = new McpServer({
+    name: spec2.meta.key,
+    version: `${spec2.meta.version}`
+  });
+  server.registerTool(spec2.meta.key, {
+    description: spec2.description ?? `Interact with ${spec2.meta.key} agent`,
+    inputSchema: z4.object({
+      message: z4.string().describe("The message or query to send to the agent"),
+      sessionId: z4.string().optional().describe("Optional session ID to continue a conversation")
+    })
+  }, async (args) => {
+    const { message, sessionId } = args;
+    const result = await agent.generate({
+      prompt: message,
+      options: { sessionId }
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: result.text
+        }
+      ]
+    };
+  });
+  for (const toolConfig of spec2.tools) {
+    const inputSchema = toolConfig.schema ? jsonSchemaToZodSafe(toolConfig.schema) : z4.object({});
+    server.registerTool(`${spec2.meta.key}.${toolConfig.name}`, {
+      description: toolConfig.description ?? `Execute ${toolConfig.name} tool`,
+      inputSchema
+    }, async (args) => {
+      const result = await agent.generate({
+        prompt: `Execute the ${toolConfig.name} tool with the following arguments: ${JSON.stringify(args)}`
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.text
+          }
+        ]
+      };
+    });
+  }
+  return server;
+}
+function createAgentMcpServer(config) {
+  return agentToMcpServer(config.agent, config.spec);
+}
+
+// src/tools/index.ts
+init_tool_adapter();
+init_knowledge_tool();
+
+// src/schema/schema-output.ts
+init_json_schema_to_zod();
+import { Output } from "ai";
+function jsonSchemaToOutput(schema) {
+  const zodSchema = jsonSchemaToZod(schema);
+  return Output.object({
+    schema: zodSchema
+  });
+}
+function jsonSchemaToArrayOutput(itemSchema) {
+  const zodSchema = jsonSchemaToZod(itemSchema);
+  return Output.array({
+    element: zodSchema
+  });
+}
+function enumToChoiceOutput(choices) {
+  return Output.choice({
+    options: choices
+  });
+}
+function zodToOutput(schema) {
+  return Output.object({
+    schema
+  });
+}
+function textOutput() {
+  return Output.text();
+}
+var SchemaOutput = {
+  fromJsonSchema: jsonSchemaToOutput,
+  arrayFromJsonSchema: jsonSchemaToArrayOutput,
+  fromEnum: enumToChoiceOutput,
+  fromZod: zodToOutput,
+  text: textOutput
+};
+
+// src/schema/index.ts
+init_json_schema_to_zod();
+// src/telemetry/index.ts
+init_adapter();
+
+// src/providers/registry.ts
+init_types();
+
+class InMemoryProviderRegistry {
+  providers = new Map;
+  get(name) {
+    return this.providers.get(name);
+  }
+  register(name, provider) {
+    this.providers.set(name, provider);
+  }
+  list() {
+    return Array.from(this.providers.keys());
+  }
+  isAvailable(name) {
+    const provider = this.providers.get(name);
+    return provider !== undefined && provider.isAvailable();
+  }
+  require(name) {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      throw new ProviderNotAvailableError(name, "not registered");
+    }
+    if (!provider.isAvailable()) {
+      throw new ProviderNotAvailableError(name, "dependencies not installed or not configured");
+    }
+    return provider;
+  }
+  clear() {
+    this.providers.clear();
+  }
+}
+function createProviderRegistry() {
+  return new InMemoryProviderRegistry;
+}
+var defaultProviderRegistry = createProviderRegistry();
+
+// src/providers/index.ts
+init_claude_agent_sdk();
+init_opencode_sdk();
+init_types();
+// src/interop/spec-consumer.ts
+class ContractSpecConsumer {
+  specs;
+  includeMetadata;
+  baseUrl;
+  constructor(config) {
+    this.specs = new Map;
+    this.includeMetadata = config.includeMetadata ?? true;
+    this.baseUrl = config.baseUrl;
+    for (const spec2 of config.specs) {
+      const key = agentKey(spec2.meta);
+      this.specs.set(key, spec2);
+    }
+  }
+  getSpecMarkdown(specKey, options) {
+    const spec2 = this.specs.get(specKey);
+    if (!spec2) {
+      throw new Error(`Spec not found: ${specKey}`);
+    }
+    const sections = [];
+    const opts = {
+      includeToc: options?.includeToc ?? true,
+      includeTools: options?.includeTools ?? true,
+      ...options
+    };
+    if (opts.customHeader) {
+      sections.push(opts.customHeader);
+      sections.push("");
+    }
+    const specName = spec2.meta.key;
+    sections.push(`# ${specName}`);
+    sections.push("");
+    if (spec2.description) {
+      sections.push(spec2.description);
+      sections.push("");
+    }
+    if (opts.includeToc) {
+      sections.push("## Table of Contents");
+      sections.push("");
+      sections.push("- [Overview](#overview)");
+      sections.push("- [Instructions](#instructions)");
+      if (opts.includeTools && spec2.tools && spec2.tools.length > 0) {
+        sections.push("- [Tools](#tools)");
+      }
+      if (spec2.knowledge && spec2.knowledge.length > 0) {
+        sections.push("- [Knowledge](#knowledge)");
+      }
+      sections.push("");
+    }
+    sections.push("## Overview");
+    sections.push("");
+    if (this.includeMetadata) {
+      sections.push(`- **Key**: \`${spec2.meta.key}\``);
+      sections.push(`- **Version**: ${spec2.meta.version}`);
+      if (spec2.meta.stability) {
+        sections.push(`- **Stability**: ${spec2.meta.stability}`);
+      }
+      if (spec2.meta.owners && spec2.meta.owners.length > 0) {
+        sections.push(`- **Owners**: ${spec2.meta.owners.join(", ")}`);
+      }
+      if (spec2.tags && spec2.tags.length > 0) {
+        sections.push(`- **Tags**: ${spec2.tags.join(", ")}`);
+      }
+    }
+    sections.push("");
+    sections.push("## Instructions");
+    sections.push("");
+    sections.push(spec2.instructions);
+    sections.push("");
+    if (opts.includeTools && spec2.tools && spec2.tools.length > 0) {
+      sections.push("## Tools");
+      sections.push("");
+      for (const tool3 of spec2.tools) {
+        sections.push(`### ${tool3.name}`);
+        sections.push("");
+        if (tool3.description) {
+          sections.push(tool3.description);
+          sections.push("");
+        }
+        if (tool3.schema) {
+          sections.push("**Schema:**");
+          sections.push("");
+          sections.push("```json");
+          sections.push(JSON.stringify(tool3.schema, null, 2));
+          sections.push("```");
+          sections.push("");
+        }
+        if (tool3.automationSafe !== undefined) {
+          sections.push(`**Automation Safe**: ${tool3.automationSafe ? "Yes" : "No"}`);
+          sections.push("");
+        }
+      }
+    }
+    if (spec2.knowledge && spec2.knowledge.length > 0) {
+      sections.push("## Knowledge");
+      sections.push("");
+      for (const k of spec2.knowledge) {
+        sections.push(`- **${k.key}**${k.required ? " (required)" : ""}`);
+        if (k.instructions) {
+          sections.push(`  - ${k.instructions}`);
+        }
+      }
+      sections.push("");
+    }
+    if (spec2.policy) {
+      sections.push("## Policy");
+      sections.push("");
+      if (spec2.policy.confidence) {
+        sections.push(`- **Minimum Confidence**: ${spec2.policy.confidence.min ?? 0.7}`);
+      }
+      if (spec2.policy.escalation) {
+        const esc = spec2.policy.escalation;
+        if (esc.confidenceThreshold) {
+          sections.push(`- **Escalation Threshold**: ${esc.confidenceThreshold}`);
+        }
+        if (esc.onToolFailure) {
+          sections.push("- **Escalate on Tool Failure**: Yes");
+        }
+        if (esc.onTimeout) {
+          sections.push("- **Escalate on Timeout**: Yes");
+        }
+      }
+      sections.push("");
+    }
+    return sections.join(`
+`);
+  }
+  getSpecPrompt(specKey, options) {
+    const spec2 = this.specs.get(specKey);
+    if (!spec2) {
+      throw new Error(`Spec not found: ${specKey}`);
+    }
+    const sections = [];
+    const opts = {
+      includeTools: options?.includeTools ?? true,
+      format: options?.format ?? "structured",
+      ...options
+    };
+    sections.push("# Agent Identity");
+    sections.push("");
+    sections.push(`You are ${spec2.meta.key} (v${spec2.meta.version}).`);
+    sections.push("");
+    if (spec2.description) {
+      sections.push("## Description");
+      sections.push("");
+      sections.push(spec2.description);
+      sections.push("");
+    }
+    sections.push("## Instructions");
+    sections.push("");
+    sections.push(spec2.instructions);
+    sections.push("");
+    if (opts.includeTools && spec2.tools && spec2.tools.length > 0) {
+      sections.push("## Available Tools");
+      sections.push("");
+      sections.push("You have access to the following tools:");
+      sections.push("");
+      for (const tool3 of spec2.tools) {
+        sections.push(`### ${tool3.name}`);
+        sections.push("");
+        if (tool3.description) {
+          sections.push(tool3.description);
+          sections.push("");
+        }
+        if (tool3.schema && opts.format === "structured") {
+          sections.push("Parameters:");
+          sections.push("```json");
+          sections.push(JSON.stringify(tool3.schema, null, 2));
+          sections.push("```");
+          sections.push("");
+        }
+      }
+    }
+    if (spec2.knowledge && spec2.knowledge.length > 0) {
+      const requiredKnowledge = spec2.knowledge.filter((k) => k.required);
+      if (requiredKnowledge.length > 0) {
+        sections.push("## Knowledge Context");
+        sections.push("");
+        for (const k of requiredKnowledge) {
+          if (k.instructions) {
+            sections.push(k.instructions);
+            sections.push("");
+          }
+        }
+      }
+    }
+    if (options?.customContext) {
+      sections.push("## Additional Context");
+      sections.push("");
+      sections.push(options.customContext);
+      sections.push("");
+    }
+    return sections.join(`
+`);
+  }
+  listSpecs(options) {
+    const results = [];
+    for (const [key, spec2] of this.specs) {
+      if (options?.stability && spec2.meta.stability !== options.stability) {
+        continue;
+      }
+      if (options?.tags && options.tags.length > 0) {
+        const specTags = spec2.tags ?? [];
+        const hasMatchingTag = options.tags.some((tag) => specTags.includes(tag));
+        if (!hasMatchingTag) {
+          continue;
+        }
+      }
+      results.push({
+        key,
+        name: spec2.meta.key,
+        version: spec2.meta.version,
+        description: spec2.description,
+        stability: spec2.meta.stability,
+        tags: spec2.tags,
+        toolCount: spec2.tools?.length ?? 0
+      });
+    }
+    return results;
+  }
+  querySpec(specKey) {
+    const spec2 = this.specs.get(specKey);
+    if (!spec2) {
+      return;
+    }
+    return {
+      key: specKey,
+      spec: spec2,
+      markdown: this.getSpecMarkdown(specKey),
+      prompt: this.getSpecPrompt(specKey)
+    };
+  }
+  hasSpec(specKey) {
+    return this.specs.has(specKey);
+  }
+  getSpec(specKey) {
+    return this.specs.get(specKey);
+  }
+  getAllSpecs() {
+    return Array.from(this.specs.values());
+  }
+  getSpecCount() {
+    return this.specs.size;
+  }
+  addSpec(spec2) {
+    const key = agentKey(spec2.meta);
+    this.specs.set(key, spec2);
+  }
+  removeSpec(specKey) {
+    return this.specs.delete(specKey);
+  }
+}
+function createSpecConsumer(config) {
+  return new ContractSpecConsumer(config);
+}
+function createSingleSpecConsumer(spec2, options) {
+  return new ContractSpecConsumer({
+    specs: [spec2],
+    ...options
+  });
+}
+
+// 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 tool3 of config.tools) {
+      this.tools.set(tool3.config.name, tool3);
+    }
+  }
+  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 tool3 = this.tools.get(toolName);
+    if (!tool3) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+    if (!tool3.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 tool3.handler(args, fullContext);
+  }
+  getMCPToolDefinitions() {
+    const definitions = [];
+    for (const [name, tool3] of this.tools) {
+      definitions.push({
+        name,
+        description: tool3.config.description ?? "",
+        inputSchema: tool3.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 tool3 of config.tools) {
+      this.tools.set(tool3.config.name, tool3);
+    }
+  }
+  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((tool3) => !!tool3.handler).map((tool3) => specToolToClaudeAgentTool(tool3.config, tool3.handler, defaultContext));
+      case "opencode":
+        return tools.map((tool3) => specToolToOpenCodeTool(tool3.config));
+      case "mcp":
+        return tools.map((tool3) => ({
+          name: tool3.config.name,
+          description: tool3.config.description ?? "",
+          inputSchema: tool3.config.schema ?? { type: "object", properties: {} }
+        }));
+      case "openai":
+        return tools.map((tool3) => ({
+          type: "function",
+          function: {
+            name: tool3.config.name,
+            description: tool3.config.description ?? "",
+            parameters: tool3.config.schema ?? {
+              type: "object",
+              properties: {}
+            }
+          }
+        }));
+      default:
+        throw new Error(`Unknown export format: ${format}`);
+    }
+  }
+  createBridgedHandler(toolName, _format) {
+    const tool3 = this.tools.get(toolName);
+    if (!tool3 || !tool3.handler) {
+      return;
+    }
+    const handler = tool3.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 tool3 = this.tools.get(name);
+    if (!tool3) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    if (!tool3.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 tool3.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);
+}
+function createToolServer(config) {
+  return new MCPToolServer(config);
+}
+function exportToolsForExternalSDK(tools, format) {
+  const consumer = new ContractSpecToolConsumer({
+    tools: tools.map((config) => ({ config }))
+  });
+  return consumer.exportToolsForSDK(format);
+}
+// src/index.ts
+import { Experimental_Agent } from "ai";
+export {
+  zodToOutput,
+  validateForOpenCode,
+  validateForClaudeAgent,
+  trackAgentStep,
+  textOutput,
+  specToolsToAISDKTools,
+  specToolToAISDKTool,
+  noopTelemetryCollector,
+  mcpServerToTools,
+  jsonSchemaToZodSafe,
+  jsonSchemaToZod,
+  jsonSchemaToOutput,
+  jsonSchemaToArrayOutput,
+  injectStaticKnowledge,
+  getAvailableBackends,
+  generateSessionId,
+  generateOpenCodeMarkdown,
+  generateOpenCodeJSON,
+  generateClaudeMd,
+  exportToolsForExternalSDK,
+  exportToOpenCode,
+  exportToClaudeAgent,
+  enumToChoiceOutput,
+  defineAgent,
+  defaultProviderRegistry,
+  createUnifiedAgent,
+  createToolServer,
+  createToolHandler,
+  createToolConsumer,
+  createSpecConsumer,
+  createSingleSpecConsumer,
+  createProviderRegistry,
+  createOpenCodeSDKAgent,
+  createMcpToolsets,
+  createKnowledgeQueryTool,
+  createKnowledgeInjector,
+  createInMemoryTelemetryCollector,
+  createInMemorySessionStore,
+  createClaudeAgentSDKAgent,
+  createApprovalWorkflow,
+  createAgentRegistry,
+  createAgentMcpServer,
+  createAgentJsonRunner,
+  createAISDKAgent,
+  buildToolHandlers,
+  agentToMcpServer,
+  agentKey,
+  UnifiedAgent,
+  Experimental_Agent as ToolLoopAgent,
+  SchemaOutput,
+  ProviderNotAvailableError,
+  ProviderExecutionError,
+  OpenCodeSDKProvider,
+  OpenCodeExporter,
+  InMemoryTelemetryCollector,
+  InMemorySessionStore,
+  InMemoryApprovalStore,
+  ExternalProviderError,
+  ContractSpecToolConsumer,
+  ContractSpecConsumer,
+  ContractSpecAgent,
+  ContextCreationError,
+  ClaudeAgentSDKProvider,
+  ClaudeAgentExporter,
+  ApprovalWorkflow,
+  AgentRegistry
+};