@agentfield/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2257 @@
+import express from 'express';
+import crypto, { randomUUID } from 'crypto';
+import { AsyncLocalStorage } from 'async_hooks';
+import { generateText, streamText, embed, embedMany } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import os from 'os';
+import axios, { isAxiosError } from 'axios';
+import WebSocket from 'ws';
+import { Buffer } from 'buffer';
+
+// src/agent/Agent.ts
+
+// src/agent/ReasonerRegistry.ts
+var ReasonerRegistry = class {
+  reasoners = /* @__PURE__ */ new Map();
+  register(name, handler, options) {
+    this.reasoners.set(name, { name, handler, options });
+  }
+  includeRouter(router) {
+    router.reasoners.forEach((reasoner) => {
+      this.reasoners.set(reasoner.name, reasoner);
+    });
+  }
+  get(name) {
+    return this.reasoners.get(name);
+  }
+  all() {
+    return Array.from(this.reasoners.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/ReasonerContext.ts
+var ReasonerContext = 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);
+  }
+};
+function getCurrentContext() {
+  const execution = ExecutionContext.getCurrent();
+  if (!execution) return void 0;
+  const { metadata, input, agent, req, res } = execution;
+  return new ReasonerContext({
+    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
+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);
+    const call = async () => generateText({
+      // type cast to avoid provider-model signature drift
+      model,
+      prompt,
+      system: options.system,
+      temperature: options.temperature ?? this.config.temperature,
+      maxTokens: options.maxTokens ?? this.config.maxTokens,
+      schema: options.schema
+    });
+    const response = await this.withRateLimitRetry(call);
+    if (options.schema && response.object !== void 0) {
+      return response.object;
+    }
+    return response.text;
+  }
+  async stream(prompt, options = {}) {
+    const model = this.buildModel(options);
+    const streamResult = await this.withRateLimitRetry(
+      () => streamText({
+        model,
+        prompt,
+        system: options.system,
+        temperature: options.temperature ?? this.config.temperature,
+        maxTokens: 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";
+    if (provider === "anthropic") {
+      const anthropic = createAnthropic({
+        apiKey: this.config.apiKey,
+        baseURL: this.config.baseUrl
+      });
+      return anthropic(modelName);
+    }
+    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";
+    if (provider === "anthropic") {
+      throw new Error("Embedding generation is not supported for Anthropic provider");
+    }
+    const openai = createOpenAI({
+      apiKey: this.config.apiKey,
+      baseURL: this.config.baseUrl
+    });
+    if (typeof openai.embedding !== "function") {
+      throw new Error("Embedding model is not available for the configured provider");
+    }
+    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 AgentFieldClient = class {
+  http;
+  config;
+  defaultHeaders;
+  constructor(config) {
+    const baseURL = (config.agentFieldUrl ?? "http://localhost:8080").replace(/\/$/, "");
+    this.http = axios.create({ baseURL });
+    this.config = config;
+    this.defaultHeaders = this.sanitizeHeaders(config.defaultHeaders ?? {});
+  }
+  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,
+      reasoner_id: event.reasonerId,
+      type: event.reasonerId,
+      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.reasoner) params.reasoner = options.reasoner;
+    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),
+      totalReasoners: Number(payload?.total_reasoners ?? 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,
+        reasoners: (cap?.reasoners ?? []).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 ?? ""),
+      reasoners: (payload?.reasoners ?? []).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 ?? {})
+    };
+  }
+};
+var MemoryClient = class {
+  http;
+  defaultHeaders;
+  constructor(baseUrl, defaultHeaders) {
+    this.http = axios.create({
+      baseURL: baseUrl.replace(/\/$/, "")
+    });
+    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;
+  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.ws?.close();
+  }
+  connect() {
+    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);
+      }
+    });
+    this.ws.on("close", () => this.scheduleReconnect());
+    this.ws.on("error", () => this.scheduleReconnect());
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    setTimeout(() => {
+      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(/\/$/, "") });
+    this.defaultHeaders = this.sanitizeHeaders(defaultHeaders ?? {});
+  }
+  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 AgentConfig 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 AgentConfig to use ctx.did.");
+    }
+    return this.client.exportAuditTrail(filters);
+  }
+};
+
+// src/utils/pattern.ts
+function matchesPattern(pattern, value) {
+  const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&").replace(/\*/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return regex.test(value);
+}
+
+// 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
+    });
+    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());
+  }
+  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/Agent.ts
+var TargetNotFoundError = class extends Error {
+};
+var Agent = class {
+  config;
+  app;
+  reasoners = new ReasonerRegistry();
+  skills = new SkillRegistry();
+  server;
+  heartbeatTimer;
+  aiClient;
+  agentFieldClient;
+  memoryClient;
+  memoryEventClient;
+  didClient;
+  memoryWatchers = [];
+  mcpClientRegistry;
+  mcpToolRegistrar;
+  constructor(config) {
+    const mcp = config.mcp ? {
+      autoRegisterTools: config.mcp.autoRegisterTools ?? true,
+      ...config.mcp
+    } : void 0;
+    this.config = {
+      port: 8001,
+      agentFieldUrl: "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.agentFieldClient = new AgentFieldClient(this.config);
+    this.memoryClient = new MemoryClient(this.config.agentFieldUrl, this.config.defaultHeaders);
+    this.memoryEventClient = new MemoryEventClient(this.config.agentFieldUrl, this.config.defaultHeaders);
+    this.didClient = new DidClient(this.config.agentFieldUrl, this.config.defaultHeaders);
+    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();
+  }
+  reasoner(name, handler, options) {
+    this.reasoners.register(name, handler, options);
+    return this;
+  }
+  skill(name, handler, options) {
+    this.skills.register(name, handler, options);
+    return this;
+  }
+  includeRouter(router) {
+    this.reasoners.includeRouter(router);
+    this.skills.includeRouter(router);
+  }
+  handler() {
+    return async (event, res) => {
+      if (res && typeof res === "object" && typeof res.setHeader === "function") {
+        return this.handleHttpRequest(event, res);
+      }
+      return this.handleServerlessEvent(event);
+    };
+  }
+  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.agentFieldClient.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.agentFieldClient, {
+      executionId: metadata.executionId,
+      runId: metadata.runId,
+      workflowId: metadata.workflowId,
+      agentNodeId: this.config.nodeId
+    });
+  }
+  getDidInterface(metadata, defaultInput) {
+    return new DidInterface({
+      client: this.didClient,
+      metadata: {
+        ...metadata,
+        agentNodeDid: metadata.agentNodeDid ?? this.config.defaultHeaders?.["X-Agent-Node-DID"]?.toString()
+      },
+      enabled: Boolean(this.config.didEnabled),
+      defaultInput
+    });
+  }
+  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.agentFieldClient.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.reasoners.get(name);
+      if (!local) throw new Error(`Reasoner 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.agentFieldClient.publishWorkflowEvent({
+          executionId: execCtx.metadata.executionId,
+          runId: execCtx.metadata.runId ?? execCtx.metadata.executionId,
+          workflowId: execCtx.metadata.workflowId,
+          reasonerId: 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 ReasonerContext({
+              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)
+            })
+          );
+          await emitEvent("succeeded", result);
+          return result;
+        } catch (err) {
+          await emitEvent("failed", err);
+          throw err;
+        }
+      });
+    }
+    const metadata = ExecutionContext.getCurrent()?.metadata;
+    return this.agentFieldClient.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(),
+        reasoners: this.reasoners.all().map((r) => r.name),
+        skills: this.skills.all().map((s) => s.name)
+      });
+    });
+    this.app.get("/reasoners", (_req, res) => {
+      res.json(this.reasoners.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/reasoners/*", (req, res) => this.executeReasoner(req, res, req.params[0]));
+    this.app.post("/reasoners/:name", (req, res) => this.executeReasoner(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 executeReasoner(req, res, name) {
+    try {
+      await this.executeInvocation({
+        targetName: name,
+        targetType: "reasoner",
+        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 'reasoner' 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,
+      reasoner: event?.reasoner,
+      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 'reasoner' 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?.reasoner,
+      params.query?.skill,
+      params.target,
+      params.reasoner,
+      params.skill,
+      params.body?.target,
+      params.body?.reasoner,
+      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 reasonerMatch = normalized.match(/\/reasoners\/([^/]+)/);
+    if (reasonerMatch?.[1]) {
+      return { name: reasonerMatch[1], targetType: "reasoner" };
+    }
+    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, reasoner, 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;
+  }
+  reasonerDefinitions() {
+    return this.reasoners.all().map((r) => ({
+      id: r.name,
+      input_schema: r.options?.inputSchema ?? {},
+      output_schema: 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: s.options?.inputSchema ?? {},
+      tags: s.options?.tags ?? []
+    }));
+  }
+  discoveryPayload(deploymentType) {
+    return {
+      node_id: this.config.nodeId,
+      version: this.config.version,
+      deployment_type: deploymentType,
+      reasoners: this.reasonerDefinitions(),
+      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 reasoner = this.reasoners.get(params.targetName);
+    if (reasoner) {
+      return this.runReasoner(reasoner, params);
+    }
+    const fallbackSkill = this.skills.get(params.targetName);
+    if (fallbackSkill) {
+      return this.runSkill(fallbackSkill, params);
+    }
+    throw new TargetNotFoundError(`Reasoner not found: ${params.targetName}`);
+  }
+  async runReasoner(reasoner, 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 ReasonerContext({
+          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)
+        });
+        const result = await reasoner.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)
+        });
+        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 reasoners = this.reasonerDefinitions();
+      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.agentFieldClient.register({
+        id: this.config.nodeId,
+        version: this.config.version,
+        base_url: publicUrl,
+        public_url: publicUrl,
+        deployment_type: this.config.deploymentType ?? "long_running",
+        reasoners,
+        skills
+      });
+    } 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.agentFieldClient.heartbeat("ready");
+      } catch (err) {
+        if (!this.config.devMode) {
+          console.warn("Heartbeat failed", err);
+        }
+      }
+    };
+    this.heartbeatTimer = setInterval(tick, interval);
+    tick();
+  }
+  health() {
+    return {
+      status: "running",
+      nodeId: 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/AgentRouter.ts
+var AgentRouter = class {
+  prefix;
+  tags;
+  reasoners = [];
+  skills = [];
+  constructor(options = {}) {
+    this.prefix = options.prefix;
+    this.tags = options.tags;
+  }
+  reasoner(name, handler, options) {
+    const fullName = this.prefix ? `${sanitize(this.prefix)}_${name}` : name;
+    this.reasoners.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, Agent, AgentRouter, DidClient, DidInterface, ExecutionContext, MCPClient, MCPClientRegistry, MCPToolRegistrar, MemoryClient, MemoryEventClient, MemoryInterface, RateLimitError, ReasonerContext, SkillContext, StatelessRateLimiter, WorkflowReporter, getCurrentContext, getCurrentSkillContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map