@hanzo/playground 0.1.41-rc.101

package/dist/index.js

@@ -0,0 +1,2690 @@
+import express from 'express';
+import crypto, { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+import { generateObject, generateText, streamText, embed, embedMany } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createMistral } from '@ai-sdk/mistral';
+import { createGroq } from '@ai-sdk/groq';
+import { createXai } from '@ai-sdk/xai';
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { createCohere } from '@ai-sdk/cohere';
+import os from 'os';
+import axios, { isAxiosError } from 'axios';
+import http from 'http';
+import https from 'https';
+import WebSocket from 'ws';
+import { Buffer } from 'buffer';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+
+// src/agent/Bot.ts
+
+// src/agent/BotRegistry.ts
+var BotRegistry = class {
+  bots = /* @__PURE__ */ new Map();
+  register(name, handler, options) {
+    this.bots.set(name, { name, handler, options });
+  }
+  includeRouter(router) {
+    router.bots.forEach((bot) => {
+      this.bots.set(bot.name, bot);
+    });
+  }
+  get(name) {
+    return this.bots.get(name);
+  }
+  all() {
+    return Array.from(this.bots.values());
+  }
+};
+
+// src/agent/SkillRegistry.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(name, handler, options) {
+    this.skills.set(name, { name, handler, options });
+  }
+  includeRouter(router) {
+    router.skills.forEach((skill) => {
+      this.skills.set(skill.name, skill);
+    });
+  }
+  get(name) {
+    return this.skills.get(name);
+  }
+  all() {
+    return Array.from(this.skills.values());
+  }
+};
+var store = new AsyncLocalStorage();
+var ExecutionContext = class {
+  input;
+  metadata;
+  req;
+  res;
+  agent;
+  constructor(params) {
+    this.input = params.input;
+    this.metadata = params.metadata;
+    this.req = params.req;
+    this.res = params.res;
+    this.agent = params.agent;
+  }
+  static run(ctx, fn) {
+    return store.run(ctx, fn);
+  }
+  static getCurrent() {
+    return store.getStore();
+  }
+};
+
+// src/context/BotContext.ts
+var BotContext = class {
+  input;
+  executionId;
+  runId;
+  sessionId;
+  actorId;
+  workflowId;
+  parentExecutionId;
+  callerDid;
+  targetDid;
+  agentNodeDid;
+  req;
+  res;
+  agent;
+  aiClient;
+  memory;
+  workflow;
+  did;
+  constructor(params) {
+    this.input = params.input;
+    this.executionId = params.executionId;
+    this.runId = params.runId;
+    this.sessionId = params.sessionId;
+    this.actorId = params.actorId;
+    this.workflowId = params.workflowId;
+    this.parentExecutionId = params.parentExecutionId;
+    this.callerDid = params.callerDid;
+    this.targetDid = params.targetDid;
+    this.agentNodeDid = params.agentNodeDid;
+    this.req = params.req;
+    this.res = params.res;
+    this.agent = params.agent;
+    this.aiClient = params.aiClient;
+    this.memory = params.memory;
+    this.workflow = params.workflow;
+    this.did = params.did;
+  }
+  ai(prompt, options) {
+    return this.aiClient.generate(prompt, options);
+  }
+  aiStream(prompt, options) {
+    return this.aiClient.stream(prompt, options);
+  }
+  call(target, input) {
+    return this.agent.call(target, input);
+  }
+  discover(options) {
+    return this.agent.discover(options);
+  }
+  note(message, tags = []) {
+    this.agent.note(message, tags, {
+      executionId: this.executionId,
+      runId: this.runId,
+      sessionId: this.sessionId,
+      actorId: this.actorId,
+      workflowId: this.workflowId,
+      parentExecutionId: this.parentExecutionId,
+      callerDid: this.callerDid,
+      targetDid: this.targetDid,
+      agentNodeDid: this.agentNodeDid
+    });
+  }
+};
+function getCurrentContext() {
+  const execution = ExecutionContext.getCurrent();
+  if (!execution) return void 0;
+  const { metadata, input, agent, req, res } = execution;
+  return new BotContext({
+    input,
+    executionId: metadata.executionId,
+    runId: metadata.runId,
+    sessionId: metadata.sessionId,
+    actorId: metadata.actorId,
+    workflowId: metadata.workflowId,
+    parentExecutionId: metadata.parentExecutionId,
+    callerDid: metadata.callerDid,
+    targetDid: metadata.targetDid,
+    agentNodeDid: metadata.agentNodeDid,
+    req,
+    res,
+    agent,
+    aiClient: agent.getAIClient(),
+    memory: agent.getMemoryInterface(metadata),
+    workflow: agent.getWorkflowReporter(metadata),
+    did: agent.getDidInterface(metadata, input)
+  });
+}
+
+// src/context/SkillContext.ts
+var SkillContext = class {
+  input;
+  executionId;
+  sessionId;
+  workflowId;
+  callerDid;
+  agentNodeDid;
+  req;
+  res;
+  agent;
+  memory;
+  workflow;
+  did;
+  constructor(params) {
+    this.input = params.input;
+    this.executionId = params.executionId;
+    this.sessionId = params.sessionId;
+    this.workflowId = params.workflowId;
+    this.callerDid = params.callerDid;
+    this.agentNodeDid = params.agentNodeDid;
+    this.req = params.req;
+    this.res = params.res;
+    this.agent = params.agent;
+    this.memory = params.memory;
+    this.workflow = params.workflow;
+    this.did = params.did;
+  }
+  discover(options) {
+    return this.agent.discover(options);
+  }
+};
+function getCurrentSkillContext() {
+  const execution = ExecutionContext.getCurrent();
+  if (!execution) return void 0;
+  const { metadata, input, agent, req, res } = execution;
+  return new SkillContext({
+    input,
+    executionId: metadata.executionId,
+    sessionId: metadata.sessionId,
+    workflowId: metadata.workflowId,
+    callerDid: metadata.callerDid,
+    agentNodeDid: metadata.agentNodeDid,
+    req,
+    res,
+    agent,
+    memory: agent.getMemoryInterface(metadata),
+    workflow: agent.getWorkflowReporter(metadata),
+    did: agent.getDidInterface(metadata, input)
+  });
+}
+var RateLimitError = class extends Error {
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var StatelessRateLimiter = class {
+  maxRetries;
+  baseDelay;
+  maxDelay;
+  jitterFactor;
+  circuitBreakerThreshold;
+  circuitBreakerTimeout;
+  _containerSeed;
+  _consecutiveFailures = 0;
+  _circuitOpenTime;
+  constructor(options = {}) {
+    this.maxRetries = options.maxRetries ?? 20;
+    this.baseDelay = options.baseDelay ?? 1;
+    this.maxDelay = options.maxDelay ?? 300;
+    this.jitterFactor = options.jitterFactor ?? 0.25;
+    this.circuitBreakerThreshold = options.circuitBreakerThreshold ?? 10;
+    this.circuitBreakerTimeout = options.circuitBreakerTimeout ?? 300;
+    this._containerSeed = this._getContainerSeed();
+  }
+  _getContainerSeed() {
+    const identifier = `${os.hostname()}-${process.pid}`;
+    const hash = crypto.createHash("md5").update(identifier).digest("hex");
+    return parseInt(hash.slice(0, 8), 16);
+  }
+  _isRateLimitError(error) {
+    if (!error) return false;
+    const err = error;
+    const className = err?.constructor?.name;
+    if (className && className.includes("RateLimitError")) {
+      return true;
+    }
+    const response = err?.response;
+    const statusCandidates = [
+      err?.status,
+      err?.statusCode,
+      response?.status,
+      response?.statusCode,
+      response?.status_code
+    ];
+    if (statusCandidates.some((code) => code === 429 || code === 503)) {
+      return true;
+    }
+    const message = String(err?.message ?? err ?? "").toLowerCase();
+    const rateLimitKeywords = [
+      "rate limit",
+      "rate-limit",
+      "rate_limit",
+      "too many requests",
+      "quota exceeded",
+      "temporarily rate-limited",
+      "rate limited",
+      "requests per",
+      "rpm exceeded",
+      "tpm exceeded",
+      "usage limit",
+      "throttled",
+      "throttling"
+    ];
+    return rateLimitKeywords.some((keyword) => message.includes(keyword));
+  }
+  _extractRetryAfter(error) {
+    if (!error) return void 0;
+    const err = error;
+    const headers = err?.response?.headers ?? err?.response?.Headers ?? err?.response?.header;
+    if (headers && typeof headers === "object") {
+      const retryAfterKey = Object.keys(headers).find((k) => k.toLowerCase() === "retry-after");
+      if (retryAfterKey) {
+        const value = Array.isArray(headers[retryAfterKey]) ? headers[retryAfterKey][0] : headers[retryAfterKey];
+        const parsed2 = parseFloat(value);
+        if (!Number.isNaN(parsed2)) {
+          return parsed2;
+        }
+      }
+    }
+    const retryAfter = err?.retryAfter ?? err?.retry_after;
+    const parsed = parseFloat(retryAfter);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+    return void 0;
+  }
+  _createJitterRng(seed) {
+    let x = seed >>> 0;
+    return () => {
+      x = (1664525 * x + 1013904223) % 4294967296;
+      return x / 4294967296;
+    };
+  }
+  _calculateBackoffDelay(attempt, retryAfter) {
+    let baseDelay;
+    if (retryAfter && retryAfter <= this.maxDelay) {
+      baseDelay = retryAfter;
+    } else {
+      baseDelay = Math.min(this.baseDelay * 2 ** attempt, this.maxDelay);
+    }
+    const jitterRange = baseDelay * this.jitterFactor;
+    const rng = this._createJitterRng(this._containerSeed + attempt);
+    const jitter = (rng() * 2 - 1) * jitterRange;
+    const delay = Math.max(0.1, baseDelay + jitter);
+    return delay;
+  }
+  _checkCircuitBreaker() {
+    if (this._circuitOpenTime === void 0) {
+      return false;
+    }
+    if (this._now() - this._circuitOpenTime > this.circuitBreakerTimeout) {
+      this._circuitOpenTime = void 0;
+      this._consecutiveFailures = 0;
+      return false;
+    }
+    return true;
+  }
+  _updateCircuitBreaker(success) {
+    if (success) {
+      this._consecutiveFailures = 0;
+      this._circuitOpenTime = void 0;
+      return;
+    }
+    this._consecutiveFailures += 1;
+    if (this._consecutiveFailures >= this.circuitBreakerThreshold && this._circuitOpenTime === void 0) {
+      this._circuitOpenTime = this._now();
+    }
+  }
+  async _sleep(delaySeconds) {
+    await new Promise((resolve) => setTimeout(resolve, delaySeconds * 1e3));
+  }
+  _now() {
+    return Date.now() / 1e3;
+  }
+  async executeWithRetry(fn) {
+    if (this._checkCircuitBreaker()) {
+      throw new RateLimitError(
+        `Circuit breaker is open. Too many consecutive rate limit failures. Will retry after ${this.circuitBreakerTimeout} seconds.`
+      );
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+      try {
+        const result = await fn();
+        this._updateCircuitBreaker(true);
+        return result;
+      } catch (error) {
+        lastError = error;
+        if (!this._isRateLimitError(error)) {
+          throw error;
+        }
+        this._updateCircuitBreaker(false);
+        if (attempt >= this.maxRetries) {
+          break;
+        }
+        const retryAfter = this._extractRetryAfter(error);
+        const delay = this._calculateBackoffDelay(attempt, retryAfter);
+        await this._sleep(delay);
+      }
+    }
+    throw new RateLimitError(
+      `Rate limit retries exhausted after ${this.maxRetries} attempts. Last error: ${String(lastError)}`,
+      this._extractRetryAfter(lastError)
+    );
+  }
+};
+
+// src/ai/AIClient.ts
+function repairJsonText(text) {
+  let cleaned = text.trim();
+  const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (codeBlockMatch) {
+    cleaned = codeBlockMatch[1].trim();
+  }
+  const jsonMatch = cleaned.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  if (jsonMatch) {
+    cleaned = jsonMatch[1];
+  }
+  cleaned = cleaned.replace(/,(\s*[}\]])/g, "$1");
+  try {
+    JSON.parse(cleaned);
+    return cleaned;
+  } catch {
+    return null;
+  }
+}
+var AIClient = class {
+  config;
+  rateLimiter;
+  constructor(config = {}) {
+    this.config = {
+      enableRateLimitRetry: true,
+      rateLimitMaxRetries: 20,
+      rateLimitBaseDelay: 1,
+      rateLimitMaxDelay: 300,
+      rateLimitJitterFactor: 0.25,
+      rateLimitCircuitBreakerThreshold: 10,
+      rateLimitCircuitBreakerTimeout: 300,
+      ...config
+    };
+  }
+  async generate(prompt, options = {}) {
+    const model = this.buildModel(options);
+    if (options.schema) {
+      const schema = options.schema;
+      const mode = options.mode ?? "json";
+      const call2 = async () => generateObject({
+        model,
+        prompt,
+        output: "object",
+        mode,
+        system: options.system,
+        temperature: options.temperature ?? this.config.temperature,
+        maxOutputTokens: options.maxTokens ?? this.config.maxTokens,
+        schema,
+        experimental_repairText: async ({ text }) => repairJsonText(text)
+      });
+      const response2 = await this.withRateLimitRetry(call2);
+      return response2.object;
+    }
+    const call = async () => generateText({
+      model,
+      prompt,
+      system: options.system,
+      temperature: options.temperature ?? this.config.temperature,
+      maxOutputTokens: options.maxTokens ?? this.config.maxTokens
+    });
+    const response = await this.withRateLimitRetry(call);
+    return response.text;
+  }
+  async stream(prompt, options = {}) {
+    const model = this.buildModel(options);
+    const streamResult = streamText({
+      model,
+      prompt,
+      system: options.system,
+      temperature: options.temperature ?? this.config.temperature,
+      maxOutputTokens: options.maxTokens ?? this.config.maxTokens
+    });
+    return streamResult.textStream;
+  }
+  async embed(value, options = {}) {
+    const model = this.buildEmbeddingModel(options);
+    const result = await this.withRateLimitRetry(
+      () => embed({
+        model,
+        value
+      })
+    );
+    return result.embedding;
+  }
+  async embedMany(values, options = {}) {
+    const model = this.buildEmbeddingModel(options);
+    const result = await this.withRateLimitRetry(
+      () => embedMany({
+        model,
+        values
+      })
+    );
+    return result.embeddings;
+  }
+  buildModel(options) {
+    const provider = options.provider ?? this.config.provider ?? "openai";
+    const modelName = options.model ?? this.config.model ?? "gpt-4o";
+    switch (provider) {
+      case "anthropic": {
+        const anthropic = createAnthropic({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return anthropic(modelName);
+      }
+      case "google": {
+        const google = createGoogleGenerativeAI({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return google(modelName);
+      }
+      case "mistral": {
+        const mistral = createMistral({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return mistral(modelName);
+      }
+      case "groq": {
+        const groq = createGroq({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return groq(modelName);
+      }
+      case "xai": {
+        const xai = createXai({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return xai(modelName);
+      }
+      case "deepseek": {
+        const deepseek = createDeepSeek({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return deepseek(modelName);
+      }
+      case "cohere": {
+        const cohere = createCohere({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return cohere(modelName);
+      }
+      case "openrouter": {
+        const openrouter = createOpenAI({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl ?? "https://openrouter.ai/api/v1"
+        });
+        return openrouter(modelName);
+      }
+      case "ollama": {
+        const ollama = createOpenAI({
+          apiKey: this.config.apiKey ?? "ollama",
+          // Ollama doesn't need real key
+          baseURL: this.config.baseUrl ?? "http://localhost:11434/v1"
+        });
+        return ollama(modelName);
+      }
+      case "openai":
+      default: {
+        const openai = createOpenAI({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return openai(modelName);
+      }
+    }
+  }
+  buildEmbeddingModel(options) {
+    const provider = options.provider ?? this.config.provider ?? "openai";
+    const modelName = options.model ?? this.config.embeddingModel ?? "text-embedding-3-small";
+    const noEmbeddingProviders = ["anthropic", "xai", "deepseek", "groq"];
+    if (noEmbeddingProviders.includes(provider)) {
+      throw new Error(`Embedding generation is not supported for ${provider} provider`);
+    }
+    switch (provider) {
+      case "google": {
+        const google = createGoogleGenerativeAI({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return google.textEmbeddingModel(modelName);
+      }
+      case "mistral": {
+        const mistral = createMistral({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return mistral.textEmbeddingModel(modelName);
+      }
+      case "cohere": {
+        const cohere = createCohere({
+          apiKey: this.config.apiKey,
+          baseURL: this.config.baseUrl
+        });
+        return cohere.textEmbeddingModel(modelName);
+      }
+      case "openai":
+      case "openrouter":
+      case "ollama":
+      default: {
+        const openai = createOpenAI({
+          apiKey: this.config.apiKey ?? (provider === "ollama" ? "ollama" : void 0),
+          baseURL: this.config.baseUrl ?? (provider === "openrouter" ? "https://openrouter.ai/api/v1" : provider === "ollama" ? "http://localhost:11434/v1" : void 0)
+        });
+        return openai.embedding(modelName);
+      }
+    }
+  }
+  getRateLimiter() {
+    if (!this.rateLimiter) {
+      this.rateLimiter = new StatelessRateLimiter({
+        maxRetries: this.config.rateLimitMaxRetries,
+        baseDelay: this.config.rateLimitBaseDelay,
+        maxDelay: this.config.rateLimitMaxDelay,
+        jitterFactor: this.config.rateLimitJitterFactor,
+        circuitBreakerThreshold: this.config.rateLimitCircuitBreakerThreshold,
+        circuitBreakerTimeout: this.config.rateLimitCircuitBreakerTimeout
+      });
+    }
+    return this.rateLimiter;
+  }
+  withRateLimitRetry(fn) {
+    if (this.config.enableRateLimitRetry === false) {
+      return fn();
+    }
+    return this.getRateLimiter().executeWithRetry(fn);
+  }
+};
+var httpAgent = new http.Agent({
+  keepAlive: true,
+  maxSockets: 10,
+  maxTotalSockets: 50,
+  maxFreeSockets: 5
+});
+var httpsAgent = new https.Agent({
+  keepAlive: true,
+  maxSockets: 10,
+  maxTotalSockets: 50,
+  maxFreeSockets: 5
+});
+
+// src/client/PlaygroundClient.ts
+var PlaygroundClient = class {
+  http;
+  config;
+  defaultHeaders;
+  constructor(config) {
+    const baseURL = (config.playgroundUrl ?? "http://localhost:8080").replace(/\/$/, "");
+    this.http = axios.create({
+      baseURL,
+      timeout: 3e4,
+      httpAgent,
+      httpsAgent
+    });
+    this.config = config;
+    const mergedHeaders = { ...config.defaultHeaders ?? {} };
+    if (config.apiKey) {
+      mergedHeaders["X-API-Key"] = config.apiKey;
+    }
+    this.defaultHeaders = this.sanitizeHeaders(mergedHeaders);
+  }
+  async register(payload) {
+    await this.http.post("/api/v1/nodes/register", payload, { headers: this.mergeHeaders() });
+  }
+  async heartbeat(status = "ready") {
+    const nodeId = this.config.nodeId;
+    const res = await this.http.post(
+      `/api/v1/nodes/${nodeId}/heartbeat`,
+      {
+        status,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      { headers: this.mergeHeaders() }
+    );
+    return res.data;
+  }
+  async execute(target, input, metadata) {
+    const headers = {};
+    if (metadata?.runId) headers["X-Run-ID"] = metadata.runId;
+    if (metadata?.workflowId) headers["X-Workflow-ID"] = metadata.workflowId;
+    if (metadata?.parentExecutionId) headers["X-Parent-Execution-ID"] = metadata.parentExecutionId;
+    if (metadata?.sessionId) headers["X-Session-ID"] = metadata.sessionId;
+    if (metadata?.actorId) headers["X-Actor-ID"] = metadata.actorId;
+    if (metadata?.callerDid) headers["X-Caller-DID"] = metadata.callerDid;
+    if (metadata?.targetDid) headers["X-Target-DID"] = metadata.targetDid;
+    if (metadata?.agentNodeDid) headers["X-Agent-Node-DID"] = metadata.agentNodeDid;
+    if (metadata?.agentNodeId) headers["X-Agent-Node-ID"] = metadata.agentNodeId;
+    const res = await this.http.post(
+      `/api/v1/execute/${target}`,
+      {
+        input
+      },
+      { headers: this.mergeHeaders(headers) }
+    );
+    return res.data?.result ?? res.data;
+  }
+  async publishWorkflowEvent(event) {
+    const payload = {
+      execution_id: event.executionId,
+      workflow_id: event.workflowId ?? event.runId,
+      run_id: event.runId,
+      bot_id: event.botId,
+      type: event.botId,
+      agent_node_id: event.agentNodeId,
+      status: event.status,
+      parent_execution_id: event.parentExecutionId,
+      parent_workflow_id: event.parentWorkflowId ?? event.workflowId ?? event.runId,
+      input_data: event.inputData ?? {},
+      result: event.result,
+      error: event.error,
+      duration_ms: event.durationMs
+    };
+    this.http.post("/api/v1/workflow/executions/events", payload, {
+      headers: this.mergeHeaders(),
+      timeout: this.config.devMode ? 1e3 : void 0
+    }).catch(() => {
+    });
+  }
+  async updateExecutionStatus(executionId, update) {
+    if (!executionId) {
+      throw new Error("executionId is required to update workflow status");
+    }
+    const payload = {
+      status: update.status ?? "running",
+      result: update.result,
+      error: update.error,
+      duration_ms: update.durationMs,
+      progress: update.progress !== void 0 ? Math.round(update.progress) : void 0
+    };
+    await this.http.post(`/api/v1/executions/${executionId}/status`, payload, { headers: this.mergeHeaders() });
+  }
+  async discoverCapabilities(options = {}) {
+    const format = (options.format ?? "json").toLowerCase();
+    const params = { format };
+    const dedupe = (values) => Array.from(new Set((values ?? []).filter(Boolean))).map((v) => v);
+    const combinedAgents = dedupe([
+      ...options.agent ? [options.agent] : [],
+      ...options.nodeId ? [options.nodeId] : [],
+      ...options.agentIds ?? [],
+      ...options.nodeIds ?? []
+    ]);
+    if (combinedAgents.length === 1) {
+      params.agent = combinedAgents[0];
+    } else if (combinedAgents.length > 1) {
+      params.agent_ids = combinedAgents.join(",");
+    }
+    if (options.bot) params.bot = options.bot;
+    if (options.skill) params.skill = options.skill;
+    if (options.tags?.length) params.tags = dedupe(options.tags).join(",");
+    if (options.includeInputSchema !== void 0) {
+      params.include_input_schema = String(Boolean(options.includeInputSchema));
+    }
+    if (options.includeOutputSchema !== void 0) {
+      params.include_output_schema = String(Boolean(options.includeOutputSchema));
+    }
+    if (options.includeDescriptions !== void 0) {
+      params.include_descriptions = String(Boolean(options.includeDescriptions));
+    }
+    if (options.includeExamples !== void 0) {
+      params.include_examples = String(Boolean(options.includeExamples));
+    }
+    if (options.healthStatus) params.health_status = options.healthStatus.toLowerCase();
+    if (options.limit !== void 0) params.limit = String(options.limit);
+    if (options.offset !== void 0) params.offset = String(options.offset);
+    const res = await this.http.get("/api/v1/discovery/capabilities", {
+      params,
+      headers: this.mergeHeaders({
+        ...options.headers ?? {},
+        Accept: format === "xml" ? "application/xml" : "application/json"
+      }),
+      responseType: format === "xml" ? "text" : "json",
+      transformResponse: (data) => data
+      // preserve raw body for xml
+    });
+    const raw = typeof res.data === "string" ? res.data : JSON.stringify(res.data);
+    if (format === "xml") {
+      return { format: "xml", raw, xml: raw };
+    }
+    const parsed = typeof res.data === "string" ? JSON.parse(res.data) : res.data;
+    if (format === "compact") {
+      return {
+        format: "compact",
+        raw,
+        compact: this.mapCompactDiscovery(parsed)
+      };
+    }
+    return {
+      format: "json",
+      raw,
+      json: this.mapDiscoveryResponse(parsed)
+    };
+  }
+  mapDiscoveryResponse(payload) {
+    return {
+      discoveredAt: String(payload?.discovered_at ?? ""),
+      totalAgents: Number(payload?.total_agents ?? 0),
+      totalBots: Number(payload?.total_bots ?? 0),
+      totalSkills: Number(payload?.total_skills ?? 0),
+      pagination: {
+        limit: Number(payload?.pagination?.limit ?? 0),
+        offset: Number(payload?.pagination?.offset ?? 0),
+        hasMore: Boolean(payload?.pagination?.has_more)
+      },
+      capabilities: (payload?.capabilities ?? []).map((cap) => ({
+        agentId: cap?.agent_id ?? "",
+        baseUrl: cap?.base_url ?? "",
+        version: cap?.version ?? "",
+        healthStatus: cap?.health_status ?? "",
+        deploymentType: cap?.deployment_type,
+        lastHeartbeat: cap?.last_heartbeat,
+        bots: (cap?.bots ?? []).map((r) => ({
+          id: r?.id ?? "",
+          description: r?.description,
+          tags: r?.tags ?? [],
+          inputSchema: r?.input_schema,
+          outputSchema: r?.output_schema,
+          examples: r?.examples,
+          invocationTarget: r?.invocation_target ?? ""
+        })),
+        skills: (cap?.skills ?? []).map((s) => ({
+          id: s?.id ?? "",
+          description: s?.description,
+          tags: s?.tags ?? [],
+          inputSchema: s?.input_schema,
+          invocationTarget: s?.invocation_target ?? ""
+        }))
+      }))
+    };
+  }
+  mapCompactDiscovery(payload) {
+    const toCap = (cap) => ({
+      id: cap?.id ?? "",
+      agentId: cap?.agent_id ?? "",
+      target: cap?.target ?? "",
+      tags: cap?.tags ?? []
+    });
+    return {
+      discoveredAt: String(payload?.discovered_at ?? ""),
+      bots: (payload?.bots ?? []).map(toCap),
+      skills: (payload?.skills ?? []).map(toCap)
+    };
+  }
+  sanitizeHeaders(headers) {
+    const sanitized = {};
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) return;
+      sanitized[key] = typeof value === "string" ? value : String(value);
+    });
+    return sanitized;
+  }
+  mergeHeaders(headers) {
+    return {
+      ...this.defaultHeaders,
+      ...this.sanitizeHeaders(headers ?? {})
+    };
+  }
+  buildExecutionHeaders(metadata) {
+    const headers = {};
+    if (metadata.runId) headers["x-run-id"] = metadata.runId;
+    if (metadata.executionId) headers["x-execution-id"] = metadata.executionId;
+    if (metadata.sessionId) headers["x-session-id"] = metadata.sessionId;
+    if (metadata.actorId) headers["x-actor-id"] = metadata.actorId;
+    if (metadata.workflowId) headers["x-workflow-id"] = metadata.workflowId;
+    if (metadata.parentExecutionId) headers["x-parent-execution-id"] = metadata.parentExecutionId;
+    if (metadata.callerDid) headers["x-caller-did"] = metadata.callerDid;
+    if (metadata.targetDid) headers["x-target-did"] = metadata.targetDid;
+    if (metadata.agentNodeDid) headers["x-agent-node-did"] = metadata.agentNodeDid;
+    if (metadata.agentNodeId) headers["x-agent-node-id"] = metadata.agentNodeId;
+    return headers;
+  }
+  sendNote(message, tags, agentNodeId, metadata, uiApiBaseUrl, devMode) {
+    const payload = {
+      message,
+      tags: tags ?? [],
+      timestamp: Date.now() / 1e3,
+      agent_node_id: agentNodeId
+    };
+    const executionHeaders = this.buildExecutionHeaders({ ...metadata, agentNodeId });
+    const headers = this.mergeHeaders({
+      "content-type": "application/json",
+      ...executionHeaders
+    });
+    axios.post(`${uiApiBaseUrl}/executions/note`, payload, {
+      headers,
+      timeout: devMode ? 5e3 : 1e4,
+      httpAgent,
+      httpsAgent
+    }).catch(() => {
+    });
+  }
+};
+var MemoryClient = class {
+  http;
+  defaultHeaders;
+  constructor(baseUrl, defaultHeaders) {
+    this.http = axios.create({
+      baseURL: baseUrl.replace(/\/$/, ""),
+      timeout: 3e4,
+      httpAgent,
+      httpsAgent
+    });
+    this.defaultHeaders = this.sanitizeHeaders(defaultHeaders ?? {});
+  }
+  async set(key, data, options = {}) {
+    const payload = { key, data };
+    if (options.scope) payload.scope = options.scope;
+    await this.http.post("/api/v1/memory/set", payload, {
+      headers: this.buildHeaders(options)
+    });
+  }
+  async get(key, options = {}) {
+    try {
+      const payload = { key };
+      if (options.scope) payload.scope = options.scope;
+      const res = await this.http.post("/api/v1/memory/get", payload, {
+        headers: this.buildHeaders(options)
+      });
+      return res.data?.data;
+    } catch (err) {
+      if (isAxiosError(err) && err.response?.status === 404) {
+        return void 0;
+      }
+      throw err;
+    }
+  }
+  async delete(key, options = {}) {
+    const payload = { key };
+    if (options.scope) payload.scope = options.scope;
+    await this.http.post("/api/v1/memory/delete", payload, {
+      headers: this.buildHeaders(options)
+    });
+  }
+  async listKeys(scope, options = {}) {
+    const res = await this.http.get("/api/v1/memory/list", {
+      params: { scope },
+      headers: this.buildHeaders({ ...options, scope })
+    });
+    return (res.data ?? []).map((item) => item?.key).filter(Boolean);
+  }
+  async exists(key, options = {}) {
+    const value = await this.get(key, options);
+    return value !== void 0;
+  }
+  async setVector(key, embedding, metadata, options = {}) {
+    const payload = {
+      key,
+      embedding
+    };
+    if (metadata !== void 0) payload.metadata = metadata;
+    if (options.scope) payload.scope = options.scope;
+    await this.http.post("/api/v1/memory/vector/set", payload, {
+      headers: this.buildHeaders(options)
+    });
+  }
+  async deleteVector(key, options = {}) {
+    const payload = { key };
+    if (options.scope) payload.scope = options.scope;
+    await this.http.post("/api/v1/memory/vector/delete", payload, {
+      headers: this.buildHeaders(options)
+    });
+  }
+  async searchVector(queryEmbedding, options = {}) {
+    const payload = {
+      query_embedding: queryEmbedding,
+      top_k: options.topK ?? 10
+    };
+    if (options.filters) payload.filters = options.filters;
+    if (options.scope) payload.scope = options.scope;
+    const res = await this.http.post("/api/v1/memory/vector/search", payload, {
+      headers: this.buildHeaders(options)
+    });
+    return res.data ?? [];
+  }
+  buildHeaders(options = {}) {
+    const { scope, scopeId, metadata } = options;
+    const headers = { ...this.defaultHeaders };
+    const workflowId = metadata?.workflowId ?? metadata?.runId;
+    if (workflowId) headers["X-Workflow-ID"] = workflowId;
+    if (metadata?.sessionId) headers["X-Session-ID"] = metadata.sessionId;
+    if (metadata?.actorId) headers["X-Actor-ID"] = metadata.actorId;
+    if (metadata?.runId) headers["X-Run-ID"] = metadata.runId;
+    if (metadata?.executionId) headers["X-Execution-ID"] = metadata.executionId;
+    if (metadata?.parentExecutionId) headers["X-Parent-Execution-ID"] = metadata.parentExecutionId;
+    if (metadata?.callerDid) headers["X-Caller-DID"] = metadata.callerDid;
+    if (metadata?.targetDid) headers["X-Target-DID"] = metadata.targetDid;
+    if (metadata?.agentNodeDid) headers["X-Agent-Node-DID"] = metadata.agentNodeDid;
+    if (metadata?.agentNodeId) headers["X-Agent-Node-ID"] = metadata.agentNodeId;
+    const headerName = this.scopeToHeader(scope);
+    const resolvedScopeId = this.resolveScopeId(scope, scopeId, metadata);
+    if (headerName && resolvedScopeId) {
+      headers[headerName] = resolvedScopeId;
+    }
+    return { ...headers, ...this.sanitizeHeaders(options.headers ?? {}) };
+  }
+  scopeToHeader(scope) {
+    switch (scope) {
+      case "workflow":
+        return "X-Workflow-ID";
+      case "session":
+        return "X-Session-ID";
+      case "actor":
+        return "X-Actor-ID";
+      default:
+        return void 0;
+    }
+  }
+  resolveScopeId(scope, scopeId, metadata) {
+    if (scopeId) return scopeId;
+    switch (scope) {
+      case "workflow":
+        return metadata?.workflowId ?? metadata?.runId;
+      case "session":
+        return metadata?.sessionId;
+      case "actor":
+        return metadata?.actorId;
+      case "global":
+        return "global";
+      default:
+        return void 0;
+    }
+  }
+  sanitizeHeaders(headers) {
+    const sanitized = {};
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) return;
+      sanitized[key] = typeof value === "string" ? value : String(value);
+    });
+    return sanitized;
+  }
+};
+var MemoryEventClient = class {
+  url;
+  ws;
+  handlers = [];
+  reconnectDelay = 1e3;
+  closed = false;
+  reconnectPending = false;
+  reconnectTimer;
+  headers;
+  constructor(baseUrl, headers) {
+    this.url = `${baseUrl.replace(/^http/, "ws")}/api/v1/memory/events/ws`;
+    this.headers = this.buildForwardHeaders(headers ?? {});
+  }
+  start() {
+    if (this.ws) return;
+    this.connect();
+  }
+  onEvent(handler) {
+    this.handlers.push(handler);
+  }
+  stop() {
+    this.closed = true;
+    this.cleanup();
+  }
+  cleanup() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
+    }
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      this.ws.terminate();
+      this.ws = void 0;
+    }
+  }
+  connect() {
+    this.cleanup();
+    this.reconnectPending = false;
+    this.ws = new WebSocket(this.url, { headers: this.headers });
+    this.ws.on("open", () => {
+      this.reconnectDelay = 1e3;
+    });
+    this.ws.on("message", async (raw) => {
+      try {
+        const parsed = JSON.parse(raw.toString());
+        for (const handler of this.handlers) {
+          await handler(parsed);
+        }
+      } catch (err) {
+        console.error("Failed to handle memory event", err);
+      }
+    });
+    const handleDisconnect = () => this.scheduleReconnect();
+    this.ws.on("close", handleDisconnect);
+    this.ws.on("error", handleDisconnect);
+  }
+  scheduleReconnect() {
+    if (this.closed || this.reconnectPending) return;
+    this.reconnectPending = true;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = void 0;
+      if (this.closed) return;
+      this.reconnectDelay = Math.min(this.reconnectDelay * 2, 3e4);
+      this.connect();
+    }, this.reconnectDelay);
+  }
+  buildForwardHeaders(headers) {
+    const allowed = /* @__PURE__ */ new Set(["authorization", "cookie"]);
+    const sanitized = {};
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) return;
+      const lower = key.toLowerCase();
+      if (lower.startsWith("x-") || allowed.has(lower)) {
+        sanitized[key] = typeof value === "string" ? value : String(value);
+      }
+    });
+    return sanitized;
+  }
+};
+
+// src/memory/MemoryInterface.ts
+var MemoryInterface = class _MemoryInterface {
+  client;
+  eventClient;
+  aiClient;
+  defaultScope;
+  defaultScopeId;
+  metadata;
+  constructor(params) {
+    this.client = params.client;
+    this.eventClient = params.eventClient;
+    this.aiClient = params.aiClient;
+    this.defaultScope = params.defaultScope ?? "workflow";
+    this.defaultScopeId = params.defaultScopeId;
+    this.metadata = params.metadata;
+  }
+  async set(key, data, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    await this.client.set(key, data, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  get(key, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    if (scope === this.defaultScope && scopeId === this.defaultScopeId) {
+      return this.getWithFallback(key);
+    }
+    return this.client.get(key, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  async getWithFallback(key) {
+    for (const candidate of this.getScopeOrder()) {
+      const value = await this.client.get(key, {
+        scope: candidate.scope,
+        scopeId: candidate.scopeId,
+        metadata: this.metadata
+      });
+      if (value !== void 0) return value;
+    }
+    return void 0;
+  }
+  async setVector(key, embedding, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    await this.client.setVector(key, embedding, metadata, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  async deleteVector(key, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    await this.client.deleteVector(key, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  searchVector(queryEmbedding, options = {}) {
+    return this.client.searchVector(queryEmbedding, {
+      ...options,
+      metadata: this.metadata
+    });
+  }
+  delete(key, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    return this.client.delete(key, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  exists(key, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    return this.client.exists(key, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  listKeys(scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    return this.client.listKeys(scope, {
+      scope,
+      scopeId,
+      metadata: this.metadata
+    });
+  }
+  async embedText(text, options) {
+    if (!this.aiClient) {
+      throw new Error("AI client not configured for embeddings");
+    }
+    return this.aiClient.embed(text, options);
+  }
+  async embedTexts(texts, options) {
+    if (!this.aiClient) {
+      throw new Error("AI client not configured for embeddings");
+    }
+    return this.aiClient.embedMany(texts, options);
+  }
+  async embedAndSet(key, text, metadata, scope = this.defaultScope, scopeId = this.defaultScopeId, embeddingOptions) {
+    const embedding = await this.embedText(text, embeddingOptions);
+    await this.setVector(key, embedding, metadata, scope, scopeId);
+    return embedding;
+  }
+  async deleteVectors(keys, scope = this.defaultScope, scopeId = this.defaultScopeId) {
+    for (const key of keys) {
+      await this.deleteVector(key, scope, scopeId);
+    }
+  }
+  workflow(scopeId) {
+    return this.cloneWithScope("workflow", scopeId);
+  }
+  session(scopeId) {
+    return this.cloneWithScope("session", scopeId);
+  }
+  actor(scopeId) {
+    return this.cloneWithScope("actor", scopeId);
+  }
+  get globalScope() {
+    return this.cloneWithScope("global", "global");
+  }
+  onEvent(handler) {
+    this.eventClient?.onEvent(handler);
+  }
+  cloneWithScope(scope, scopeId) {
+    return new _MemoryInterface({
+      client: this.client,
+      eventClient: this.eventClient,
+      aiClient: this.aiClient,
+      defaultScope: scope,
+      defaultScopeId: scopeId ?? this.resolveScopeId(scope, this.metadata),
+      metadata: this.metadata
+    });
+  }
+  getScopeOrder() {
+    const metadata = this.metadata ?? {};
+    const order = [];
+    const pushUnique = (scope, scopeId) => {
+      const key = `${scope}:${scopeId ?? ""}`;
+      if (!order.some((c) => `${c.scope}:${c.scopeId ?? ""}` === key)) {
+        order.push({ scope, scopeId });
+      }
+    };
+    pushUnique(this.defaultScope, this.defaultScopeId ?? this.resolveScopeId(this.defaultScope, metadata));
+    const defaultSequence = ["workflow", "session", "actor", "global"];
+    defaultSequence.forEach((scope) => {
+      pushUnique(scope, this.resolveScopeId(scope, metadata));
+    });
+    return order;
+  }
+  resolveScopeId(scope, metadata) {
+    switch (scope) {
+      case "workflow":
+        return metadata?.workflowId ?? metadata?.runId;
+      case "session":
+        return metadata?.sessionId;
+      case "actor":
+        return metadata?.actorId;
+      case "global":
+        return "global";
+      default:
+        return void 0;
+    }
+  }
+};
+var DidClient = class {
+  http;
+  defaultHeaders;
+  constructor(baseUrl, defaultHeaders) {
+    this.http = axios.create({
+      baseURL: baseUrl.replace(/\/$/, ""),
+      timeout: 3e4,
+      httpAgent,
+      httpsAgent
+    });
+    this.defaultHeaders = this.sanitizeHeaders(defaultHeaders ?? {});
+  }
+  /**
+   * Register an agent with the DID system and obtain an identity package.
+   * This must be called before generating VCs to get the caller/target DIDs.
+   */
+  async registerAgent(request) {
+    const payload = {
+      agent_node_id: request.agentNodeId,
+      bots: request.bots,
+      skills: request.skills
+    };
+    const res = await this.http.post("/api/v1/did/register", payload, {
+      headers: this.mergeHeaders()
+    });
+    const data = res.data ?? {};
+    if (!data.success) {
+      return {
+        success: false,
+        error: data.error ?? "DID registration failed"
+      };
+    }
+    return {
+      success: true,
+      identityPackage: this.parseIdentityPackage(data.identity_package),
+      message: data.message
+    };
+  }
+  parseIdentityPackage(pkg) {
+    const parseIdentity = (data) => ({
+      did: data?.did ?? "",
+      privateKeyJwk: data?.private_key_jwk ?? "",
+      publicKeyJwk: data?.public_key_jwk ?? "",
+      derivationPath: data?.derivation_path ?? "",
+      componentType: data?.component_type ?? "",
+      functionName: data?.function_name
+    });
+    const botDids = {};
+    if (pkg?.bot_dids) {
+      for (const [name, data] of Object.entries(pkg.bot_dids)) {
+        botDids[name] = parseIdentity(data);
+      }
+    }
+    const skillDids = {};
+    if (pkg?.skill_dids) {
+      for (const [name, data] of Object.entries(pkg.skill_dids)) {
+        skillDids[name] = parseIdentity(data);
+      }
+    }
+    return {
+      agentDid: parseIdentity(pkg?.agent_did),
+      botDids,
+      skillDids,
+      playgroundServerId: pkg?.playground_server_id ?? ""
+    };
+  }
+  async generateCredential(params) {
+    const ctx = params.executionContext;
+    const timestamp = ctx.timestamp instanceof Date ? ctx.timestamp.toISOString() : ctx.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    const payload = {
+      execution_context: {
+        execution_id: ctx.executionId,
+        workflow_id: ctx.workflowId,
+        session_id: ctx.sessionId,
+        caller_did: ctx.callerDid,
+        target_did: ctx.targetDid,
+        agent_node_did: ctx.agentNodeDid,
+        timestamp
+      },
+      input_data: this.serializeDataForJson(params.inputData),
+      output_data: this.serializeDataForJson(params.outputData),
+      status: params.status ?? "succeeded",
+      error_message: params.errorMessage,
+      duration_ms: params.durationMs ?? 0
+    };
+    const res = await this.http.post("/api/v1/execution/vc", payload, {
+      headers: this.mergeHeaders(params.headers)
+    });
+    return this.mapExecutionCredential(res.data);
+  }
+  async exportAuditTrail(filters = {}) {
+    const res = await this.http.get("/api/v1/did/export/vcs", {
+      params: this.cleanFilters(filters),
+      headers: this.mergeHeaders()
+    });
+    const data = res.data ?? {};
+    return {
+      agentDids: data.agent_dids ?? [],
+      executionVcs: (data.execution_vcs ?? []).map((vc) => ({
+        vcId: vc.vc_id,
+        executionId: vc.execution_id,
+        workflowId: vc.workflow_id,
+        sessionId: vc.session_id,
+        issuerDid: vc.issuer_did,
+        targetDid: vc.target_did,
+        callerDid: vc.caller_did,
+        status: vc.status,
+        createdAt: vc.created_at
+      })),
+      workflowVcs: (data.workflow_vcs ?? []).map((vc) => ({
+        workflowId: vc.workflow_id,
+        sessionId: vc.session_id,
+        componentVcs: vc.component_vcs ?? [],
+        workflowVcId: vc.workflow_vc_id ?? vc.workflowVcId ?? vc.workflow_id,
+        status: vc.status,
+        startTime: vc.start_time,
+        endTime: vc.end_time,
+        totalSteps: vc.total_steps ?? 0,
+        completedSteps: vc.completed_steps ?? 0
+      })),
+      totalCount: data.total_count ?? 0,
+      filtersApplied: data.filters_applied
+    };
+  }
+  serializeDataForJson(data) {
+    if (data === void 0 || data === null) return "";
+    let value;
+    if (typeof data === "string") {
+      value = data;
+    } else if (data instanceof Uint8Array) {
+      value = Buffer.from(data).toString("utf-8");
+    } else if (typeof data === "object") {
+      try {
+        value = JSON.stringify(data, Object.keys(data).sort());
+      } catch {
+        value = String(data);
+      }
+    } else {
+      value = String(data);
+    }
+    return Buffer.from(value, "utf-8").toString("base64");
+  }
+  mapExecutionCredential(data) {
+    return {
+      vcId: data?.vc_id ?? "",
+      executionId: data?.execution_id ?? "",
+      workflowId: data?.workflow_id ?? "",
+      sessionId: data?.session_id,
+      issuerDid: data?.issuer_did,
+      targetDid: data?.target_did,
+      callerDid: data?.caller_did,
+      vcDocument: data?.vc_document,
+      signature: data?.signature,
+      inputHash: data?.input_hash,
+      outputHash: data?.output_hash,
+      status: data?.status ?? "",
+      createdAt: data?.created_at ?? ""
+    };
+  }
+  cleanFilters(filters) {
+    const cleaned = {};
+    if (filters.workflowId) cleaned.workflow_id = filters.workflowId;
+    if (filters.sessionId) cleaned.session_id = filters.sessionId;
+    if (filters.issuerDid) cleaned.issuer_did = filters.issuerDid;
+    if (filters.status) cleaned.status = filters.status;
+    if (filters.limit !== void 0) cleaned.limit = filters.limit;
+    return cleaned;
+  }
+  mergeHeaders(headers) {
+    return {
+      ...this.defaultHeaders,
+      ...this.sanitizeHeaders(headers ?? {})
+    };
+  }
+  sanitizeHeaders(headers) {
+    const sanitized = {};
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value === void 0 || value === null) return;
+      sanitized[key] = typeof value === "string" ? value : String(value);
+    });
+    return sanitized;
+  }
+};
+
+// src/did/DidInterface.ts
+var DidInterface = class {
+  client;
+  metadata;
+  enabled;
+  defaultInput;
+  constructor(params) {
+    this.client = params.client;
+    this.metadata = params.metadata;
+    this.enabled = params.enabled;
+    this.defaultInput = params.defaultInput;
+  }
+  async generateCredential(options = {}) {
+    if (!this.enabled) {
+      throw new Error("DID/VC features are disabled. Enable didEnabled in BotConfig to use ctx.did.");
+    }
+    const executionContext = {
+      executionId: options.executionId ?? this.metadata.executionId,
+      workflowId: options.workflowId ?? this.metadata.workflowId ?? this.metadata.runId,
+      sessionId: options.sessionId ?? this.metadata.sessionId,
+      callerDid: options.callerDid ?? this.metadata.callerDid,
+      targetDid: options.targetDid ?? this.metadata.targetDid,
+      agentNodeDid: options.agentNodeDid ?? this.metadata.agentNodeDid,
+      timestamp: options.timestamp
+    };
+    return this.client.generateCredential({
+      executionContext,
+      inputData: options.inputData ?? this.defaultInput,
+      outputData: options.outputData,
+      status: options.status,
+      errorMessage: options.errorMessage,
+      durationMs: options.durationMs,
+      headers: options.headers
+    });
+  }
+  exportAuditTrail(filters) {
+    if (!this.enabled) {
+      throw new Error("DID/VC features are disabled. Enable didEnabled in BotConfig to use ctx.did.");
+    }
+    return this.client.exportAuditTrail(filters);
+  }
+};
+
+// src/did/DidManager.ts
+var DidManager = class {
+  client;
+  agentNodeId;
+  identityPackage;
+  _enabled = false;
+  constructor(client, agentNodeId) {
+    this.client = client;
+    this.agentNodeId = agentNodeId;
+  }
+  /**
+   * Register agent with the DID system and obtain identity package.
+   *
+   * @param bots - List of bot definitions
+   * @param skills - List of skill definitions
+   * @returns true if registration succeeded
+   */
+  async registerAgent(bots, skills) {
+    const request = {
+      agentNodeId: this.agentNodeId,
+      bots,
+      skills
+    };
+    const response = await this.client.registerAgent(request);
+    if (response.success && response.identityPackage) {
+      this.identityPackage = response.identityPackage;
+      this._enabled = true;
+      return true;
+    }
+    console.warn(`[DID] Registration failed: ${response.error ?? "Unknown error"}`);
+    return false;
+  }
+  /**
+   * Check if DID system is enabled and identity package is available.
+   */
+  get enabled() {
+    return this._enabled && this.identityPackage !== void 0;
+  }
+  /**
+   * Get the agent node DID.
+   */
+  getAgentDid() {
+    return this.identityPackage?.agentDid.did;
+  }
+  /**
+   * Get DID for a specific function (bot or skill).
+   * Falls back to agent DID if function not found.
+   *
+   * @param functionName - Name of the bot or skill
+   * @returns DID string or undefined if not registered
+   */
+  getFunctionDid(functionName) {
+    if (!this.identityPackage) {
+      return void 0;
+    }
+    const botDid = this.identityPackage.botDids[functionName];
+    if (botDid) {
+      return botDid.did;
+    }
+    const skillDid = this.identityPackage.skillDids[functionName];
+    if (skillDid) {
+      return skillDid.did;
+    }
+    return this.identityPackage.agentDid.did;
+  }
+  /**
+   * Get the full identity package (for debugging/inspection).
+   */
+  getIdentityPackage() {
+    return this.identityPackage;
+  }
+  /**
+   * Get a summary of the identity for debugging/monitoring.
+   */
+  getIdentitySummary() {
+    if (!this.identityPackage) {
+      return { enabled: false, message: "No identity package available" };
+    }
+    return {
+      enabled: true,
+      agentDid: this.identityPackage.agentDid.did,
+      playgroundServerId: this.identityPackage.playgroundServerId,
+      botCount: Object.keys(this.identityPackage.botDids).length,
+      skillCount: Object.keys(this.identityPackage.skillDids).length,
+      botDids: Object.fromEntries(
+        Object.entries(this.identityPackage.botDids).map(([name, identity]) => [name, identity.did])
+      ),
+      skillDids: Object.fromEntries(
+        Object.entries(this.identityPackage.skillDids).map(([name, identity]) => [name, identity.did])
+      )
+    };
+  }
+};
+
+// src/utils/pattern.ts
+function matchesPattern(pattern, value) {
+  const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return regex.test(value);
+}
+function isZodSchema(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return "_def" in obj && typeof obj._def === "object" || "~standard" in obj && obj["~standard"]?.vendor === "zod";
+}
+function toJsonSchema(schema) {
+  if (schema === void 0 || schema === null) {
+    return {};
+  }
+  if (isZodSchema(schema)) {
+    const jsonSchema = zodToJsonSchema(schema, {
+      target: "openApi3",
+      $refStrategy: "none"
+      // Inline all definitions instead of using $ref
+    });
+    if (typeof jsonSchema === "object" && jsonSchema !== null) {
+      const { $schema, ...rest } = jsonSchema;
+      return rest;
+    }
+    return jsonSchema;
+  }
+  if (typeof schema === "object") {
+    return schema;
+  }
+  return {};
+}
+
+// src/workflow/WorkflowReporter.ts
+var WorkflowReporter = class {
+  client;
+  metadata;
+  constructor(client, metadata) {
+    if (!metadata.executionId) {
+      throw new Error("WorkflowReporter requires an executionId");
+    }
+    this.client = client;
+    this.metadata = metadata;
+  }
+  async progress(progress, options) {
+    const normalized = Math.min(100, Math.max(0, Math.round(progress)));
+    return this.client.updateExecutionStatus(this.metadata.executionId, {
+      status: options?.status ?? "running",
+      progress: normalized,
+      result: options?.result,
+      error: options?.error,
+      durationMs: options?.durationMs
+    });
+  }
+};
+var MCPClient = class {
+  alias;
+  baseUrl;
+  transport;
+  http;
+  devMode;
+  lastHealthy = false;
+  constructor(config, devMode) {
+    if (!config.alias) {
+      throw new Error("MCP server alias is required");
+    }
+    if (!config.url && !config.port) {
+      throw new Error(`MCP server "${config.alias}" requires a url or port`);
+    }
+    this.alias = config.alias;
+    this.transport = config.transport ?? "http";
+    this.baseUrl = (config.url ?? `http://localhost:${config.port}`).replace(/\/$/, "");
+    this.http = axios.create({
+      baseURL: this.baseUrl,
+      headers: config.headers,
+      timeout: 3e4,
+      httpAgent,
+      httpsAgent
+    });
+    this.devMode = Boolean(devMode);
+  }
+  async healthCheck() {
+    try {
+      await this.http.get("/health");
+      this.lastHealthy = true;
+      return true;
+    } catch (err) {
+      this.lastHealthy = false;
+      if (this.devMode) {
+        console.warn(`MCP health check failed for ${this.alias}:`, err instanceof Error ? err.message : err);
+      }
+      return false;
+    }
+  }
+  async listTools() {
+    try {
+      if (this.transport === "bridge") {
+        const res2 = await this.http.post("/mcp/tools/list");
+        const tools2 = res2.data?.tools ?? [];
+        return this.normalizeTools(tools2);
+      }
+      const res = await this.http.post("/mcp/v1", {
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method: "tools/list",
+        params: {}
+      });
+      const tools = res.data?.result?.tools ?? [];
+      return this.normalizeTools(tools);
+    } catch (err) {
+      if (this.devMode) {
+        console.warn(`MCP listTools failed for ${this.alias}:`, err instanceof Error ? err.message : err);
+      }
+      return [];
+    }
+  }
+  async callTool(toolName, arguments_ = {}) {
+    if (!toolName) {
+      throw new Error("toolName is required");
+    }
+    try {
+      if (this.transport === "bridge") {
+        const res2 = await this.http.post("/mcp/tools/call", {
+          tool_name: toolName,
+          arguments: arguments_
+        });
+        return res2.data?.result ?? res2.data;
+      }
+      const res = await this.http.post("/mcp/v1", {
+        jsonrpc: "2.0",
+        id: Date.now(),
+        method: "tools/call",
+        params: { name: toolName, arguments: arguments_ }
+      });
+      if (res.data?.error) {
+        throw new Error(String(res.data.error?.message ?? res.data.error));
+      }
+      if (res.data?.result !== void 0) {
+        return res.data.result;
+      }
+      return res.data;
+    } catch (err) {
+      if (this.devMode) {
+        console.warn(`MCP callTool failed for ${this.alias}.${toolName}:`, err instanceof Error ? err.message : err);
+      }
+      throw err;
+    }
+  }
+  get lastHealthStatus() {
+    return this.lastHealthy;
+  }
+  normalizeTools(tools) {
+    return (tools ?? []).map((tool) => ({
+      name: tool?.name ?? "unknown",
+      description: tool?.description,
+      inputSchema: tool?.inputSchema ?? tool?.input_schema,
+      input_schema: tool?.input_schema
+    }));
+  }
+};
+
+// src/mcp/MCPClientRegistry.ts
+var MCPClientRegistry = class {
+  clients = /* @__PURE__ */ new Map();
+  devMode;
+  constructor(devMode) {
+    this.devMode = Boolean(devMode);
+  }
+  register(config) {
+    const client = new MCPClient(config, this.devMode);
+    this.clients.set(config.alias, client);
+    return client;
+  }
+  get(alias) {
+    return this.clients.get(alias);
+  }
+  list() {
+    return Array.from(this.clients.values());
+  }
+  clear() {
+    this.clients.clear();
+  }
+  async healthSummary() {
+    if (!this.clients.size) {
+      return {
+        status: "disabled",
+        totalServers: 0,
+        healthyServers: 0,
+        servers: []
+      };
+    }
+    const results = await Promise.all(
+      Array.from(this.clients.values()).map(async (client) => {
+        const healthy = await client.healthCheck();
+        return {
+          alias: client.alias,
+          baseUrl: client.baseUrl,
+          transport: client.transport,
+          healthy
+        };
+      })
+    );
+    const healthyCount = results.filter((r) => r.healthy).length;
+    const status = healthyCount === 0 ? "degraded" : healthyCount === results.length ? "ok" : "degraded";
+    return {
+      status,
+      totalServers: results.length,
+      healthyServers: healthyCount,
+      servers: results
+    };
+  }
+};
+
+// src/mcp/MCPToolRegistrar.ts
+var MCPToolRegistrar = class {
+  constructor(agent, registry, options = {}) {
+    this.agent = agent;
+    this.registry = registry;
+    this.options = options;
+    this.devMode = Boolean(options.devMode);
+  }
+  registered = /* @__PURE__ */ new Set();
+  devMode;
+  registerServers(servers) {
+    servers.forEach((server) => this.registry.register(server));
+  }
+  async registerAll() {
+    const registrations = [];
+    const clients = this.registry.list();
+    for (const client of clients) {
+      const healthy = await client.healthCheck();
+      if (!healthy) {
+        if (this.devMode) {
+          console.warn(`Skipping MCP server ${client.alias} (health check failed)`);
+        }
+        continue;
+      }
+      const tools = await client.listTools();
+      for (const tool of tools) {
+        if (!tool?.name) continue;
+        const skillName = this.buildSkillName(client.alias, tool.name);
+        if (this.registered.has(skillName) || this.agent.skills.get(skillName)) {
+          continue;
+        }
+        this.agent.skill(
+          skillName,
+          async (ctx) => {
+            const args = ctx.input && typeof ctx.input === "object" ? ctx.input : {};
+            const result = await client.callTool(tool.name, args);
+            return {
+              status: "success",
+              result,
+              server: client.alias,
+              tool: tool.name
+            };
+          },
+          {
+            description: tool.description ?? `MCP tool ${tool.name} from ${client.alias}`,
+            inputSchema: tool.inputSchema ?? tool.input_schema ?? {},
+            tags: this.buildTags(client.alias)
+          }
+        );
+        this.registered.add(skillName);
+        registrations.push({ server: client.alias, skillName, tool });
+        if (this.devMode) {
+          console.info(`Registered MCP skill ${skillName}`);
+        }
+      }
+    }
+    return { registered: registrations };
+  }
+  buildTags(alias) {
+    return Array.from(/* @__PURE__ */ new Set(["mcp", alias, ...this.options.tags ?? []]));
+  }
+  buildSkillName(serverAlias, toolName) {
+    const base = [this.options.namespace, serverAlias, toolName].filter(Boolean).join("_");
+    return this.sanitize(base);
+  }
+  sanitize(value) {
+    const collapsed = value.replace(/[^a-zA-Z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+    if (/^[0-9]/.test(collapsed)) {
+      return `mcp_${collapsed}`;
+    }
+    return collapsed || "mcp_tool";
+  }
+};
+
+// src/agent/Bot.ts
+var TargetNotFoundError = class extends Error {
+};
+var Bot = class {
+  config;
+  app;
+  bots = new BotRegistry();
+  skills = new SkillRegistry();
+  server;
+  heartbeatTimer;
+  aiClient;
+  playgroundClient;
+  memoryClient;
+  memoryEventClient;
+  didClient;
+  didManager;
+  memoryWatchers = [];
+  mcpClientRegistry;
+  mcpToolRegistrar;
+  constructor(config) {
+    const mcp = config.mcp ? {
+      autoRegisterTools: config.mcp.autoRegisterTools ?? true,
+      ...config.mcp
+    } : void 0;
+    this.config = {
+      port: 8001,
+      playgroundUrl: "http://localhost:8080",
+      host: "0.0.0.0",
+      ...config,
+      didEnabled: config.didEnabled ?? true,
+      deploymentType: config.deploymentType ?? "long_running",
+      mcp
+    };
+    this.app = express();
+    this.app.use(express.json());
+    this.aiClient = new AIClient(this.config.aiConfig);
+    this.playgroundClient = new PlaygroundClient(this.config);
+    this.memoryClient = new MemoryClient(this.config.playgroundUrl, this.config.defaultHeaders);
+    this.memoryEventClient = new MemoryEventClient(this.config.playgroundUrl, this.config.defaultHeaders);
+    this.didClient = new DidClient(this.config.playgroundUrl, this.config.defaultHeaders);
+    this.didManager = new DidManager(this.didClient, this.config.nodeId);
+    this.memoryEventClient.onEvent((event) => this.dispatchMemoryEvent(event));
+    if (this.config.mcp?.servers?.length) {
+      this.mcpClientRegistry = new MCPClientRegistry(this.config.devMode);
+      this.mcpToolRegistrar = new MCPToolRegistrar(this, this.mcpClientRegistry, {
+        namespace: this.config.mcp.namespace,
+        tags: this.config.mcp.tags,
+        devMode: this.config.devMode
+      });
+      this.mcpToolRegistrar.registerServers(this.config.mcp.servers);
+    }
+    this.registerDefaultRoutes();
+  }
+  bot(name, handler, options) {
+    this.bots.register(name, handler, options);
+    return this;
+  }
+  skill(name, handler, options) {
+    this.skills.register(name, handler, options);
+    return this;
+  }
+  includeRouter(router) {
+    this.bots.includeRouter(router);
+    this.skills.includeRouter(router);
+  }
+  handler(adapter) {
+    return async (event, res) => {
+      if (res && typeof res === "object" && typeof res.setHeader === "function") {
+        return this.handleHttpRequest(event, res);
+      }
+      const normalized = adapter ? adapter(event) : event;
+      return this.handleServerlessEvent(normalized);
+    };
+  }
+  watchMemory(pattern, handler, options) {
+    const patterns = Array.isArray(pattern) ? pattern : [pattern];
+    patterns.forEach(
+      (p) => this.memoryWatchers.push({ pattern: p, handler, scope: options?.scope, scopeId: options?.scopeId })
+    );
+    this.memoryEventClient.start();
+  }
+  discover(options) {
+    return this.playgroundClient.discoverCapabilities(options);
+  }
+  async registerMcpTools() {
+    if (!this.mcpToolRegistrar) return { registered: [] };
+    return this.mcpToolRegistrar.registerAll();
+  }
+  getAIClient() {
+    return this.aiClient;
+  }
+  getMemoryInterface(metadata) {
+    const defaultScope = this.config.memoryConfig?.defaultScope ?? "workflow";
+    const defaultScopeId = defaultScope === "session" ? metadata?.sessionId : defaultScope === "actor" ? metadata?.actorId : metadata?.workflowId ?? metadata?.runId ?? metadata?.sessionId ?? metadata?.actorId;
+    return new MemoryInterface({
+      client: this.memoryClient,
+      eventClient: this.memoryEventClient,
+      aiClient: this.aiClient,
+      defaultScope,
+      defaultScopeId,
+      metadata: {
+        workflowId: metadata?.workflowId ?? metadata?.runId,
+        sessionId: metadata?.sessionId,
+        actorId: metadata?.actorId,
+        runId: metadata?.runId,
+        executionId: metadata?.executionId,
+        parentExecutionId: metadata?.parentExecutionId,
+        callerDid: metadata?.callerDid,
+        targetDid: metadata?.targetDid,
+        agentNodeDid: metadata?.agentNodeDid,
+        agentNodeId: this.config.nodeId
+      }
+    });
+  }
+  getWorkflowReporter(metadata) {
+    return new WorkflowReporter(this.playgroundClient, {
+      executionId: metadata.executionId,
+      runId: metadata.runId,
+      workflowId: metadata.workflowId,
+      agentNodeId: this.config.nodeId
+    });
+  }
+  getDidInterface(metadata, defaultInput, targetName) {
+    const agentNodeDid = metadata.agentNodeDid ?? this.didManager.getAgentDid() ?? this.config.defaultHeaders?.["X-Agent-Node-DID"]?.toString();
+    const callerDid = metadata.callerDid ?? this.didManager.getAgentDid();
+    const targetDid = metadata.targetDid ?? (targetName ? this.didManager.getFunctionDid(targetName) : void 0) ?? this.didManager.getAgentDid();
+    return new DidInterface({
+      client: this.didClient,
+      metadata: {
+        ...metadata,
+        agentNodeDid,
+        callerDid,
+        targetDid
+      },
+      enabled: Boolean(this.config.didEnabled),
+      defaultInput
+    });
+  }
+  note(message, tags = [], metadata) {
+    const execCtx = ExecutionContext.getCurrent();
+    const execMetadata = metadata ?? execCtx?.metadata;
+    if (!execMetadata) return;
+    const baseUrl = (this.config.playgroundUrl ?? "http://localhost:8080").replace(/\/$/, "");
+    let uiApiUrl = baseUrl.replace(/\/api\/v1$/, "/api/ui/v1");
+    if (!uiApiUrl.includes("/api/ui/v1")) {
+      uiApiUrl = `${baseUrl}/api/ui/v1`;
+    }
+    this.playgroundClient.sendNote(message, tags, this.config.nodeId, execMetadata, uiApiUrl, this.config.devMode);
+  }
+  async serve() {
+    if (this.config.mcp?.autoRegisterTools !== false) {
+      try {
+        await this.registerMcpTools();
+      } catch (err) {
+        if (this.config.devMode) {
+          console.warn("MCP tool registration failed", err);
+        }
+      }
+    }
+    await this.registerWithControlPlane();
+    const port = this.config.port ?? 8001;
+    const host = this.config.host ?? "0.0.0.0";
+    await this.playgroundClient.heartbeat("starting");
+    await new Promise((resolve, reject) => {
+      this.server = this.app.listen(port, host, () => resolve()).on("error", reject);
+    });
+    this.memoryEventClient.start();
+    this.startHeartbeat();
+  }
+  async shutdown() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    await new Promise((resolve, reject) => {
+      this.server?.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    this.memoryEventClient.stop();
+  }
+  async call(target, input) {
+    const { agentId, name } = this.parseTarget(target);
+    if (!agentId || agentId === this.config.nodeId) {
+      const local = this.bots.get(name);
+      if (!local) throw new Error(`Bot not found: ${name}`);
+      const parentMetadata = ExecutionContext.getCurrent()?.metadata;
+      const runId = parentMetadata?.runId ?? parentMetadata?.executionId ?? randomUUID();
+      const metadata2 = {
+        ...parentMetadata,
+        executionId: randomUUID(),
+        parentExecutionId: parentMetadata?.executionId,
+        runId,
+        workflowId: parentMetadata?.workflowId ?? runId
+      };
+      const dummyReq = {};
+      const dummyRes = {};
+      const execCtx = new ExecutionContext({
+        input,
+        metadata: {
+          ...metadata2,
+          executionId: metadata2.executionId ?? randomUUID()
+        },
+        req: dummyReq,
+        res: dummyRes,
+        agent: this
+      });
+      const startTime = Date.now();
+      const emitEvent = async (status, payload) => {
+        await this.playgroundClient.publishWorkflowEvent({
+          executionId: execCtx.metadata.executionId,
+          runId: execCtx.metadata.runId ?? execCtx.metadata.executionId,
+          workflowId: execCtx.metadata.workflowId,
+          botId: name,
+          agentNodeId: this.config.nodeId,
+          status,
+          parentExecutionId: execCtx.metadata.parentExecutionId,
+          parentWorkflowId: execCtx.metadata.workflowId,
+          inputData: status === "running" ? input : void 0,
+          result: status === "succeeded" ? payload : void 0,
+          error: status === "failed" ? payload?.message ?? String(payload) : void 0,
+          durationMs: status === "running" ? void 0 : Date.now() - startTime
+        });
+      };
+      await emitEvent("running", null);
+      return ExecutionContext.run(execCtx, async () => {
+        try {
+          const result = await local.handler(
+            new BotContext({
+              input,
+              executionId: execCtx.metadata.executionId,
+              runId: execCtx.metadata.runId,
+              sessionId: execCtx.metadata.sessionId,
+              actorId: execCtx.metadata.actorId,
+              workflowId: execCtx.metadata.workflowId,
+              parentExecutionId: execCtx.metadata.parentExecutionId,
+              callerDid: execCtx.metadata.callerDid,
+              targetDid: execCtx.metadata.targetDid,
+              agentNodeDid: execCtx.metadata.agentNodeDid,
+              req: dummyReq,
+              res: dummyRes,
+              agent: this,
+              aiClient: this.aiClient,
+              memory: this.getMemoryInterface(execCtx.metadata),
+              workflow: this.getWorkflowReporter(execCtx.metadata),
+              did: this.getDidInterface(execCtx.metadata, input, name)
+            })
+          );
+          await emitEvent("succeeded", result);
+          return result;
+        } catch (err) {
+          await emitEvent("failed", err);
+          throw err;
+        }
+      });
+    }
+    const metadata = ExecutionContext.getCurrent()?.metadata;
+    return this.playgroundClient.execute(target, input, {
+      runId: metadata?.runId ?? metadata?.executionId,
+      workflowId: metadata?.workflowId ?? metadata?.runId,
+      parentExecutionId: metadata?.executionId,
+      sessionId: metadata?.sessionId,
+      actorId: metadata?.actorId,
+      callerDid: metadata?.callerDid,
+      targetDid: metadata?.targetDid,
+      agentNodeDid: metadata?.agentNodeDid,
+      agentNodeId: this.config.nodeId
+    });
+  }
+  registerDefaultRoutes() {
+    this.app.get("/health", (_req, res) => {
+      res.json(this.health());
+    });
+    this.app.get("/discover", (_req, res) => {
+      res.json(this.discoveryPayload(this.config.deploymentType ?? "long_running"));
+    });
+    this.app.get("/health/mcp", async (_req, res) => {
+      if (!this.mcpClientRegistry) {
+        res.json({ status: "disabled", totalServers: 0, healthyServers: 0, servers: [] });
+        return;
+      }
+      try {
+        const summary = await this.mcpClientRegistry.healthSummary();
+        res.json(summary);
+      } catch (err) {
+        res.status(500).json({ status: "error", error: err?.message ?? "MCP health check failed" });
+      }
+    });
+    this.app.get("/mcp/status", (_req, res) => {
+      res.json(this.mcpStatus());
+    });
+    this.app.get("/status", (_req, res) => {
+      res.json({
+        ...this.health(),
+        bots: this.bots.all().map((r) => r.name),
+        skills: this.skills.all().map((s) => s.name)
+      });
+    });
+    this.app.get("/bots", (_req, res) => {
+      res.json(this.bots.all().map((r) => r.name));
+    });
+    this.app.get("/skills", (_req, res) => {
+      res.json(this.skills.all().map((s) => s.name));
+    });
+    this.app.post("/api/v1/bots/*", (req, res) => this.executeBot(req, res, req.params[0]));
+    this.app.post("/bots/:name", (req, res) => this.executeBot(req, res, req.params.name));
+    this.app.post("/api/v1/skills/*", (req, res) => this.executeSkill(req, res, req.params[0]));
+    this.app.post("/skills/:name", (req, res) => this.executeSkill(req, res, req.params.name));
+    this.app.post("/execute", (req, res) => this.executeServerlessHttp(req, res));
+    this.app.post("/execute/:name", (req, res) => this.executeServerlessHttp(req, res, req.params.name));
+  }
+  async executeBot(req, res, name) {
+    try {
+      await this.executeInvocation({
+        targetName: name,
+        targetType: "bot",
+        input: req.body,
+        metadata: this.buildMetadata(req),
+        req,
+        res,
+        respond: true
+      });
+    } catch (err) {
+      if (err instanceof TargetNotFoundError) {
+        res.status(404).json({ error: err.message });
+      } else {
+        res.status(500).json({ error: err?.message ?? "Execution failed" });
+      }
+    }
+  }
+  async executeSkill(req, res, name) {
+    try {
+      await this.executeInvocation({
+        targetName: name,
+        targetType: "skill",
+        input: req.body,
+        metadata: this.buildMetadata(req),
+        req,
+        res,
+        respond: true
+      });
+    } catch (err) {
+      if (err instanceof TargetNotFoundError) {
+        res.status(404).json({ error: err.message });
+      } else {
+        res.status(500).json({ error: err?.message ?? "Execution failed" });
+      }
+    }
+  }
+  buildMetadata(req) {
+    return this.buildMetadataFromHeaders(req.headers);
+  }
+  async executeServerlessHttp(req, res, explicitName) {
+    const invocation = this.extractInvocationDetails({
+      path: req.path,
+      explicitTarget: explicitName,
+      query: req.query,
+      body: req.body
+    });
+    if (!invocation.name) {
+      res.status(400).json({ error: "Missing 'target' or 'bot' in request" });
+      return;
+    }
+    try {
+      const result = await this.executeInvocation({
+        targetName: invocation.name,
+        targetType: invocation.targetType,
+        input: invocation.input,
+        metadata: this.buildMetadata(req),
+        req,
+        res,
+        respond: true
+      });
+      if (result !== void 0 && !res.headersSent) {
+        res.json(result);
+      }
+    } catch (err) {
+      if (err instanceof TargetNotFoundError) {
+        res.status(404).json({ error: err.message });
+      } else {
+        res.status(500).json({ error: err?.message ?? "Execution failed" });
+      }
+    }
+  }
+  buildMetadataFromHeaders(headers, overrides) {
+    const normalized = {};
+    Object.entries(headers ?? {}).forEach(([key, value]) => {
+      normalized[key.toLowerCase()] = Array.isArray(value) ? value[0] : value;
+    });
+    const executionId = overrides?.executionId ?? normalized["x-execution-id"] ?? randomUUID();
+    const runId = overrides?.runId ?? normalized["x-run-id"] ?? executionId;
+    const workflowId = overrides?.workflowId ?? normalized["x-workflow-id"] ?? runId;
+    return {
+      executionId,
+      runId,
+      workflowId,
+      sessionId: overrides?.sessionId ?? normalized["x-session-id"],
+      actorId: overrides?.actorId ?? normalized["x-actor-id"],
+      parentExecutionId: overrides?.parentExecutionId ?? normalized["x-parent-execution-id"],
+      callerDid: overrides?.callerDid ?? normalized["x-caller-did"],
+      targetDid: overrides?.targetDid ?? normalized["x-target-did"],
+      agentNodeDid: overrides?.agentNodeDid ?? normalized["x-agent-node-did"] ?? normalized["x-agent-did"]
+    };
+  }
+  handleHttpRequest(req, res) {
+    const handler = this.app;
+    return handler(req, res);
+  }
+  async handleServerlessEvent(event) {
+    const path = event?.path ?? event?.rawPath ?? "";
+    const action = event?.action ?? "";
+    if (path === "/discover" || action === "discover") {
+      return {
+        statusCode: 200,
+        headers: { "content-type": "application/json" },
+        body: this.discoveryPayload(this.config.deploymentType ?? "serverless")
+      };
+    }
+    const body = this.normalizeEventBody(event);
+    const invocation = this.extractInvocationDetails({
+      path,
+      query: event?.queryStringParameters,
+      body,
+      bot: event?.bot,
+      target: event?.target,
+      skill: event?.skill,
+      type: event?.type
+    });
+    if (!invocation.name) {
+      return {
+        statusCode: 400,
+        headers: { "content-type": "application/json" },
+        body: { error: "Missing 'target' or 'bot' in request" }
+      };
+    }
+    const metadata = this.buildMetadataFromHeaders(event?.headers ?? {}, this.mergeExecutionContext(event));
+    try {
+      const result = await this.executeInvocation({
+        targetName: invocation.name,
+        targetType: invocation.targetType,
+        input: invocation.input,
+        metadata
+      });
+      return { statusCode: 200, headers: { "content-type": "application/json" }, body: result };
+    } catch (err) {
+      if (err instanceof TargetNotFoundError) {
+        return {
+          statusCode: 404,
+          headers: { "content-type": "application/json" },
+          body: { error: err.message }
+        };
+      }
+      return {
+        statusCode: 500,
+        headers: { "content-type": "application/json" },
+        body: { error: err?.message ?? "Execution failed" }
+      };
+    }
+  }
+  normalizeEventBody(event) {
+    const parsed = this.parseBody(event?.body);
+    if (parsed && typeof parsed === "object" && event?.input !== void 0 && parsed.input === void 0) {
+      return { ...parsed, input: event.input };
+    }
+    if ((parsed === void 0 || parsed === null) && event?.input !== void 0) {
+      return { input: event.input };
+    }
+    return parsed;
+  }
+  mergeExecutionContext(event) {
+    const ctx = event?.executionContext ?? event?.execution_context;
+    if (!ctx) return {};
+    return {
+      executionId: ctx.executionId ?? ctx.execution_id ?? ctx.executionId,
+      runId: ctx.runId ?? ctx.run_id,
+      workflowId: ctx.workflowId ?? ctx.workflow_id,
+      parentExecutionId: ctx.parentExecutionId ?? ctx.parent_execution_id,
+      sessionId: ctx.sessionId ?? ctx.session_id,
+      actorId: ctx.actorId ?? ctx.actor_id,
+      callerDid: ctx.callerDid ?? ctx.caller_did,
+      targetDid: ctx.targetDid ?? ctx.target_did,
+      agentNodeDid: ctx.agentNodeDid ?? ctx.agent_node_did
+    };
+  }
+  extractInvocationDetails(params) {
+    const pathTarget = this.parsePathTarget(params.path);
+    const name = this.firstDefined(
+      params.explicitTarget,
+      pathTarget.name,
+      params.query?.target,
+      params.query?.bot,
+      params.query?.skill,
+      params.target,
+      params.bot,
+      params.skill,
+      params.body?.target,
+      params.body?.bot,
+      params.body?.skill
+    ) ?? pathTarget.name;
+    const typeValue = this.firstDefined(
+      pathTarget.targetType,
+      params.type,
+      params.query?.type,
+      params.query?.targetType,
+      params.body?.type,
+      params.body?.targetType
+    ) ?? void 0;
+    const input = this.normalizeInputPayload(params.body);
+    return { name: name ?? void 0, targetType: typeValue, input };
+  }
+  parsePathTarget(path) {
+    if (!path) return {};
+    const normalized = path.split("?")[0];
+    const botMatch = normalized.match(/\/bots\/([^/]+)/);
+    if (botMatch?.[1]) {
+      return { name: botMatch[1], targetType: "bot" };
+    }
+    const skillMatch = normalized.match(/\/skills\/([^/]+)/);
+    if (skillMatch?.[1]) {
+      return { name: skillMatch[1], targetType: "skill" };
+    }
+    const executeMatch = normalized.match(/\/execute\/([^/]+)/);
+    if (executeMatch?.[1]) {
+      return { name: executeMatch[1] };
+    }
+    return {};
+  }
+  parseBody(body) {
+    if (body === void 0 || body === null) return body;
+    if (typeof body === "string") {
+      try {
+        return JSON.parse(body);
+      } catch {
+        return body;
+      }
+    }
+    return body;
+  }
+  normalizeInputPayload(body) {
+    if (body === void 0 || body === null) return {};
+    const parsed = this.parseBody(body);
+    if (parsed && typeof parsed === "object") {
+      const { target, bot, skill, type, targetType, ...rest } = parsed;
+      if (parsed.input !== void 0) {
+        return parsed.input;
+      }
+      if (parsed.data !== void 0) {
+        return parsed.data;
+      }
+      if (Object.keys(rest).length === 0) {
+        return {};
+      }
+      return rest;
+    }
+    return parsed;
+  }
+  firstDefined(...values) {
+    for (const value of values) {
+      if (value !== void 0 && value !== null) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  botDefinitions() {
+    return this.bots.all().map((r) => ({
+      id: r.name,
+      input_schema: toJsonSchema(r.options?.inputSchema),
+      output_schema: toJsonSchema(r.options?.outputSchema),
+      memory_config: r.options?.memoryConfig ?? {
+        auto_inject: [],
+        memory_retention: "",
+        cache_results: false
+      },
+      tags: r.options?.tags ?? []
+    }));
+  }
+  skillDefinitions() {
+    return this.skills.all().map((s) => ({
+      id: s.name,
+      input_schema: toJsonSchema(s.options?.inputSchema),
+      tags: s.options?.tags ?? []
+    }));
+  }
+  discoveryPayload(deploymentType) {
+    return {
+      node_id: this.config.nodeId,
+      version: this.config.version,
+      deployment_type: deploymentType,
+      bots: this.botDefinitions(),
+      skills: this.skillDefinitions()
+    };
+  }
+  async executeInvocation(params) {
+    const targetType = params.targetType;
+    if (targetType === "skill") {
+      const skill = this.skills.get(params.targetName);
+      if (!skill) {
+        throw new TargetNotFoundError(`Skill not found: ${params.targetName}`);
+      }
+      return this.runSkill(skill, params);
+    }
+    const bot = this.bots.get(params.targetName);
+    if (bot) {
+      return this.runBot(bot, params);
+    }
+    const fallbackSkill = this.skills.get(params.targetName);
+    if (fallbackSkill) {
+      return this.runSkill(fallbackSkill, params);
+    }
+    throw new TargetNotFoundError(`Bot not found: ${params.targetName}`);
+  }
+  async runBot(bot, params) {
+    const req = params.req ?? {};
+    const res = params.res ?? {};
+    const execCtx = new ExecutionContext({
+      input: params.input,
+      metadata: params.metadata,
+      req,
+      res,
+      agent: this
+    });
+    return ExecutionContext.run(execCtx, async () => {
+      try {
+        const ctx = new BotContext({
+          input: params.input,
+          executionId: params.metadata.executionId,
+          runId: params.metadata.runId,
+          sessionId: params.metadata.sessionId,
+          actorId: params.metadata.actorId,
+          workflowId: params.metadata.workflowId,
+          parentExecutionId: params.metadata.parentExecutionId,
+          callerDid: params.metadata.callerDid,
+          targetDid: params.metadata.targetDid,
+          agentNodeDid: params.metadata.agentNodeDid,
+          req,
+          res,
+          agent: this,
+          aiClient: this.aiClient,
+          memory: this.getMemoryInterface(params.metadata),
+          workflow: this.getWorkflowReporter(params.metadata),
+          did: this.getDidInterface(params.metadata, params.input, params.targetName)
+        });
+        const result = await bot.handler(ctx);
+        if (params.respond && params.res) {
+          params.res.json(result);
+          return;
+        }
+        return result;
+      } catch (err) {
+        if (params.respond && params.res) {
+          params.res.status(500).json({ error: err?.message ?? "Execution failed" });
+          return;
+        }
+        throw err;
+      }
+    });
+  }
+  async runSkill(skill, params) {
+    const req = params.req ?? {};
+    const res = params.res ?? {};
+    const execCtx = new ExecutionContext({
+      input: params.input,
+      metadata: params.metadata,
+      req,
+      res,
+      agent: this
+    });
+    return ExecutionContext.run(execCtx, async () => {
+      try {
+        const ctx = new SkillContext({
+          input: params.input,
+          executionId: params.metadata.executionId,
+          sessionId: params.metadata.sessionId,
+          workflowId: params.metadata.workflowId,
+          req,
+          res,
+          agent: this,
+          memory: this.getMemoryInterface(params.metadata),
+          workflow: this.getWorkflowReporter(params.metadata),
+          did: this.getDidInterface(params.metadata, params.input, params.targetName)
+        });
+        const result = await skill.handler(ctx);
+        if (params.respond && params.res) {
+          params.res.json(result);
+          return;
+        }
+        return result;
+      } catch (err) {
+        if (params.respond && params.res) {
+          params.res.status(500).json({ error: err?.message ?? "Execution failed" });
+          return;
+        }
+        throw err;
+      }
+    });
+  }
+  async registerWithControlPlane() {
+    try {
+      const bots = this.botDefinitions();
+      const skills = this.skillDefinitions();
+      const port = this.config.port ?? 8001;
+      const hostForUrl = this.config.publicUrl ? void 0 : this.config.host && this.config.host !== "0.0.0.0" ? this.config.host : "127.0.0.1";
+      const publicUrl = this.config.publicUrl ?? `http://${hostForUrl ?? "127.0.0.1"}:${port}`;
+      await this.playgroundClient.register({
+        id: this.config.nodeId,
+        version: this.config.version,
+        base_url: publicUrl,
+        public_url: publicUrl,
+        deployment_type: this.config.deploymentType ?? "long_running",
+        bots,
+        skills
+      });
+      if (this.config.didEnabled) {
+        try {
+          const didRegistered = await this.didManager.registerAgent(bots, skills);
+          if (didRegistered) {
+            const summary = this.didManager.getIdentitySummary();
+            console.log(`[DID] Agent registered with DID: ${summary.agentDid}`);
+            console.log(`[DID] Bot DIDs: ${summary.botCount}, Skill DIDs: ${summary.skillCount}`);
+          }
+        } catch (didErr) {
+          if (!this.config.devMode) {
+            console.warn("[DID] DID registration failed:", didErr);
+          }
+        }
+      }
+    } catch (err) {
+      if (!this.config.devMode) {
+        throw err;
+      }
+      console.warn("Control plane registration failed (devMode=true), continuing locally", err);
+    }
+  }
+  startHeartbeat() {
+    const interval = this.config.heartbeatIntervalMs ?? 3e4;
+    if (interval <= 0) return;
+    const tick = async () => {
+      try {
+        await this.playgroundClient.heartbeat("ready");
+      } catch (err) {
+        console.warn("Heartbeat failed", err);
+      }
+    };
+    this.heartbeatTimer = setInterval(tick, interval);
+    tick();
+  }
+  health() {
+    return {
+      status: "running",
+      node_id: this.config.nodeId,
+      version: this.config.version
+    };
+  }
+  mcpStatus() {
+    const servers = this.mcpClientRegistry ? this.mcpClientRegistry.list().map((client) => ({
+      alias: client.alias,
+      baseUrl: client.baseUrl,
+      transport: client.transport
+    })) : [];
+    const skills = this.skills.all().filter((skill) => skill.options?.tags?.includes("mcp")).map((skill) => skill.name);
+    return {
+      status: servers.length ? "configured" : "disabled",
+      servers,
+      skills
+    };
+  }
+  dispatchMemoryEvent(event) {
+    this.memoryWatchers.forEach(({ pattern, handler, scope, scopeId }) => {
+      const scopeMatch = (!scope || scope === event.scope) && (!scopeId || scopeId === event.scopeId);
+      if (scopeMatch && matchesPattern(pattern, event.key)) {
+        handler(event);
+      }
+    });
+  }
+  parseTarget(target) {
+    if (!target.includes(".")) {
+      return { name: target };
+    }
+    const [agentId, remainder] = target.split(".", 2);
+    const name = remainder.replace(":", "/");
+    return { agentId, name };
+  }
+};
+
+// src/router/BotRouter.ts
+var BotRouter = class {
+  prefix;
+  tags;
+  bots = [];
+  skills = [];
+  constructor(options = {}) {
+    this.prefix = options.prefix;
+    this.tags = options.tags;
+  }
+  bot(name, handler, options) {
+    const fullName = this.prefix ? `${sanitize(this.prefix)}_${name}` : name;
+    this.bots.push({ name: fullName, handler, options });
+    return this;
+  }
+  skill(name, handler, options) {
+    const fullName = this.prefix ? `${sanitize(this.prefix)}_${name}` : name;
+    this.skills.push({ name: fullName, handler, options });
+    return this;
+  }
+};
+function sanitize(value) {
+  return value.replace(/[^0-9a-zA-Z]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+
+export { AIClient, Bot as Agent, BotRouter as AgentRouter, Bot, BotContext, BotRouter, DidClient, DidInterface, DidManager, ExecutionContext, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, SkillContext, StatelessRateLimiter, WorkflowReporter, getCurrentContext, getCurrentSkillContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map