@contractspec/lib.ai-agent 1.62.0 → 2.1.0

package/dist/index.js

@@ -13,7 +13,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/i18n/catalogs/en.ts
-import { defineTranslation } from "@contractspec/lib.contracts/translations";
+import { defineTranslation } from "@contractspec/lib.contracts-spec/translations";
 var enMessages;
 var init_en = __esm(() => {
   enMessages = defineTranslation({
@@ -609,7 +609,7 @@ var init_en = __esm(() => {
 });
 
 // src/i18n/catalogs/fr.ts
-import { defineTranslation as defineTranslation2 } from "@contractspec/lib.contracts/translations";
+import { defineTranslation as defineTranslation2 } from "@contractspec/lib.contracts-spec/translations";
 var frMessages;
 var init_fr = __esm(() => {
   frMessages = defineTranslation2({
@@ -1220,7 +1220,7 @@ var init_fr = __esm(() => {
 });
 
 // src/i18n/catalogs/es.ts
-import { defineTranslation as defineTranslation3 } from "@contractspec/lib.contracts/translations";
+import { defineTranslation as defineTranslation3 } from "@contractspec/lib.contracts-spec/translations";
 var esMessages;
 var init_es = __esm(() => {
   esMessages = defineTranslation3({
@@ -1885,7 +1885,7 @@ var init_locale = __esm(() => {
 });
 
 // src/i18n/messages.ts
-import { TranslationRegistry } from "@contractspec/lib.contracts/translations";
+import { TranslationRegistry } from "@contractspec/lib.contracts-spec/translations";
 function getRegistry() {
   if (!sharedRegistry) {
     sharedRegistry = new TranslationRegistry([
@@ -2137,2786 +2137,10 @@ var init_spec = __esm(() => {
   init_i18n();
 });
 
-// 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(getDefaultI18n().t("error.missingToolHandler", { name: 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();
-  init_i18n();
-});
-
-// src/tools/knowledge-tool.ts
-import { tool as tool2 } from "ai";
-import * as z2 from "zod";
-function createKnowledgeQueryTool(retriever, knowledgeRefs, locale) {
-  const i18n = createAgentI18n(locale);
-  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 ?? i18n.t("tool.knowledge.spaceDefault")}`).join(`
-`);
-  return tool2({
-    description: `${i18n.t("tool.knowledge.description")}
-
-${i18n.t("tool.knowledge.availableSpaces")}
-${spaceDescriptions}`,
-    inputSchema: z2.object({
-      query: z2.string().describe(i18n.t("tool.knowledge.param.query")),
-      spaceKey: z2.enum(optionalSpaces).optional().describe(i18n.t("tool.knowledge.param.spaceKey")),
-      topK: z2.number().optional().default(5).describe(i18n.t("tool.knowledge.param.topK"))
-    }),
-    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(i18n.t("log.knowledge.queryFailed", { space }), error);
-        }
-      }
-      if (allResults.length === 0) {
-        return i18n.t("tool.knowledge.noResults");
-      }
-      allResults.sort((a, b) => b.score - a.score);
-      const topResults = allResults.slice(0, topK ?? 5);
-      return topResults.map((r, i) => `${i18n.t("tool.knowledge.sourceLabel", { index: i + 1, space: r.space, score: (r.score * 100).toFixed(0) })}
-${r.content}`).join(`
-
----
-
-`);
-    }
-  });
-}
-var init_knowledge_tool = __esm(() => {
-  init_i18n();
-});
-
-// src/knowledge/injector.ts
-async function injectStaticKnowledge(instructions, knowledgeRefs, retriever, locale) {
-  if (!retriever)
-    return instructions;
-  const requiredRefs = knowledgeRefs.filter((ref) => ref.required);
-  if (requiredRefs.length === 0)
-    return instructions;
-  const i18n = createAgentI18n(locale);
-  const blocks = [];
-  for (const ref of requiredRefs) {
-    if (!retriever.supportsSpace(ref.key)) {
-      console.warn(i18n.t("log.knowledge.spaceNotAvailable", { key: ref.key }));
-      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(i18n.t("log.knowledge.loadFailed", { key: ref.key }), error);
-    }
-  }
-  if (blocks.length === 0)
-    return instructions;
-  return `${instructions}
-
----
-
-# ${i18n.t("knowledge.header")}
-
-${i18n.t("knowledge.description")}
-
-${blocks.join(`
-
----
-
-`)}`;
-}
-function createKnowledgeInjector(retriever, locale) {
-  return {
-    inject: (instructions, knowledgeRefs) => injectStaticKnowledge(instructions, knowledgeRefs, retriever, locale),
-    hasSpace: (spaceKey) => retriever?.supportsSpace(spaceKey) ?? false,
-    listSpaces: () => retriever?.listSpaces() ?? []
-  };
-}
-var init_injector = __esm(() => {
-  init_i18n();
-});
-
-// 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/telemetry/posthog.ts
-var exports_posthog = {};
-__export(exports_posthog, {
-  createPostHogTracedModel: () => createPostHogTracedModel,
-  createPostHogTelemetryCollector: () => createPostHogTelemetryCollector,
-  createCompositeTelemetryCollector: () => createCompositeTelemetryCollector,
-  PostHogTelemetryCollector: () => PostHogTelemetryCollector,
-  CompositeTelemetryCollector: () => CompositeTelemetryCollector
-});
-async function createPostHogTracedModel(model, config, overrides) {
-  const { withTracing } = await importPostHogAI();
-  const phClient = await resolvePostHogClient(config);
-  const tracingOptions = {
-    ...config.defaults,
-    ...overrides
-  };
-  return withTracing(model, phClient, tracingOptions);
-}
-
-class PostHogTelemetryCollector {
-  phClient;
-  config;
-  initPromise;
-  constructor(config) {
-    this.config = config;
-    this.phClient = config.client;
-  }
-  async collect(sample) {
-    const client = await this.getClient();
-    const distinctId = this.config.defaults?.posthogDistinctId ?? sample.metadata?.["actorId"] ?? "system";
-    client.capture({
-      distinctId,
-      event: "$ai_generation",
-      properties: {
-        $ai_model: sample.operation.name,
-        $ai_provider: "contractspec",
-        $ai_latency: sample.durationMs / 1000,
-        $ai_is_error: !sample.success,
-        $ai_trace_id: this.config.defaults?.posthogTraceId,
-        ...sample.metadata?.["tokenUsage"] ? mapTokenUsage(sample.metadata["tokenUsage"]) : {},
-        ...this.config.defaults?.posthogProperties,
-        contractspec_operation: sample.operation.name,
-        contractspec_version: sample.operation.version,
-        contractspec_agent_id: sample.metadata?.["agentId"],
-        contractspec_finish_reason: sample.metadata?.["finishReason"],
-        contractspec_tool_count: sample.metadata?.["toolCallCount"]
-      },
-      groups: this.config.defaults?.posthogGroups
-    });
-  }
-  async shutdown() {
-    if (this.phClient?.shutdown) {
-      await this.phClient.shutdown();
-    }
-  }
-  async getClient() {
-    if (this.phClient)
-      return this.phClient;
-    if (!this.initPromise) {
-      this.initPromise = resolvePostHogClient(this.config).then((client) => {
-        this.phClient = client;
-        return client;
-      });
-    }
-    return this.initPromise;
-  }
-}
-function createPostHogTelemetryCollector(config) {
-  return new PostHogTelemetryCollector(config);
-}
-
-class CompositeTelemetryCollector {
-  collectors;
-  constructor(collectors) {
-    this.collectors = collectors;
-  }
-  async collect(sample) {
-    await Promise.all(this.collectors.map((c) => c.collect(sample)));
-  }
-}
-function createCompositeTelemetryCollector(collectors) {
-  return new CompositeTelemetryCollector(collectors);
-}
-async function importPostHogAI() {
-  try {
-    return await import("@posthog/ai");
-  } catch {
-    throw new Error("PostHog LLM Analytics requires @posthog/ai to be installed. Run: npm install @posthog/ai posthog-node");
-  }
-}
-async function resolvePostHogClient(config) {
-  if (config.client)
-    return config.client;
-  if (!config.apiKey) {
-    throw new Error("PostHog LLM Analytics requires either a client instance or an apiKey.");
-  }
-  try {
-    const { PostHog } = await import("posthog-node");
-    return new PostHog(config.apiKey, {
-      host: config.host ?? "https://us.i.posthog.com"
-    });
-  } catch {
-    throw new Error("PostHog LLM Analytics requires posthog-node to be installed. Run: npm install posthog-node");
-  }
-}
-function mapTokenUsage(usage) {
-  return {
-    $ai_input_tokens: usage["promptTokens"],
-    $ai_output_tokens: usage["completionTokens"]
-  };
-}
-
-// 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) {
-    let effectiveConfig = config;
-    if (config.posthogConfig) {
-      const { createPostHogTracedModel: createPostHogTracedModel2 } = await Promise.resolve().then(() => exports_posthog);
-      const tracedModel = await createPostHogTracedModel2(config.model, config.posthogConfig, config.posthogConfig.tracingOptions);
-      effectiveConfig = { ...config, model: tracedModel };
-    }
-    const instructions = await injectStaticKnowledge(effectiveConfig.spec.instructions, effectiveConfig.spec.knowledge ?? [], effectiveConfig.knowledgeRetriever);
-    const specTools = specToolsToAISDKTools(effectiveConfig.spec.tools, effectiveConfig.toolHandlers, { agentId: agentKey(effectiveConfig.spec.meta) });
-    const knowledgeTool = effectiveConfig.knowledgeRetriever ? createKnowledgeQueryTool(effectiveConfig.knowledgeRetriever, effectiveConfig.spec.knowledge ?? []) : null;
-    const tools = {
-      ...specTools,
-      ...knowledgeTool ? { query_knowledge: knowledgeTool } : {},
-      ...effectiveConfig.additionalTools ?? {}
-    };
-    return new ContractSpecAgent(effectiveConfig, 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_spec();
-  init_tool_adapter();
-  init_knowledge_tool();
-  init_injector();
-  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 ?? getDefaultI18n().t("tool.fallbackDescription", { name: 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(getDefaultI18n().t("error.handlerNotFoundForTool", {
-        name: 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 ?? getDefaultI18n().t("tool.fallbackDescription", { name: 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
-  }));
-}
-var init_tool_bridge = __esm(() => {
-  init_i18n();
-});
-
-// 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, getDefaultI18n().t("error.provider.sdkNotConfigured"));
-    }
-    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, getDefaultI18n().t("error.provider.contextCreation", {
-        error: 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, getDefaultI18n().t("error.provider.executionFailed", {
-        error: 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, getDefaultI18n().t("error.provider.streamFailed", {
-        error: 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, getDefaultI18n().t("error.provider.claudeSdkMissing"));
-    }
-  }
-  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(getDefaultI18n().t("error.toolNoExecuteHandler", {
-              name: tool3.name
-            }));
-          }
-          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: getDefaultI18n().t("error.toolNotFoundOrNoHandler", {
-          name: toolCall.toolName
-        })
-      };
-    }
-    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_spec();
-  init_types();
-  init_tool_bridge();
-  init_injector();
-  init_i18n();
-});
-
-// 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();
-  init_tool_bridge();
-});
-
-// src/providers/opencode-sdk/tool-bridge.ts
-function specToolToOpenCodeTool(tool3) {
-  return {
-    name: tool3.name,
-    description: tool3.description ?? getDefaultI18n().t("tool.fallbackDescription", { name: 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 ?? getDefaultI18n().t("tool.fallbackDescription", { name: 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: getDefaultI18n().t("error.toolNotFoundOrNoHandler", {
-        name: toolCall.name
-      }),
-      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
-    };
-  }
-}
-var init_tool_bridge2 = __esm(() => {
-  init_i18n();
-});
-
-// 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 i18n = getDefaultI18n();
-  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(i18n.t("export.instructions"));
-  lines.push("");
-  lines.push(spec.instructions);
-  lines.push("");
-  if (spec.tools.length > 0) {
-    lines.push(i18n.t("export.tools"));
-    lines.push("");
-    for (const tool3 of spec.tools) {
-      const permission = tool3.requiresApproval ? i18n.t("export.bridge.requiresApproval") : tool3.automationSafe === false ? i18n.t("export.bridge.askMode") : "";
-      lines.push(`- **${tool3.name}**: ${tool3.description ?? i18n.t("export.noDescription")} ${permission}`.trim());
-    }
-    lines.push("");
-  }
-  if (spec.knowledge && spec.knowledge.length > 0) {
-    lines.push(i18n.t("export.knowledgeSources"));
-    lines.push("");
-    for (const k of spec.knowledge) {
-      const required = k.required ? i18n.t("export.required") : i18n.t("export.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 = __esm(() => {
-  init_tool_bridge2();
-  init_i18n();
-});
-
-// 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, getDefaultI18n().t("error.provider.sdkNotInstalled"));
-    }
-    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, getDefaultI18n().t("error.provider.contextCreation", {
-        error: 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, getDefaultI18n().t("error.provider.executionFailed", {
-        error: 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, getDefaultI18n().t("error.provider.streamFailed", {
-        error: 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, getDefaultI18n().t("error.provider.opencodeSdkMissing"));
-    }
-  }
-  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_spec();
-  init_types();
-  init_tool_bridge2();
-  init_agent_bridge();
-  init_injector();
-  init_i18n();
-});
-
-// 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_tool_bridge2();
-  init_agent_bridge();
-});
-
-// src/agent/json-runner.ts
-init_i18n();
-init_contract_spec_agent();
-import { createProvider } from "@contractspec/lib.ai-providers/factory";
-import { StabilityEnum } from "@contractspec/lib.contracts/ownership";
-function getJsonOnlyRules(locale) {
-  const i18n = createAgentI18n(locale);
-  return [
-    i18n.t("agent.json.rules.validJsonOnly"),
-    i18n.t("agent.json.rules.noMarkdownFences"),
-    i18n.t("agent.json.rules.noCommentary"),
-    i18n.t("agent.json.rules.doubleQuotes"),
-    i18n.t("agent.json.rules.noTrailingCommas")
-  ].join(`
-`);
-}
-function getDefaultSpec(locale) {
-  const i18n = createAgentI18n(locale);
-  return {
-    meta: {
-      key: "agent.json-runner",
-      version: "1.0.0",
-      description: i18n.t("agent.json.defaultDescription"),
-      stability: StabilityEnum.Experimental,
-      owners: ["platform.core"],
-      tags: ["json", "agent"]
-    },
-    instructions: i18n.t("agent.json.systemPrompt"),
-    tools: []
-  };
-}
-function resolveModel(options) {
-  if (options.model)
-    return options.model;
-  if (options.provider) {
-    return createProvider(options.provider).getModel();
-  }
-  throw new Error(getDefaultI18n().t("error.jsonRunner.requiresModel"));
-}
-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, locale, system) {
-  return [base, getJsonOnlyRules(locale), system].filter(Boolean).join(`
-
-`);
-}
-function ensureToolHandlers(spec, handlers) {
-  for (const tool3 of spec.tools) {
-    if (!handlers.has(tool3.name)) {
-      throw new Error(getDefaultI18n().t("error.missingToolHandler", { name: tool3.name }));
-    }
-  }
-}
-async function createAgentJsonRunner(options) {
-  const model = applyModelSettings(resolveModel(options), {
-    temperature: options.temperature ?? 0
-  });
-  const baseSpec = options.spec ?? getDefaultSpec(options.locale);
-  const spec = {
-    ...baseSpec,
-    locale: options.spec?.locale ?? options.locale,
-    instructions: buildInstructions(baseSpec.instructions, options.locale, 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
-init_i18n();
-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(getDefaultI18n().t("error.unknownBackend", {
-            backend: String(backend)
-          }));
-      }
-    } catch (error) {
-      this.state.lastError = error instanceof Error ? error : new Error(String(error));
-      if (this.config.fallbackBackend && this.config.fallbackBackend !== backend) {
-        console.warn(getDefaultI18n().t("log.unifiedAgent.fallback", {
-          backend: String(backend),
-          fallback: String(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(getDefaultI18n().t("error.claudeSdk.notAvailable"));
-      }
-      this.context = await this.provider.createContext(this.spec);
-      this.state.isReady = true;
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error(getDefaultI18n().t("error.claudeSdk.notInstalled"));
-      }
-      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(getDefaultI18n().t("error.opencodeSdk.notAvailable"));
-      }
-      this.context = await this.provider.createContext(this.spec);
-      this.state.isReady = true;
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error(getDefaultI18n().t("error.opencodeSdk.notInstalled"));
-      }
-      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(getDefaultI18n().t("error.unknownBackend", {
-            backend: String(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(getDefaultI18n().t("error.providerNotInitialized"));
-    }
-    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
-init_i18n();
-import { randomUUID } from "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 ?? getDefaultI18n().t("approval.toolRequiresApproval", {
-        name: toolCall.toolName
-      })
-    });
-  }
-  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
-init_spec();
-init_i18n();
-
-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 i18n = getDefaultI18n();
-    const errors = [];
-    if (!spec.meta?.key) {
-      errors.push(i18n.t("export.validation.requiresKey"));
-    }
-    if (!spec.instructions) {
-      errors.push(i18n.t("export.validation.requiresInstructions"));
-    }
-    if (!spec.tools || spec.tools.length === 0) {
-      errors.push(i18n.t("export.validation.requiresTool"));
-    }
-    for (const tool3 of spec.tools ?? []) {
-      if (!tool3.name) {
-        errors.push(i18n.t("export.validation.toolRequiresName"));
-      }
-      if (!tool3.description && !tool3.name) {
-        errors.push(i18n.t("export.validation.toolRequiresDescOrName"));
-      }
-    }
-    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 i18n = getDefaultI18n();
-    const parts = [];
-    parts.push(spec.instructions);
-    if (spec.knowledge && spec.knowledge.length > 0) {
-      parts.push("");
-      parts.push(i18n.t("export.knowledgeSources"));
-      for (const k of spec.knowledge) {
-        if (k.instructions) {
-          parts.push(`- ${k.key}: ${k.instructions}`);
-        }
-      }
-    }
-    if (spec.policy) {
-      parts.push("");
-      parts.push(i18n.t("export.policy"));
-      if (spec.policy.confidence?.min) {
-        parts.push(i18n.t("export.minConfidence", { min: spec.policy.confidence.min }));
-      }
-      if (spec.policy.escalation) {
-        parts.push(i18n.t("export.escalationConfigured"));
-      }
-    }
-    if (options.metadata) {
-      parts.push("");
-      parts.push(i18n.t("export.additionalContext"));
-      for (const [key, value] of Object.entries(options.metadata)) {
-        parts.push(`- ${key}: ${String(value)}`);
-      }
-    }
-    return parts.join(`
-`);
-  }
-  exportTools(spec) {
-    const i18n = getDefaultI18n();
-    return spec.tools.map((tool3) => ({
-      name: tool3.name,
-      description: tool3.description ?? i18n.t("tool.fallbackDescription", { name: 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 i18n = getDefaultI18n();
-    const lines = [];
-    lines.push(i18n.t("export.agentConfiguration"));
-    lines.push("");
-    if (spec.description) {
-      lines.push(`> ${spec.description}`);
-      lines.push("");
-    }
-    lines.push(i18n.t("export.metadata"));
-    lines.push("");
-    lines.push(i18n.t("export.metaName", { name: spec.meta.key }));
-    lines.push(i18n.t("export.metaVersion", { version: spec.meta.version }));
-    if (spec.meta.owners && spec.meta.owners.length > 0) {
-      lines.push(i18n.t("export.metaOwners", {
-        owners: spec.meta.owners.join(", ")
-      }));
-    }
-    if (options.model) {
-      lines.push(i18n.t("export.metaModel", { model: options.model }));
-    }
-    lines.push("");
-    lines.push(i18n.t("export.instructions"));
-    lines.push("");
-    lines.push(spec.instructions);
-    lines.push("");
-    if (spec.tools.length > 0) {
-      lines.push(i18n.t("export.availableTools"));
-      lines.push("");
-      for (const tool3 of spec.tools) {
-        const flags = [];
-        if (tool3.requiresApproval) {
-          flags.push(i18n.t("export.requiresApproval"));
-        }
-        if (tool3.automationSafe === false) {
-          flags.push(i18n.t("export.notAutomationSafe"));
-        }
-        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(i18n.t("export.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(i18n.t("export.knowledgeSources"));
-      lines.push("");
-      for (const k of spec.knowledge) {
-        const required = k.required ? i18n.t("export.required") : i18n.t("export.optional");
-        lines.push(`- **${k.key}** ${required}`);
-        if (k.instructions) {
-          lines.push(`  - ${k.instructions}`);
-        }
-      }
-      lines.push("");
-    }
-    if (spec.policy) {
-      lines.push(i18n.t("export.policy"));
-      lines.push("");
-      if (spec.policy.confidence?.min) {
-        lines.push(i18n.t("export.minConfidence", { min: spec.policy.confidence.min }));
-      }
-      if (spec.policy.escalation) {
-        lines.push(i18n.t("export.escalationPolicyConfigured"));
-      }
-      if (spec.policy.flags && spec.policy.flags.length > 0) {
-        lines.push(i18n.t("export.featureFlags", {
-          flags: spec.policy.flags.join(", ")
-        }));
-      }
-      lines.push("");
-    }
-    if (options.mcpServers && options.mcpServers.length > 0) {
-      lines.push(i18n.t("export.mcpServers"));
-      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(i18n.t("export.generatedFrom", { key: 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_spec();
-init_agent_bridge();
-init_i18n();
-
-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 i18n = getDefaultI18n();
-    const errors = [];
-    if (!spec.meta?.key) {
-      errors.push(i18n.t("export.validation.requiresKey"));
-    }
-    if (!spec.instructions) {
-      errors.push(i18n.t("export.validation.requiresInstructions"));
-    }
-    for (const tool3 of spec.tools ?? []) {
-      if (!tool3.name) {
-        errors.push(i18n.t("export.validation.toolRequiresName"));
-      }
-      if (tool3.name && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tool3.name)) {
-        errors.push(i18n.t("export.validation.toolInvalidName", { name: tool3.name }));
-      }
-    }
-    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) {
-    const i18n = getDefaultI18n();
-    return spec.tools.map((tool3) => ({
-      name: tool3.name,
-      description: tool3.description ?? i18n.t("tool.fallbackDescription", { name: tool3.name }),
-      schema: tool3.schema ?? { type: "object" },
-      requires_approval: tool3.requiresApproval ?? !tool3.automationSafe
-    }));
-  }
-  generateMarkdown(spec, jsonConfig, options) {
-    const i18n = getDefaultI18n();
-    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 ? ` # ${i18n.t("export.requiresApproval")}` : "";
-        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(i18n.t("export.agentType", { type: jsonConfig.type }));
-    lines.push("");
-    lines.push(this.getAgentTypeDescription(jsonConfig.type));
-    lines.push("");
-    lines.push(i18n.t("export.instructions"));
-    lines.push("");
-    lines.push(spec.instructions);
-    lines.push("");
-    if (spec.tools.length > 0) {
-      lines.push(i18n.t("export.tools"));
-      lines.push("");
-      for (const tool3 of spec.tools) {
-        const approval = tool3.requiresApproval ? ` ${i18n.t("export.requiresApprovalMd")}` : "";
-        const safe = tool3.automationSafe === false ? ` ${i18n.t("export.notAutomationSafeMd")}` : "";
-        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(i18n.t("export.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(i18n.t("export.knowledgeSources"));
-      lines.push("");
-      for (const k of spec.knowledge) {
-        const required = k.required ? i18n.t("export.required") : i18n.t("export.optional");
-        lines.push(`- **${k.key}** ${required}`);
-        if (k.instructions) {
-          lines.push(`  - ${k.instructions}`);
-        }
-      }
-      lines.push("");
-    }
-    if (spec.policy) {
-      lines.push(i18n.t("export.policy"));
-      lines.push("");
-      if (spec.policy.confidence?.min) {
-        lines.push(i18n.t("export.minConfidence", { min: spec.policy.confidence.min }));
-      }
-      if (spec.policy.escalation) {
-        lines.push(i18n.t("export.escalationPolicyConfigured"));
-      }
-      lines.push("");
-    }
-    lines.push(i18n.t("export.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(i18n.t("export.generatedFrom", { key: agentKey(spec.meta) }));
-    lines.push(i18n.t("export.exportedAt", { date: new Date().toISOString() }));
-    return lines.join(`
-`);
-  }
-  getAgentTypeDescription(type) {
-    const i18n = getDefaultI18n();
-    switch (type) {
-      case "build":
-        return i18n.t("export.agentType.build");
-      case "plan":
-        return i18n.t("export.agentType.plan");
-      case "general":
-        return i18n.t("export.agentType.general");
-      case "explore":
-        return i18n.t("export.agentType.explore");
-      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
 init_i18n();
 import { compareVersions } from "compare-versions";
-import { SpecContractRegistry } from "@contractspec/lib.contracts/registry";
+import { SpecContractRegistry } from "@contractspec/lib.contracts-spec/registry";
 
 class AgentRegistry extends SpecContractRegistry {
   constructor(items) {
@@ -4957,750 +2181,9 @@ function createAgentRegistry() {
 
 // src/spec/index.ts
 init_spec();
-// 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();
-init_i18n();
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import * as z4 from "zod";
-function agentToMcpServer(agent, spec2) {
-  const i18n = createAgentI18n();
-  const server = new McpServer({
-    name: spec2.meta.key,
-    version: `${spec2.meta.version}`
-  });
-  server.registerTool(spec2.meta.key, {
-    description: spec2.description ?? i18n.t("tool.mcp.agentDescription", { key: spec2.meta.key }),
-    inputSchema: z4.object({
-      message: z4.string().describe(i18n.t("tool.mcp.param.message")),
-      sessionId: z4.string().optional().describe(i18n.t("tool.mcp.param.sessionId"))
-    })
-  }, 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 ?? i18n.t("tool.mcp.toolDescription", { name: toolConfig.name }),
-      inputSchema
-    }, async (args) => {
-      const result = await agent.generate({
-        prompt: i18n.t("tool.mcp.executePrompt", {
-          name: toolConfig.name,
-          args: 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/knowledge/index.ts
-init_injector();
-// src/telemetry/index.ts
-init_adapter();
-
-// src/providers/registry.ts
-init_types();
-init_i18n();
-
-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, getDefaultI18n().t("error.provider.notRegistered"));
-    }
-    if (!provider.isAvailable()) {
-      throw new ProviderNotAvailableError(name, getDefaultI18n().t("error.provider.depsNotInstalled"));
-    }
-    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
-init_spec();
-init_i18n();
-
-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(getDefaultI18n().t("error.specNotFound", { specKey }));
-    }
-    const i18n = getDefaultI18n();
-    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(i18n.t("interop.md.toc"));
-      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(i18n.t("interop.md.overview"));
-    sections.push("");
-    if (this.includeMetadata) {
-      sections.push(i18n.t("interop.md.metaKey", { key: spec2.meta.key }));
-      sections.push(i18n.t("interop.md.metaVersion", { version: spec2.meta.version }));
-      if (spec2.meta.stability) {
-        sections.push(i18n.t("interop.md.metaStability", {
-          stability: spec2.meta.stability
-        }));
-      }
-      if (spec2.meta.owners && spec2.meta.owners.length > 0) {
-        sections.push(i18n.t("interop.md.metaOwners", {
-          owners: spec2.meta.owners.join(", ")
-        }));
-      }
-      if (spec2.tags && spec2.tags.length > 0) {
-        sections.push(i18n.t("interop.md.metaTags", { tags: spec2.tags.join(", ") }));
-      }
-    }
-    sections.push("");
-    sections.push(i18n.t("interop.prompt.instructions"));
-    sections.push("");
-    sections.push(spec2.instructions);
-    sections.push("");
-    if (opts.includeTools && spec2.tools && spec2.tools.length > 0) {
-      sections.push(i18n.t("interop.md.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(i18n.t("interop.md.schema"));
-          sections.push("");
-          sections.push("```json");
-          sections.push(JSON.stringify(tool3.schema, null, 2));
-          sections.push("```");
-          sections.push("");
-        }
-        if (tool3.automationSafe !== undefined) {
-          sections.push(i18n.t("interop.md.automationSafe", {
-            value: tool3.automationSafe ? i18n.t("interop.md.yes") : i18n.t("interop.md.no")
-          }));
-          sections.push("");
-        }
-      }
-    }
-    if (spec2.knowledge && spec2.knowledge.length > 0) {
-      sections.push(i18n.t("interop.md.knowledge"));
-      sections.push("");
-      for (const k of spec2.knowledge) {
-        const marker = k.required ? ` ${i18n.t("interop.md.required")}` : "";
-        sections.push(`- **${k.key}**${marker}`);
-        if (k.instructions) {
-          sections.push(`  - ${k.instructions}`);
-        }
-      }
-      sections.push("");
-    }
-    if (spec2.policy) {
-      sections.push(i18n.t("interop.md.policy"));
-      sections.push("");
-      if (spec2.policy.confidence) {
-        sections.push(i18n.t("interop.md.minConfidence", {
-          min: spec2.policy.confidence.min ?? 0.7
-        }));
-      }
-      if (spec2.policy.escalation) {
-        const esc = spec2.policy.escalation;
-        if (esc.confidenceThreshold) {
-          sections.push(i18n.t("interop.md.escalationThreshold", {
-            threshold: esc.confidenceThreshold
-          }));
-        }
-        if (esc.onToolFailure) {
-          sections.push(i18n.t("interop.md.escalateToolFailure"));
-        }
-        if (esc.onTimeout) {
-          sections.push(i18n.t("interop.md.escalateTimeout"));
-        }
-      }
-      sections.push("");
-    }
-    return sections.join(`
-`);
-  }
-  getSpecPrompt(specKey, options) {
-    const spec2 = this.specs.get(specKey);
-    if (!spec2) {
-      throw new Error(getDefaultI18n().t("error.specNotFound", { specKey }));
-    }
-    const i18n = getDefaultI18n();
-    const sections = [];
-    const opts = {
-      includeTools: options?.includeTools ?? true,
-      format: options?.format ?? "structured",
-      ...options
-    };
-    sections.push(i18n.t("interop.prompt.agentIdentity"));
-    sections.push("");
-    sections.push(i18n.t("interop.prompt.youAre", {
-      key: spec2.meta.key,
-      version: spec2.meta.version
-    }));
-    sections.push("");
-    if (spec2.description) {
-      sections.push(i18n.t("interop.prompt.description"));
-      sections.push("");
-      sections.push(spec2.description);
-      sections.push("");
-    }
-    sections.push(i18n.t("interop.prompt.instructions"));
-    sections.push("");
-    sections.push(spec2.instructions);
-    sections.push("");
-    if (opts.includeTools && spec2.tools && spec2.tools.length > 0) {
-      sections.push(i18n.t("interop.prompt.availableTools"));
-      sections.push("");
-      sections.push(i18n.t("interop.prompt.toolsIntro"));
-      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(i18n.t("interop.prompt.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(i18n.t("interop.prompt.knowledgeContext"));
-        sections.push("");
-        for (const k of requiredKnowledge) {
-          if (k.instructions) {
-            sections.push(k.instructions);
-            sections.push("");
-          }
-        }
-      }
-    }
-    if (options?.customContext) {
-      sections.push(i18n.t("interop.prompt.additionalContext"));
-      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
-init_tool_bridge();
-init_tool_bridge2();
-init_i18n();
-
-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(getDefaultI18n().t("log.mcpServer.started", {
-      name: this.name,
-      version: this.version,
-      count: this.tools.size
-    }));
-  }
-  async stop() {
-    if (!this.running) {
-      return;
-    }
-    this.running = false;
-    console.log(getDefaultI18n().t("log.mcpServer.stopped", { name: 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(getDefaultI18n().t("error.toolNotFound", { name: toolName }));
-    }
-    if (!tool3.handler) {
-      throw new Error(getDefaultI18n().t("error.noHandlerForTool", { name: 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(getDefaultI18n().t("error.unknownExportFormat", { 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(getDefaultI18n().t("error.toolNotFound", { name }));
-    }
-    if (!tool3.handler) {
-      throw new Error(getDefaultI18n().t("error.noToolHandler", { 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
-init_i18n();
-import { Experimental_Agent } from "ai";
 export {
-  zodToOutput,
-  validateForOpenCode,
-  validateForClaudeAgent,
-  trackAgentStep,
-  textOutput,
-  specToolsToAISDKTools,
-  specToolToAISDKTool,
-  resolveLocale,
-  resetI18nRegistry,
-  noopTelemetryCollector,
-  mcpServerToTools,
-  jsonSchemaToZodSafe,
-  jsonSchemaToZod,
-  jsonSchemaToOutput,
-  jsonSchemaToArrayOutput,
-  isSupportedLocale,
-  injectStaticKnowledge,
-  getDefaultI18n,
-  getAvailableBackends,
-  generateSessionId,
-  generateOpenCodeMarkdown,
-  generateOpenCodeJSON,
-  generateClaudeMd,
-  frMessages,
-  exportToolsForExternalSDK,
-  exportToOpenCode,
-  exportToClaudeAgent,
-  esMessages,
-  enumToChoiceOutput,
-  enMessages,
   defineAgent,
-  defaultProviderRegistry,
-  createUnifiedAgent,
-  createToolServer,
-  createToolHandler,
-  createToolConsumer,
-  createSpecConsumer,
-  createSingleSpecConsumer,
-  createProviderRegistry,
-  createPostHogTracedModel,
-  createPostHogTelemetryCollector,
-  createOpenCodeSDKAgent,
-  createMcpToolsets,
-  createKnowledgeQueryTool,
-  createKnowledgeInjector,
-  createInMemoryTelemetryCollector,
-  createInMemorySessionStore,
-  createCompositeTelemetryCollector,
-  createClaudeAgentSDKAgent,
-  createApprovalWorkflow,
   createAgentRegistry,
-  createAgentMcpServer,
-  createAgentJsonRunner,
-  createAgentI18n,
-  createAISDKAgent,
-  buildToolHandlers,
-  agentToMcpServer,
   agentKey,
-  UnifiedAgent,
-  Experimental_Agent as ToolLoopAgent,
-  TOOL_KEYS,
-  SchemaOutput,
-  SUPPORTED_LOCALES,
-  ProviderNotAvailableError,
-  ProviderExecutionError,
-  PostHogTelemetryCollector,
-  OpenCodeSDKProvider,
-  OpenCodeExporter,
-  LOG_KEYS,
-  KNOWLEDGE_KEYS,
-  InMemoryTelemetryCollector,
-  InMemorySessionStore,
-  InMemoryApprovalStore,
-  INTEROP_KEYS,
-  I18N_KEYS,
-  ExternalProviderError,
-  EXPORT_KEYS,
-  ERROR_KEYS,
-  DEFAULT_LOCALE,
-  ContractSpecToolConsumer,
-  ContractSpecConsumer,
-  ContractSpecAgent,
-  ContextCreationError,
-  CompositeTelemetryCollector,
-  ClaudeAgentSDKProvider,
-  ClaudeAgentExporter,
-  ApprovalWorkflow,
-  AgentRegistry,
-  APPROVAL_KEYS,
-  AGENT_KEYS
+  AgentRegistry
 };