gauss-ai 4.0.0

package/dist/plugins-L4ING3CX.js

@@ -0,0 +1,4625 @@
+import {
+  CircuitBreaker,
+  PluginManager,
+  ToolCache
+} from "./chunk-X2GHUHAF.js";
+import {
+  tool
+} from "./chunk-K6SAETGP.js";
+
+// src/plugins/base.plugin.ts
+var BasePlugin = class {
+  version = "1.0.0";
+  hooks;
+  constructor() {
+    this.hooks = this.buildHooks();
+  }
+};
+
+// src/plugins/agent-card.plugin.ts
+import { z } from "zod";
+var DEFAULT_AGENTS_PATH = "agents.md";
+var DEFAULT_SKILLS_PATH = "skills.md";
+var DEFAULT_ZONES = ["persistent", "transient"];
+var AgentCardPlugin = class {
+  name = "agent-card";
+  version = "1.0.0";
+  tools;
+  options;
+  setupCtx;
+  latestCtx;
+  hooks = {
+    beforeRun: async (ctx, _params) => {
+      this.latestCtx = ctx;
+    },
+    afterRun: async (ctx, _params) => {
+      this.latestCtx = ctx;
+    }
+  };
+  constructor(options = {}) {
+    this.options = {
+      paths: {
+        agents: options.paths?.agents ?? DEFAULT_AGENTS_PATH,
+        skills: options.paths?.skills ?? DEFAULT_SKILLS_PATH
+      },
+      readZones: options.readZones ?? DEFAULT_ZONES,
+      overrides: options.overrides
+    };
+    this.tools = {
+      "agent-card:get": tool({
+        description: "Return generated or manual agent card documents.",
+        inputSchema: z.object({
+          target: z.enum(["agents", "skills", "all"]).default("all")
+        }),
+        execute: async (args) => {
+          const parsed = z.object({ target: z.enum(["agents", "skills", "all"]).default("all") }).parse(args ?? {});
+          const snapshot = await this.getAgentCard();
+          if (parsed.target === "agents") {
+            return {
+              target: "agents",
+              markdown: snapshot.agentsMd,
+              source: snapshot.source.agents
+            };
+          }
+          if (parsed.target === "skills") {
+            return {
+              target: "skills",
+              markdown: snapshot.skillsMd,
+              source: snapshot.source.skills
+            };
+          }
+          return snapshot;
+        }
+      })
+    };
+  }
+  setup(ctx) {
+    this.setupCtx = ctx;
+  }
+  async getAgentCard() {
+    const ctx = this.latestCtx ?? this.setupCtx;
+    if (!ctx) {
+      throw new Error("AgentCardPlugin has not been initialized by a Agent instance");
+    }
+    const agents = await this.resolveAgentsMarkdown(ctx);
+    const skills = await this.resolveSkillsMarkdown(ctx);
+    return {
+      agentsMd: agents.markdown,
+      skillsMd: skills.markdown,
+      source: {
+        agents: agents.source,
+        skills: skills.source
+      }
+    };
+  }
+  async resolveAgentsMarkdown(ctx) {
+    const manual = await this.tryReadManual(ctx, this.options.paths.agents);
+    if (manual) return { markdown: manual, source: "manual" };
+    const auto = this.createAutoAgentCard(ctx);
+    const override = this.options.overrides?.agents;
+    if (override !== void 0) {
+      if (typeof override === "string") {
+        return { markdown: override, source: "override" };
+      }
+      const merged = this.mergeAgentCard(auto, override);
+      return { markdown: this.renderAgentCard(merged), source: "override" };
+    }
+    return { markdown: this.renderAgentCard(auto), source: "auto" };
+  }
+  async resolveSkillsMarkdown(ctx) {
+    const manual = await this.tryReadManual(ctx, this.options.paths.skills);
+    if (manual) return { markdown: manual, source: "manual" };
+    const auto = this.createAutoSkillsCard(ctx);
+    const override = this.options.overrides?.skills;
+    if (override !== void 0) {
+      if (typeof override === "string") {
+        return { markdown: override, source: "override" };
+      }
+      const merged = this.mergeSkillsCard(auto, override);
+      return { markdown: this.renderSkillsCard(merged), source: "override" };
+    }
+    return { markdown: this.renderSkillsCard(auto), source: "auto" };
+  }
+  async tryReadManual(ctx, path) {
+    for (const zone of this.options.readZones) {
+      try {
+        const exists = await ctx.filesystem.exists(path, zone);
+        if (!exists) continue;
+        return await ctx.filesystem.read(path, zone);
+      } catch {
+      }
+    }
+    return null;
+  }
+  createAutoAgentCard(ctx) {
+    const name = ctx.agentName ?? "Agent";
+    const tools = [...ctx.toolNames].sort();
+    return {
+      title: "Agent Card",
+      name,
+      sessionId: ctx.sessionId,
+      maxSteps: ctx.config.maxSteps,
+      summary: `${name} exposes ${tools.length} tool${tools.length === 1 ? "" : "s"}.`,
+      instructions: ctx.config.instructions,
+      tools,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  createAutoSkillsCard(ctx) {
+    const name = ctx.agentName ?? "Agent";
+    const skills = [...ctx.toolNames].sort();
+    return {
+      title: "Skills Card",
+      name,
+      summary: `${name} can invoke ${skills.length} callable skills/tools.`,
+      skills,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  mergeAgentCard(base, override) {
+    return {
+      ...base,
+      ...override,
+      tools: override.tools ? [...override.tools] : base.tools
+    };
+  }
+  mergeSkillsCard(base, override) {
+    return {
+      ...base,
+      ...override,
+      skills: override.skills ? [...override.skills] : base.skills
+    };
+  }
+  renderAgentCard(doc) {
+    const tools = doc.tools.length > 0 ? doc.tools.map((toolName) => `- \`${toolName}\``) : ["- _No tools registered_"];
+    return [
+      `# ${doc.title}`,
+      "",
+      `- Name: ${doc.name}`,
+      `- Session: ${doc.sessionId}`,
+      `- Max Steps: ${doc.maxSteps}`,
+      `- Generated At: ${doc.generatedAt}`,
+      "",
+      "## Summary",
+      doc.summary,
+      "",
+      "## Instructions",
+      doc.instructions,
+      "",
+      "## Tools",
+      ...tools,
+      ""
+    ].join("\n");
+  }
+  renderSkillsCard(doc) {
+    const skills = doc.skills.length > 0 ? doc.skills.map((skill) => `- \`${skill}\``) : ["- _No skills registered_"];
+    return [
+      `# ${doc.title}`,
+      "",
+      `- Agent: ${doc.name}`,
+      `- Generated At: ${doc.generatedAt}`,
+      "",
+      "## Summary",
+      doc.summary,
+      "",
+      "## Skills",
+      ...skills,
+      ""
+    ].join("\n");
+  }
+};
+function createAgentCardPlugin(options) {
+  return new AgentCardPlugin(options);
+}
+
+// src/plugins/a2a.plugin.ts
+import { z as z2 } from "zod";
+
+// src/plugins/a2a-handler.ts
+function createError(id, code, message, data) {
+  const error = data === void 0 ? { code, message } : { code, message, data };
+  return {
+    jsonrpc: "2.0",
+    id,
+    error
+  };
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function createA2AJsonRpcHandler(handlers) {
+  return async (request) => {
+    const id = request.id ?? null;
+    if (request.jsonrpc !== "2.0" || typeof request.method !== "string") {
+      return createError(id, -32600, "Invalid Request");
+    }
+    try {
+      switch (request.method) {
+        case "tasks/send": {
+          const params = asRecord(request.params);
+          if (!params) {
+            return createError(id, -32602, "Invalid params: expected object");
+          }
+          const prompt = asString(params.prompt);
+          if (!prompt) {
+            return createError(id, -32602, "Invalid params: prompt is required");
+          }
+          const parsedTaskId = params.taskId === void 0 ? void 0 : asString(params.taskId);
+          if (params.taskId !== void 0 && !parsedTaskId) {
+            return createError(id, -32602, "Invalid params: taskId must be a non-empty string");
+          }
+          const taskId = parsedTaskId ?? void 0;
+          const metadata = params.metadata === void 0 ? void 0 : asRecord(params.metadata);
+          if (params.metadata !== void 0 && !metadata) {
+            return createError(id, -32602, "Invalid params: metadata must be an object");
+          }
+          const task = await handlers.sendTask({ prompt, taskId, metadata: metadata ?? void 0 });
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: task
+          };
+        }
+        case "tasks/get": {
+          const params = asRecord(request.params);
+          if (!params) {
+            return createError(id, -32602, "Invalid params: expected object");
+          }
+          const taskId = asString(params.taskId);
+          if (!taskId) {
+            return createError(id, -32602, "Invalid params: taskId is required");
+          }
+          const task = await handlers.getTask(taskId);
+          if (!task) {
+            return createError(id, -32004, "Task not found", { taskId });
+          }
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: task
+          };
+        }
+        case "tasks/list": {
+          if (!handlers.listTasks) {
+            return createError(id, -32601, "Method not found: tasks/list");
+          }
+          const tasks = await handlers.listTasks();
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: { tasks }
+          };
+        }
+        case "tasks/cancel": {
+          if (!handlers.cancelTask) {
+            return createError(id, -32601, "Method not found: tasks/cancel");
+          }
+          const params = asRecord(request.params);
+          if (!params) {
+            return createError(id, -32602, "Invalid params: expected object");
+          }
+          const taskId = asString(params.taskId);
+          if (!taskId) {
+            return createError(id, -32602, "Invalid params: taskId is required");
+          }
+          const task = await handlers.cancelTask(taskId);
+          if (!task) {
+            return createError(id, -32004, "Task not found", { taskId });
+          }
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: task
+          };
+        }
+        case "agent/card": {
+          if (!handlers.getAgentCard) {
+            return createError(id, -32601, "Method not found: agent/card");
+          }
+          const card = await handlers.getAgentCard();
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: card
+          };
+        }
+        case "tasks/sendSubscribe": {
+          if (!handlers.sendTaskSubscribe) {
+            return createError(id, -32601, "Method not found: tasks/sendSubscribe");
+          }
+          const params = asRecord(request.params);
+          if (!params) {
+            return createError(id, -32602, "Invalid params: expected object");
+          }
+          const prompt = asString(params.prompt);
+          if (!prompt) {
+            return createError(id, -32602, "Invalid params: prompt is required");
+          }
+          const parsedTaskId = params.taskId === void 0 ? void 0 : asString(params.taskId);
+          if (params.taskId !== void 0 && !parsedTaskId) {
+            return createError(id, -32602, "Invalid params: taskId must be a non-empty string");
+          }
+          const taskId = parsedTaskId ?? void 0;
+          const metadata = params.metadata === void 0 ? void 0 : asRecord(params.metadata);
+          if (params.metadata !== void 0 && !metadata) {
+            return createError(id, -32602, "Invalid params: metadata must be an object");
+          }
+          return createError(id, -32601, "Use SSE endpoint for tasks/sendSubscribe");
+        }
+        case "health": {
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: { ok: true }
+          };
+        }
+        default:
+          return createError(id, -32601, `Method not found: ${request.method}`);
+      }
+    } catch (error) {
+      return createError(
+        id,
+        -32603,
+        error instanceof Error ? error.message : "Internal error"
+      );
+    }
+  };
+}
+function createA2AHttpHandler(jsonRpcHandler, sseHandlers) {
+  return async (request) => {
+    const url = new URL(request.url);
+    if (request.method === "GET" && url.pathname === "/.well-known/agent.json") {
+      try {
+        const cardResponse = await jsonRpcHandler({
+          jsonrpc: "2.0",
+          id: "agent-discovery",
+          method: "agent/card"
+        });
+        if (cardResponse.error) {
+          return new Response(
+            JSON.stringify({ error: "Agent card not available" }),
+            { status: 500, headers: { "Content-Type": "application/json" } }
+          );
+        }
+        const agentCard = cardResponse.result;
+        const cardName = agentCard?.name ?? agentCard?.source?.name ?? "Agent";
+        const cardDescription = agentCard?.instructions ?? agentCard?.agentsMd ?? "A2A-compatible agent";
+        const cardTools = agentCard?.tools ?? [];
+        const cardSkills = agentCard?.skillsMd ? agentCard.skillsMd.split("\n").filter((l) => l.startsWith("- ")).map((l) => l.slice(2)) : [];
+        const allSkills = cardTools.length > 0 ? cardTools : cardSkills;
+        const discoveryCard = {
+          name: cardName,
+          description: cardDescription,
+          url: url.origin + "/a2a",
+          version: "1.0.0",
+          capabilities: {
+            streaming: true,
+            pushNotifications: true
+          },
+          skills: allSkills.map((skill, index) => ({
+            id: `skill-${index}`,
+            name: skill,
+            description: `Skill: ${skill}`
+          })),
+          authentication: { schemes: ["none"] }
+        };
+        return new Response(JSON.stringify(discoveryCard), {
+          status: 200,
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        return new Response(
+          JSON.stringify({ error: "Failed to generate agent card" }),
+          { status: 500, headers: { "Content-Type": "application/json" } }
+        );
+      }
+    }
+    if (request.method !== "POST") {
+      return new Response(null, { status: 405 });
+    }
+    let parsed;
+    try {
+      parsed = await request.json();
+    } catch {
+      return new Response(
+        JSON.stringify(createError(null, -32700, "Parse error")),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    if (sseHandlers?.sendTaskSubscribe) {
+      const requestObject2 = asRecord(parsed);
+      if (requestObject2?.method === "tasks/sendSubscribe") {
+        const params = asRecord(requestObject2.params);
+        if (!params) {
+          return new Response("Invalid params", { status: 400 });
+        }
+        const prompt = asString(params.prompt);
+        if (!prompt) {
+          return new Response("Prompt required", { status: 400 });
+        }
+        const taskId = params.taskId ? asString(params.taskId) : void 0;
+        const metadata = params.metadata ? asRecord(params.metadata) : void 0;
+        const eventStream = sseHandlers.sendTaskSubscribe({
+          prompt,
+          taskId: taskId ?? void 0,
+          metadata: metadata ?? void 0
+        });
+        return createSseResponse(eventStream);
+      }
+    }
+    if (Array.isArray(parsed)) {
+      return new Response(
+        JSON.stringify(createError(null, -32600, "Batch requests are not supported")),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const requestObject = asRecord(parsed);
+    if (!requestObject) {
+      return new Response(
+        JSON.stringify(createError(null, -32600, "Invalid Request")),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    const hasId = "id" in requestObject;
+    const normalizedRequest = {
+      jsonrpc: requestObject.jsonrpc,
+      id: hasId ? requestObject.id ?? null : null,
+      method: requestObject.method,
+      params: requestObject.params
+    };
+    if (!hasId) {
+      await jsonRpcHandler({ ...normalizedRequest, id: null });
+      return new Response(null, { status: 202 });
+    }
+    const response = await jsonRpcHandler(normalizedRequest);
+    return new Response(
+      JSON.stringify(response),
+      {
+        status: response.error ? 400 : 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  };
+}
+function createSseResponse(eventStream) {
+  const encoder = new TextEncoder();
+  const readableStream = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of eventStream) {
+          const sseData = `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+          controller.enqueue(encoder.encode(sseData));
+        }
+        controller.close();
+      } catch (error) {
+        const errorEvent = `event: error
+data: ${JSON.stringify({ error: String(error) })}
+
+`;
+        controller.enqueue(encoder.encode(errorEvent));
+        controller.close();
+      }
+    }
+  });
+  return new Response(readableStream, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive",
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Headers": "Content-Type"
+    }
+  });
+}
+function createA2ASseHandler(handlers) {
+  return (params) => {
+    if (!handlers.sendTaskSubscribe) {
+      throw new Error("sendTaskSubscribe handler not available");
+    }
+    return handlers.sendTaskSubscribe(params);
+  };
+}
+
+// src/plugins/a2a-delegation.ts
+var A2ADelegationManager = class {
+  agents = /* @__PURE__ */ new Map();
+  fetchImpl;
+  constructor(fetchImpl = globalThis.fetch) {
+    if (!fetchImpl) {
+      throw new Error("A2ADelegationManager requires a fetch implementation");
+    }
+    this.fetchImpl = fetchImpl;
+  }
+  register(agent) {
+    this.agents.set(agent.name, agent);
+  }
+  unregister(name) {
+    this.agents.delete(name);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  /**
+   * Find the best agent for a task based on required skills.
+   * Uses a simple skill overlap scoring system.
+   */
+  findAgent(requiredSkills) {
+    if (requiredSkills.length === 0) {
+      const agents = Array.from(this.agents.values());
+      return agents.length > 0 ? agents[0] : null;
+    }
+    let bestAgent = null;
+    let bestScore = 0;
+    for (const agent of this.agents.values()) {
+      const overlap = requiredSkills.filter(
+        (skill) => agent.skills.some(
+          (agentSkill) => agentSkill.toLowerCase().includes(skill.toLowerCase()) || skill.toLowerCase().includes(agentSkill.toLowerCase())
+        )
+      );
+      const score = overlap.length / requiredSkills.length;
+      if (score > bestScore) {
+        bestScore = score;
+        bestAgent = agent;
+      }
+    }
+    return bestAgent;
+  }
+  /**
+   * Delegate a task to the best matching agent.
+   */
+  async delegate(prompt, requiredSkills, fetchImpl = this.fetchImpl) {
+    const selectedAgent = this.findAgent(requiredSkills);
+    if (!selectedAgent) {
+      throw new Error("No suitable agent found for delegation");
+    }
+    const taskId = crypto.randomUUID();
+    const payload = {
+      jsonrpc: "2.0",
+      id: taskId,
+      method: "tasks/send",
+      params: {
+        prompt,
+        taskId,
+        metadata: { delegatedSkills: requiredSkills }
+      }
+    };
+    try {
+      const response = await fetchImpl(selectedAgent.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Agent endpoint returned HTTP ${response.status}`);
+      }
+      const result = await response.json();
+      if (result.error) {
+        throw new Error(`Agent error [${result.error.code}]: ${result.error.message}`);
+      }
+      return {
+        selectedAgent,
+        taskId,
+        result: result.result
+      };
+    } catch (error) {
+      throw new Error(`Delegation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// src/plugins/a2a-push.ts
+var A2APushNotifier = class _A2APushNotifier {
+  subscriptions = /* @__PURE__ */ new Map();
+  fetchImpl;
+  constructor(fetchImpl = globalThis.fetch) {
+    if (!fetchImpl) {
+      throw new Error("A2APushNotifier requires a fetch implementation");
+    }
+    this.fetchImpl = fetchImpl;
+  }
+  static BLOCKED_HEADERS = /* @__PURE__ */ new Set(["host", "authorization", "cookie", "content-type"]);
+  static LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "0.0.0.0"]);
+  subscribe(taskId, config) {
+    const parsed = new URL(config.url);
+    const isLocal = _A2APushNotifier.LOCAL_HOSTS.has(parsed.hostname) || parsed.hostname.startsWith("127.");
+    if (parsed.protocol !== "https:" && !isLocal) {
+      throw new Error("Push notification URL must use HTTPS");
+    }
+    if (parsed.protocol !== "https:" && isLocal && parsed.hostname !== "localhost" && parsed.hostname !== "127.0.0.1") {
+      throw new Error("Push notification URL must use HTTPS for non-standard local addresses");
+    }
+    if (config.headers) {
+      for (const key of Object.keys(config.headers)) {
+        if (_A2APushNotifier.BLOCKED_HEADERS.has(key.toLowerCase())) {
+          throw new Error(`Header "${key}" is not allowed in push notifications`);
+        }
+      }
+    }
+    const existing = this.subscriptions.get(taskId) ?? [];
+    existing.push(config);
+    this.subscriptions.set(taskId, existing);
+  }
+  unsubscribe(taskId, url) {
+    const existing = this.subscriptions.get(taskId) ?? [];
+    const filtered = existing.filter((config) => config.url !== url);
+    if (filtered.length === 0) {
+      this.subscriptions.delete(taskId);
+    } else {
+      this.subscriptions.set(taskId, filtered);
+    }
+  }
+  async notify(event) {
+    const configs = this.subscriptions.get(event.taskId) ?? [];
+    const promises = configs.map(async (config) => {
+      if (config.events && !config.events.includes(event.type)) {
+        return;
+      }
+      try {
+        await this.fetchImpl(config.url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers
+          },
+          body: JSON.stringify(event)
+        });
+      } catch (error) {
+        console.warn(`Push notification failed for ${config.url}:`, error);
+      }
+    });
+    await Promise.allSettled(promises);
+  }
+  cleanup(taskId) {
+    this.subscriptions.delete(taskId);
+  }
+};
+
+// src/plugins/a2a-durable-task-queue.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  initialBackoffMs: 250,
+  backoffMultiplier: 2,
+  maxBackoffMs: 3e4,
+  jitterRatio: 0
+};
+var DEFAULT_QUEUE_CONFIG = {
+  leaseDurationMs: 6e4,
+  retentionMs: 36e5,
+  maxTerminalTasks: 1e3,
+  retry: DEFAULT_RETRY_CONFIG
+};
+function cloneTask(task) {
+  return {
+    ...task,
+    metadata: task.metadata ? { ...task.metadata } : void 0
+  };
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+var A2ADurableTaskQueue = class {
+  entries = /* @__PURE__ */ new Map();
+  now;
+  idFactory;
+  config;
+  constructor(config = {}) {
+    const retry = {
+      ...DEFAULT_RETRY_CONFIG,
+      ...config.retry ?? {}
+    };
+    this.config = {
+      leaseDurationMs: config.leaseDurationMs ?? DEFAULT_QUEUE_CONFIG.leaseDurationMs,
+      retentionMs: config.retentionMs ?? DEFAULT_QUEUE_CONFIG.retentionMs,
+      maxTerminalTasks: config.maxTerminalTasks ?? DEFAULT_QUEUE_CONFIG.maxTerminalTasks,
+      retry,
+      now: config.now,
+      idFactory: config.idFactory
+    };
+    this.now = config.now ?? (() => Date.now());
+    this.idFactory = config.idFactory ?? (() => crypto.randomUUID());
+  }
+  get size() {
+    return this.entries.size;
+  }
+  enqueue(task, options = {}) {
+    if (this.entries.has(task.id)) {
+      throw new Error(`Task already exists: ${task.id}`);
+    }
+    const now = this.now();
+    const maxAttempts = Math.max(1, options.maxAttempts ?? this.config.retry.maxAttempts);
+    const normalizedTask = {
+      ...cloneTask(task),
+      status: "queued",
+      updatedAt: new Date(now).toISOString(),
+      completedAt: void 0
+    };
+    this.entries.set(task.id, {
+      task: normalizedTask,
+      attempts: 0,
+      maxAttempts,
+      nextAttemptAt: now
+    });
+    return cloneTask(normalizedTask);
+  }
+  get(taskId) {
+    this.resolveExpiredLeases();
+    const entry = this.entries.get(taskId);
+    if (!entry) return null;
+    return cloneTask(entry.task);
+  }
+  list() {
+    this.resolveExpiredLeases();
+    return [...this.entries.values()].map((entry) => cloneTask(entry.task));
+  }
+  acquire(taskId, workerId) {
+    this.resolveExpiredLeases();
+    const entry = this.entries.get(taskId);
+    if (!entry) return null;
+    const now = this.now();
+    if (entry.task.status !== "queued") return null;
+    if (entry.nextAttemptAt > now) return null;
+    entry.attempts += 1;
+    const leaseId = this.idFactory();
+    entry.lease = {
+      leaseId,
+      workerId,
+      expiresAt: now + this.config.leaseDurationMs
+    };
+    entry.task.status = "running";
+    entry.task.updatedAt = new Date(now).toISOString();
+    return {
+      taskId,
+      leaseId,
+      workerId,
+      expiresAt: new Date(entry.lease.expiresAt).toISOString(),
+      attempt: entry.attempts,
+      maxAttempts: entry.maxAttempts
+    };
+  }
+  extendLease(taskId, leaseId, leaseDurationMs) {
+    const entry = this.entries.get(taskId);
+    if (!entry || !entry.lease) return false;
+    if (entry.lease.leaseId !== leaseId) return false;
+    const duration = Math.max(1, leaseDurationMs ?? this.config.leaseDurationMs);
+    entry.lease.expiresAt = this.now() + duration;
+    return true;
+  }
+  complete(taskId, output, leaseId) {
+    const entry = this.entries.get(taskId);
+    if (!entry) return null;
+    if (isTerminalStatus(entry.task.status)) {
+      return cloneTask(entry.task);
+    }
+    if (!this.validateLease(entry, leaseId)) {
+      return null;
+    }
+    const nowIso = new Date(this.now()).toISOString();
+    entry.task.status = "completed";
+    entry.task.output = output;
+    entry.task.error = void 0;
+    entry.task.updatedAt = nowIso;
+    entry.task.completedAt = nowIso;
+    entry.lease = void 0;
+    entry.finishedAt = this.now();
+    return cloneTask(entry.task);
+  }
+  fail(taskId, error, leaseId) {
+    const entry = this.entries.get(taskId);
+    if (!entry) return null;
+    if (isTerminalStatus(entry.task.status)) {
+      return {
+        task: cloneTask(entry.task),
+        willRetry: false,
+        retryDelayMs: 0,
+        attempts: entry.attempts,
+        maxAttempts: entry.maxAttempts
+      };
+    }
+    if (!this.validateLease(entry, leaseId)) {
+      return null;
+    }
+    const now = this.now();
+    const nowIso = new Date(now).toISOString();
+    entry.task.error = error;
+    entry.task.updatedAt = nowIso;
+    entry.lease = void 0;
+    if (entry.attempts < entry.maxAttempts) {
+      const retryDelayMs = this.computeBackoffDelay(entry.attempts);
+      entry.task.status = "queued";
+      entry.task.completedAt = void 0;
+      entry.nextAttemptAt = now + retryDelayMs;
+      return {
+        task: cloneTask(entry.task),
+        willRetry: true,
+        retryDelayMs,
+        attempts: entry.attempts,
+        maxAttempts: entry.maxAttempts
+      };
+    }
+    entry.task.status = "failed";
+    entry.task.completedAt = nowIso;
+    entry.finishedAt = now;
+    return {
+      task: cloneTask(entry.task),
+      willRetry: false,
+      retryDelayMs: 0,
+      attempts: entry.attempts,
+      maxAttempts: entry.maxAttempts
+    };
+  }
+  cancel(taskId) {
+    const entry = this.entries.get(taskId);
+    if (!entry) return null;
+    if (isTerminalStatus(entry.task.status)) {
+      return cloneTask(entry.task);
+    }
+    const nowIso = new Date(this.now()).toISOString();
+    entry.task.status = "cancelled";
+    entry.task.updatedAt = nowIso;
+    entry.task.completedAt = nowIso;
+    entry.lease = void 0;
+    entry.finishedAt = this.now();
+    return cloneTask(entry.task);
+  }
+  evictExpired() {
+    const now = this.now();
+    this.resolveExpiredLeases();
+    const terminals = [];
+    for (const [taskId, entry] of this.entries) {
+      if (!isTerminalStatus(entry.task.status)) continue;
+      const finishedAt = entry.finishedAt ?? Date.parse(entry.task.updatedAt);
+      if (now - finishedAt > this.config.retentionMs) {
+        this.entries.delete(taskId);
+        continue;
+      }
+      terminals.push({ taskId, finishedAt });
+    }
+    if (terminals.length <= this.config.maxTerminalTasks) return;
+    terminals.sort((a, b) => a.finishedAt - b.finishedAt).slice(0, terminals.length - this.config.maxTerminalTasks).forEach(({ taskId }) => this.entries.delete(taskId));
+  }
+  snapshot() {
+    this.resolveExpiredLeases();
+    return {
+      version: 1,
+      entries: [...this.entries.values()].map((entry) => ({
+        task: cloneTask(entry.task),
+        attempts: entry.attempts,
+        maxAttempts: entry.maxAttempts,
+        nextAttemptAt: entry.nextAttemptAt,
+        finishedAt: entry.finishedAt,
+        lease: entry.lease ? {
+          leaseId: entry.lease.leaseId,
+          workerId: entry.lease.workerId,
+          expiresAt: entry.lease.expiresAt
+        } : void 0
+      }))
+    };
+  }
+  hydrate(snapshot) {
+    this.entries.clear();
+    if (!snapshot || snapshot.version !== 1) return;
+    for (const item of snapshot.entries) {
+      this.entries.set(item.task.id, {
+        task: cloneTask(item.task),
+        attempts: item.attempts,
+        maxAttempts: item.maxAttempts,
+        nextAttemptAt: item.nextAttemptAt,
+        finishedAt: item.finishedAt,
+        lease: item.lease ? {
+          leaseId: item.lease.leaseId,
+          workerId: item.lease.workerId,
+          expiresAt: item.lease.expiresAt
+        } : void 0
+      });
+    }
+    this.resolveExpiredLeases();
+  }
+  validateLease(entry, leaseId) {
+    if (!entry.lease) return true;
+    if (!leaseId) return false;
+    if (entry.lease.leaseId !== leaseId) return false;
+    if (entry.lease.expiresAt <= this.now()) return false;
+    return true;
+  }
+  resolveExpiredLeases() {
+    const now = this.now();
+    for (const entry of this.entries.values()) {
+      if (!entry.lease) continue;
+      if (entry.lease.expiresAt > now) continue;
+      if (entry.task.status !== "running") {
+        entry.lease = void 0;
+        continue;
+      }
+      entry.lease = void 0;
+      entry.task.error = "Task lease expired before completion";
+      entry.task.updatedAt = new Date(now).toISOString();
+      if (entry.attempts < entry.maxAttempts) {
+        const retryDelayMs = this.computeBackoffDelay(entry.attempts);
+        entry.task.status = "queued";
+        entry.task.completedAt = void 0;
+        entry.nextAttemptAt = now + retryDelayMs;
+      } else {
+        entry.task.status = "failed";
+        entry.task.completedAt = new Date(now).toISOString();
+        entry.finishedAt = now;
+      }
+    }
+  }
+  computeBackoffDelay(attempt) {
+    const base = Math.max(1, this.config.retry.initialBackoffMs);
+    const multiplier = Math.max(1, this.config.retry.backoffMultiplier);
+    const capped = Math.min(
+      this.config.retry.maxBackoffMs,
+      Math.round(base * Math.pow(multiplier, Math.max(0, attempt - 1)))
+    );
+    const jitterRatio = Math.max(0, Math.min(1, this.config.retry.jitterRatio));
+    if (jitterRatio === 0) return capped;
+    const jitterMax = Math.round(capped * jitterRatio);
+    const jitter = Math.floor(Math.random() * (jitterMax + 1));
+    return Math.min(this.config.retry.maxBackoffMs, capped + jitter);
+  }
+};
+
+// src/plugins/a2a.plugin.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY_CONFIG2 = {
+  maxAttempts: 3,
+  initialBackoffMs: 250,
+  backoffMultiplier: 2,
+  maxBackoffMs: 3e4,
+  jitterRatio: 0
+};
+var A2A_CALL_SCHEMA = z2.object({
+  endpoint: z2.string().url(),
+  method: z2.enum(["tasks/send", "tasks/get", "tasks/list", "tasks/cancel", "agent/card", "health"]).default("tasks/send"),
+  prompt: z2.string().optional(),
+  taskId: z2.string().optional(),
+  params: z2.record(z2.string(), z2.unknown()).optional()
+});
+var A2A_DELEGATE_SCHEMA = z2.object({
+  prompt: z2.string(),
+  requiredSkills: z2.array(z2.string()).default([])
+});
+var A2A_DISCOVER_SCHEMA = z2.object({
+  endpoint: z2.string().url()
+});
+var A2A_SUBSCRIBE_SCHEMA = z2.object({
+  endpoint: z2.string().url(),
+  prompt: z2.string(),
+  taskId: z2.string().optional()
+});
+var A2APlugin = class _A2APlugin {
+  name = "a2a";
+  version = "1.0.0";
+  tools;
+  fetchImpl;
+  requestTimeoutMs;
+  agentCardProvider;
+  taskQueue;
+  persistQueueStateEnabled;
+  delegationManager;
+  pushNotifier;
+  taskEventListeners = /* @__PURE__ */ new Set();
+  static QUEUE_SNAPSHOT_KEY = "a2a:durable-task-queue:v1";
+  static DEFAULT_MAX_TERMINAL_TASKS = 1e3;
+  static DEFAULT_RETENTION_MS = 36e5;
+  // 1 hour
+  evictionTimer;
+  queueHydrated = false;
+  queueHydrationPromise = null;
+  setupCtx;
+  latestCtx;
+  hooks = {
+    beforeRun: async (ctx, _params) => {
+      this.latestCtx = ctx;
+      if (this.isQueueManagedRun(ctx)) return;
+      const taskId = this.getTaskIdFromContext(ctx);
+      if (!taskId) return;
+      this.markTaskRunning(taskId, this.getLeaseIdFromContext(ctx));
+    },
+    afterRun: async (ctx, params) => {
+      this.latestCtx = ctx;
+      if (this.isQueueManagedRun(ctx)) return;
+      const taskId = this.getTaskIdFromContext(ctx);
+      if (!taskId) return;
+      this.markTaskCompleted(taskId, params.result.text, this.getLeaseIdFromContext(ctx));
+    },
+    onError: async (ctx, params) => {
+      if (this.isQueueManagedRun(ctx)) return;
+      const taskId = this.getTaskIdFromContext(ctx);
+      if (!taskId) return;
+      this.markTaskFailed(taskId, params.error, this.getLeaseIdFromContext(ctx));
+    }
+  };
+  constructor(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new Error("A2APlugin requires a fetch implementation");
+    }
+    this.fetchImpl = fetchImpl;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.agentCardProvider = options.agentCardProvider;
+    this.persistQueueStateEnabled = options.persistQueueState ?? true;
+    this.delegationManager = new A2ADelegationManager(fetchImpl);
+    this.pushNotifier = new A2APushNotifier(fetchImpl);
+    const normalizedRetry = options.retry ? {
+      maxAttempts: options.retry.maxAttempts ?? DEFAULT_RETRY_CONFIG2.maxAttempts,
+      initialBackoffMs: options.retry.initialBackoffMs ?? DEFAULT_RETRY_CONFIG2.initialBackoffMs,
+      backoffMultiplier: options.retry.backoffMultiplier ?? DEFAULT_RETRY_CONFIG2.backoffMultiplier,
+      maxBackoffMs: options.retry.maxBackoffMs ?? DEFAULT_RETRY_CONFIG2.maxBackoffMs,
+      jitterRatio: options.retry.jitterRatio ?? DEFAULT_RETRY_CONFIG2.jitterRatio
+    } : void 0;
+    this.taskQueue = options.taskQueue ?? new A2ADurableTaskQueue({
+      leaseDurationMs: options.queue?.leaseDurationMs,
+      retentionMs: options.queue?.retentionMs ?? _A2APlugin.DEFAULT_RETENTION_MS,
+      maxTerminalTasks: options.queue?.maxTerminalTasks ?? _A2APlugin.DEFAULT_MAX_TERMINAL_TASKS,
+      retry: normalizedRetry
+    });
+    this.evictionTimer = setInterval(() => this.evictStaleTasks(), 6e4);
+    this.tools = {
+      "a2a:call": tool({
+        description: "Call an external A2A-compatible JSON-RPC endpoint.",
+        inputSchema: A2A_CALL_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_CALL_SCHEMA.parse(input ?? {});
+          const params = this.normalizeCallParams(args);
+          const payload = {
+            jsonrpc: "2.0",
+            id: crypto.randomUUID(),
+            method: args.method,
+            params
+          };
+          const response = await this.callRemoteEndpoint(args.endpoint, payload);
+          if (response.error) {
+            throw new Error(`[A2A ${response.error.code}] ${response.error.message}`);
+          }
+          return response.result;
+        }
+      }),
+      "a2a:delegate": tool({
+        description: "Delegate a task to a registered agent based on required skills.",
+        inputSchema: A2A_DELEGATE_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_DELEGATE_SCHEMA.parse(input ?? {});
+          return await this.delegationManager.delegate(args.prompt, args.requiredSkills, this.fetchImpl);
+        }
+      }),
+      "a2a:discover": tool({
+        description: "Discover agent capabilities at an A2A endpoint.",
+        inputSchema: A2A_DISCOVER_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_DISCOVER_SCHEMA.parse(input ?? {});
+          return await this.discoverAgent(args.endpoint);
+        }
+      }),
+      "a2a:subscribe": tool({
+        description: "Subscribe to task status updates via Server-Sent Events.",
+        inputSchema: A2A_SUBSCRIBE_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_SUBSCRIBE_SCHEMA.parse(input ?? {});
+          return await this.subscribeToTask(args.endpoint, args.prompt, args.taskId);
+        }
+      })
+    };
+  }
+  setup(ctx) {
+    this.setupCtx = ctx;
+    void this.ensureQueueHydrated();
+  }
+  dispose() {
+    if (this.evictionTimer) {
+      clearInterval(this.evictionTimer);
+      this.evictionTimer = void 0;
+    }
+    void this.persistQueueState();
+  }
+  createJsonRpcHandler(agent) {
+    const plugin = this;
+    const sendTaskSubscribe = async function* (params) {
+      await plugin.ensureQueueHydrated();
+      const taskId = params.taskId ?? crypto.randomUUID();
+      const eventQueue = [];
+      let completed = false;
+      let pending;
+      function createDeferred() {
+        let resolve;
+        const promise = new Promise((r) => {
+          resolve = r;
+        });
+        return { promise, resolve };
+      }
+      pending = createDeferred();
+      const eventListener = (event) => {
+        if (event.taskId === taskId) {
+          eventQueue.push(event);
+          if (event.type === "task:completed" || event.type === "task:failed" || event.type === "task:cancelled") {
+            completed = true;
+          }
+          pending.resolve();
+          pending = createDeferred();
+        }
+      };
+      plugin.taskEventListeners.add(eventListener);
+      plugin.queueTask(taskId, params.prompt, params.metadata);
+      try {
+        const runPromise = plugin.executeTaskWithRetry(agent, taskId, params);
+        let lastEventIndex = 0;
+        while (!completed) {
+          if (eventQueue.length <= lastEventIndex) {
+            await pending.promise;
+          }
+          for (let i = lastEventIndex; i < eventQueue.length; i++) {
+            yield eventQueue[i];
+          }
+          lastEventIndex = eventQueue.length;
+        }
+        await runPromise;
+        if (eventQueue.length > lastEventIndex) {
+          for (let i = lastEventIndex; i < eventQueue.length; i++) {
+            yield eventQueue[i];
+          }
+        }
+      } finally {
+        plugin.taskEventListeners.delete(eventListener);
+      }
+    };
+    const jsonRpcHandler = createA2AJsonRpcHandler({
+      sendTask: async (params) => {
+        await plugin.ensureQueueHydrated();
+        const taskId = params.taskId ?? crypto.randomUUID();
+        plugin.queueTask(taskId, params.prompt, params.metadata);
+        await plugin.executeTaskWithRetry(agent, taskId, params);
+        return plugin.cloneTask(taskId);
+      },
+      sendTaskSubscribe,
+      getTask: async (taskId) => {
+        await plugin.ensureQueueHydrated();
+        return plugin.getTask(taskId);
+      },
+      listTasks: async () => {
+        await plugin.ensureQueueHydrated();
+        return plugin.listTasks();
+      },
+      cancelTask: async (taskId) => {
+        await plugin.ensureQueueHydrated();
+        const previous = plugin.taskQueue.get(taskId);
+        if (!previous) return null;
+        const cancelled = plugin.taskQueue.cancel(taskId);
+        if (!cancelled) return null;
+        if (previous.status !== "cancelled" && previous.status !== "completed" && previous.status !== "failed") {
+          plugin.emitTaskEvent("task:cancelled", taskId);
+        }
+        void plugin.persistQueueState();
+        return cancelled;
+      },
+      getAgentCard: async () => {
+        return plugin.resolveAgentCard();
+      }
+    });
+    jsonRpcHandler.sendTaskSubscribe = sendTaskSubscribe;
+    return jsonRpcHandler;
+  }
+  createHttpHandler(agent) {
+    const handler = this.createJsonRpcHandler(agent);
+    return createA2AHttpHandler(handler, {
+      sendTaskSubscribe: async function* (params) {
+        for await (const event of handler.sendTaskSubscribe(params)) {
+          yield event;
+        }
+      }
+    });
+  }
+  getTask(taskId) {
+    return this.taskQueue.get(taskId);
+  }
+  listTasks() {
+    return this.taskQueue.list();
+  }
+  // Delegation methods
+  registerAgent(agent) {
+    this.delegationManager.register(agent);
+  }
+  unregisterAgent(name) {
+    this.delegationManager.unregister(name);
+  }
+  listAgents() {
+    return this.delegationManager.listAgents();
+  }
+  async delegateTask(prompt, requiredSkills) {
+    return await this.delegationManager.delegate(prompt, requiredSkills, this.fetchImpl);
+  }
+  // Push notification methods
+  subscribeToTaskNotifications(taskId, config) {
+    this.pushNotifier.subscribe(taskId, config);
+  }
+  unsubscribeFromTaskNotifications(taskId, url) {
+    this.pushNotifier.unsubscribe(taskId, url);
+  }
+  normalizeCallParams(args) {
+    if (args.params) {
+      return {
+        ...args.params,
+        ...args.prompt !== void 0 ? { prompt: args.prompt } : {},
+        ...args.taskId !== void 0 ? { taskId: args.taskId } : {}
+      };
+    }
+    if (args.method === "tasks/send") {
+      if (!args.prompt) {
+        throw new Error("a2a:call requires `prompt` for tasks/send requests");
+      }
+      return {
+        prompt: args.prompt,
+        ...args.taskId !== void 0 ? { taskId: args.taskId } : {}
+      };
+    }
+    if (args.method === "tasks/get" || args.method === "tasks/cancel") {
+      if (!args.taskId) {
+        throw new Error(`a2a:call requires \`taskId\` for ${args.method}`);
+      }
+      return { taskId: args.taskId };
+    }
+    return {};
+  }
+  async callRemoteEndpoint(endpoint, payload) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+    try {
+      const response = await this.fetchImpl(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`A2A endpoint returned HTTP ${response.status}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  queueTask(taskId, prompt, metadata) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.taskQueue.enqueue({
+      id: taskId,
+      status: "queued",
+      prompt,
+      metadata,
+      createdAt: now,
+      updatedAt: now
+    });
+    this.emitTaskEvent("task:queued", taskId);
+    void this.persistQueueState();
+  }
+  markTaskRunning(taskId, _leaseId) {
+    const lease = this.taskQueue.acquire(taskId, this.createWorkerId(taskId));
+    if (!lease) return null;
+    this.emitTaskEvent("task:running", taskId);
+    void this.persistQueueState();
+    return lease;
+  }
+  markTaskCompleted(taskId, output, leaseId) {
+    const before = this.taskQueue.get(taskId);
+    const completed = this.taskQueue.complete(taskId, output, leaseId);
+    if (!completed) return;
+    if (before?.status !== "completed") {
+      this.emitTaskEvent("task:completed", taskId);
+    }
+    void this.persistQueueState();
+  }
+  markTaskFailed(taskId, error, leaseId) {
+    const result = this.taskQueue.fail(taskId, this.normalizeError(error), leaseId);
+    if (!result) return;
+    if (result.willRetry) {
+      this.emitTaskEvent("task:queued", taskId);
+    } else {
+      this.emitTaskEvent("task:failed", taskId);
+    }
+    void this.persistQueueState();
+  }
+  async executeTaskWithRetry(agent, taskId, params) {
+    while (true) {
+      const task = this.taskQueue.get(taskId);
+      if (!task || task.status === "cancelled" || task.status === "completed" || task.status === "failed") {
+        return;
+      }
+      const lease = this.markTaskRunning(taskId);
+      if (!lease) {
+        await this.sleep(10);
+        continue;
+      }
+      const runMetadata = {
+        ...params.metadata ?? {},
+        a2aTaskId: taskId,
+        a2aLeaseId: lease.leaseId,
+        a2aAttempt: lease.attempt,
+        a2aManagedByQueue: true
+      };
+      try {
+        const result = await agent.run(params.prompt, { pluginMetadata: runMetadata });
+        this.markTaskCompleted(taskId, result.text, lease.leaseId);
+        return;
+      } catch (error) {
+        const failed = this.taskQueue.fail(taskId, this.normalizeError(error), lease.leaseId);
+        if (!failed) return;
+        if (!failed.willRetry) {
+          this.emitTaskEvent("task:failed", taskId);
+          void this.persistQueueState();
+          return;
+        }
+        this.emitTaskEvent("task:queued", taskId);
+        void this.persistQueueState();
+        await this.sleep(failed.retryDelayMs);
+      }
+    }
+  }
+  evictStaleTasks() {
+    const before = new Set(this.taskQueue.list().map((task) => task.id));
+    this.taskQueue.evictExpired();
+    const after = new Set(this.taskQueue.list().map((task) => task.id));
+    for (const taskId of before) {
+      if (!after.has(taskId)) {
+        this.pushNotifier.cleanup(taskId);
+      }
+    }
+    void this.persistQueueState();
+  }
+  emitTaskEvent(type, taskId) {
+    const task = this.taskQueue.get(taskId);
+    if (!task) return;
+    const event = {
+      type,
+      taskId,
+      task,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    for (const listener of this.taskEventListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.warn("Task event listener error:", error);
+      }
+    }
+    this.pushNotifier.notify(event).catch((error) => {
+      console.warn("Push notification error:", error);
+    });
+  }
+  createWorkerId(taskId) {
+    const sessionId = this.latestCtx?.sessionId ?? this.setupCtx?.sessionId ?? "a2a";
+    return `${sessionId}:${taskId}`;
+  }
+  normalizeError(error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  async ensureQueueHydrated() {
+    if (this.queueHydrated) return;
+    if (this.queueHydrationPromise) {
+      await this.queueHydrationPromise;
+      return;
+    }
+    this.queueHydrationPromise = this.hydrateQueueFromMemory();
+    try {
+      await this.queueHydrationPromise;
+      this.queueHydrated = true;
+    } finally {
+      this.queueHydrationPromise = null;
+    }
+  }
+  async hydrateQueueFromMemory() {
+    if (!this.persistQueueStateEnabled || !this.setupCtx) return;
+    try {
+      const snapshot = await this.setupCtx.memory.loadMetadata(
+        this.setupCtx.sessionId,
+        _A2APlugin.QUEUE_SNAPSHOT_KEY
+      );
+      if (snapshot) {
+        this.taskQueue.hydrate(snapshot);
+      }
+    } catch (error) {
+      console.warn("A2A queue hydration failed:", error);
+    }
+  }
+  async persistQueueState() {
+    if (!this.persistQueueStateEnabled || !this.setupCtx) return;
+    try {
+      await this.setupCtx.memory.saveMetadata(
+        this.setupCtx.sessionId,
+        _A2APlugin.QUEUE_SNAPSHOT_KEY,
+        this.taskQueue.snapshot()
+      );
+    } catch (error) {
+      console.warn("A2A queue persistence failed:", error);
+    }
+  }
+  sleep(ms) {
+    if (ms <= 0) return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async discoverAgent(endpoint) {
+    try {
+      const discoveryUrl = new URL("/.well-known/agent.json", endpoint).toString();
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+      try {
+        const discoveryResponse = await this.fetchImpl(discoveryUrl, { signal: controller.signal });
+        if (discoveryResponse.ok) {
+          const discoveryData = await discoveryResponse.json();
+          return {
+            name: discoveryData.name,
+            description: discoveryData.description,
+            skills: discoveryData.skills?.map((s) => s.name) ?? [],
+            endpoint
+          };
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch {
+    }
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto.randomUUID(),
+      method: "agent/card"
+    };
+    const response = await this.callRemoteEndpoint(endpoint, payload);
+    if (response.error) {
+      throw new Error(`Failed to discover agent: ${response.error.message}`);
+    }
+    const card = response.result;
+    return {
+      name: card?.name ?? "Unknown Agent",
+      description: card?.instructions ?? "No description",
+      skills: card?.tools ?? [],
+      endpoint
+    };
+  }
+  async subscribeToTask(endpoint, prompt, taskId) {
+    const payload = {
+      jsonrpc: "2.0",
+      id: crypto.randomUUID(),
+      method: "tasks/sendSubscribe",
+      params: { prompt, taskId }
+    };
+    const sseTimeoutMs = this.requestTimeoutMs * 5;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), sseTimeoutMs);
+    try {
+      const response = await this.fetchImpl(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream"
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`SSE subscription failed with HTTP ${response.status}`);
+      }
+      const events = [];
+      let sseCompleted = false;
+      const reader = response.body?.getReader();
+      const decoder = new TextDecoder();
+      if (!reader) {
+        throw new Error("No response body for SSE stream");
+      }
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const segments = buffer.split("\n");
+          buffer = segments.pop() ?? "";
+          for (const line of segments) {
+            if (line.startsWith("data: ")) {
+              try {
+                const eventData = JSON.parse(line.substring(6));
+                events.push(eventData);
+                if (eventData.type === "task:completed" || eventData.type === "task:failed" || eventData.type === "task:cancelled") {
+                  sseCompleted = true;
+                }
+              } catch {
+              }
+            }
+          }
+          if (sseCompleted) {
+            break;
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      return {
+        message: "Task subscription completed",
+        events
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  getTaskIdFromContext(ctx) {
+    const raw = ctx.runMetadata?.a2aTaskId;
+    return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+  }
+  getLeaseIdFromContext(ctx) {
+    const raw = ctx.runMetadata?.a2aLeaseId;
+    return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+  }
+  isQueueManagedRun(ctx) {
+    return ctx.runMetadata?.a2aManagedByQueue === true;
+  }
+  async resolveAgentCard() {
+    if (this.agentCardProvider) {
+      return this.agentCardProvider.getAgentCard();
+    }
+    const ctx = this.latestCtx ?? this.setupCtx;
+    if (!ctx) {
+      return {
+        name: "Agent",
+        instructions: "",
+        tools: []
+      };
+    }
+    return {
+      name: ctx.agentName ?? "Agent",
+      sessionId: ctx.sessionId,
+      instructions: ctx.config.instructions,
+      maxSteps: ctx.config.maxSteps,
+      tools: [...ctx.toolNames]
+    };
+  }
+  cloneTask(taskId) {
+    const task = this.taskQueue.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+  }
+};
+function createA2APlugin(options) {
+  return new A2APlugin(options);
+}
+
+// src/adapters/validation/zod-validation.adapter.ts
+var ZodValidationAdapter = class {
+  validate(schema, data) {
+    const zodSchema = schema;
+    const result = zodSchema.safeParse(data);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error.message };
+  }
+  validateOrThrow(schema, data) {
+    const zodSchema = schema;
+    return zodSchema.parse(data);
+  }
+};
+
+// src/plugins/utils/get-validator.ts
+function getValidator(options) {
+  return options.validator ?? new ZodValidationAdapter();
+}
+
+// src/plugins/guardrails.plugin.ts
+var GuardrailsError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "GuardrailsError";
+    this.code = code;
+  }
+};
+var GuardrailsPlugin = class extends BasePlugin {
+  name = "guardrails";
+  options;
+  validator;
+  constructor(options = {}) {
+    super();
+    this.validator = getValidator(options);
+    this.options = {
+      onFailure: options.onFailure ?? "throw",
+      contentFilters: options.contentFilters ?? [],
+      inputValidators: options.inputValidators ?? [],
+      outputValidators: options.outputValidators ?? [],
+      inputSchema: options.inputSchema,
+      outputSchema: options.outputSchema,
+      toolSchemas: options.toolSchemas
+    };
+  }
+  buildHooks() {
+    return {
+      beforeRun: this.beforeRun.bind(this),
+      afterRun: this.afterRun.bind(this),
+      beforeTool: this.beforeTool.bind(this)
+    };
+  }
+  // ── Hook implementations ──────────────────────────────────────────────────
+  beforeRun(_ctx, params) {
+    const { prompt } = params;
+    for (const filter of this.options.contentFilters) {
+      if (filter.test(prompt)) {
+        this.fail("content_filter", `Content filter "${filter.name}" matched input`);
+      }
+    }
+    for (const validator of this.options.inputValidators) {
+      const error = validator(prompt);
+      if (error) {
+        this.fail("input_validation", error);
+      }
+    }
+    if (this.options.inputSchema) {
+      const result = this.validator.validate(this.options.inputSchema, prompt);
+      if (!result.success) {
+        this.fail("input_validation", `Input schema validation failed: ${result.error}`);
+      }
+    }
+    return { prompt };
+  }
+  afterRun(_ctx, params) {
+    const { text } = params.result;
+    for (const filter of this.options.contentFilters) {
+      if (filter.test(text)) {
+        this.fail("content_filter", `Content filter "${filter.name}" matched output`);
+      }
+    }
+    for (const validator of this.options.outputValidators) {
+      const error = validator(text);
+      if (error) {
+        this.fail("output_validation", error);
+      }
+    }
+    if (this.options.outputSchema) {
+      const result = this.validator.validate(this.options.outputSchema, text);
+      if (!result.success) {
+        this.fail("output_validation", `Output schema validation failed: ${result.error}`);
+      }
+    }
+  }
+  beforeTool(_ctx, params) {
+    const schema = this.options.toolSchemas?.[params.toolName];
+    if (!schema) return;
+    const result = this.validator.validate(schema, params.args);
+    if (!result.success) {
+      this.fail("tool_validation", `Tool "${params.toolName}" args validation failed: ${result.error}`);
+    }
+  }
+  // ── Helpers ───────────────────────────────────────────────────────────────
+  fail(code, message) {
+    if (this.options.onFailure === "warn") {
+      console.warn(`[guardrails] ${message}`);
+      return;
+    }
+    throw new GuardrailsError(code, message);
+  }
+};
+function createGuardrailsPlugin(options = {}) {
+  return new GuardrailsPlugin(options);
+}
+function createPiiFilter() {
+  return {
+    name: "pii",
+    test(content) {
+      const patterns = [
+        /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/,
+        // email
+        /\b\d{3}[-.]?\d{2}[-.]?\d{4}\b/,
+        // SSN
+        /\b\d{16}\b/
+        // credit card (basic)
+      ];
+      return patterns.some((p) => p.test(content));
+    }
+  };
+}
+
+// src/plugins/onecrawl.plugin.ts
+import { z as z3 } from "zod";
+var DEFAULT_REQUEST_TIMEOUT_MS2 = 3e4;
+var OneCrawlPlugin = class extends BasePlugin {
+  name = "crawl";
+  options;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  crawlerPromise = null;
+  validator;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.validator = getValidator(options);
+  }
+  buildHooks() {
+    return {};
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getCrawler() {
+    if (!this.crawlerPromise) {
+      this.crawlerPromise = this.initCrawler();
+    }
+    return this.crawlerPromise;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async initCrawler() {
+    if (this.options.crawler) {
+      return this.options.crawler;
+    }
+    try {
+      const mod = await import("onecrawl");
+      const CrawlerClass = mod.Crawler ?? mod.default?.Crawler ?? mod.default;
+      return new CrawlerClass({
+        timeout: this.options.timeout ?? DEFAULT_REQUEST_TIMEOUT_MS2
+      });
+    } catch {
+      throw new Error(
+        'OneCrawlPlugin requires "onecrawl" package. Install it: pnpm add onecrawl'
+      );
+    }
+  }
+  get tools() {
+    const maxLen = this.options.maxContentLength ?? 1e4;
+    const getCrawler = this.getCrawler.bind(this);
+    const validator = this.validator;
+    return {
+      scrape: tool({
+        description: "Scrape a web page and extract its text content",
+        inputSchema: z3.object({
+          url: z3.string().url().describe("The URL to scrape")
+        }),
+        execute: async (args) => {
+          const { url } = validator.validateOrThrow(
+            z3.object({ url: z3.string().url() }),
+            args
+          );
+          const crawler = await getCrawler();
+          const result = await crawler.crawl(url);
+          const content = typeof result === "string" ? result : result?.content ?? result?.text ?? JSON.stringify(result);
+          return content.length > maxLen ? content.slice(0, maxLen) + "\n...[truncated]" : content;
+        }
+      }),
+      search: tool({
+        description: "Search the web and return results",
+        inputSchema: z3.object({
+          query: z3.string().describe("The search query"),
+          limit: z3.number().min(1).max(20).default(5).describe("Max results to return")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            z3.object({
+              query: z3.string(),
+              limit: z3.number().min(1).max(20).default(5)
+            }),
+            args
+          );
+          const crawler = await getCrawler();
+          const results = await crawler.search(query, { limit });
+          if (Array.isArray(results)) {
+            return results.map((r) => ({
+              title: r.title ?? "",
+              url: r.url ?? r.link ?? "",
+              snippet: r.snippet ?? r.description ?? ""
+            }));
+          }
+          return results;
+        }
+      }),
+      batch: tool({
+        description: "Scrape multiple web pages in parallel",
+        inputSchema: z3.object({
+          urls: z3.array(z3.string().url()).min(1).max(10).describe("URLs to scrape")
+        }),
+        execute: async (args) => {
+          const { urls } = validator.validateOrThrow(
+            z3.object({ urls: z3.array(z3.string().url()).min(1).max(10) }),
+            args
+          );
+          const crawler = await getCrawler();
+          if (typeof crawler.batchCrawl === "function") {
+            const results2 = await crawler.batchCrawl(urls);
+            return Array.isArray(results2) ? results2.map((r, i) => ({
+              url: urls[i],
+              content: (typeof r === "string" ? r : r?.content ?? r?.text ?? "").slice(0, maxLen)
+            })) : results2;
+          }
+          const results = await Promise.all(
+            urls.map(async (u) => {
+              try {
+                const r = await crawler.crawl(u);
+                const content = typeof r === "string" ? r : r?.content ?? r?.text ?? "";
+                return { url: u, content: content.slice(0, maxLen) };
+              } catch (error) {
+                return { url: u, error: String(error) };
+              }
+            })
+          );
+          return results;
+        }
+      })
+    };
+  }
+  async dispose() {
+    if (this.crawlerPromise) {
+      try {
+        const crawler = await this.crawlerPromise;
+        if (crawler && typeof crawler.close === "function") {
+          await crawler.close();
+        }
+      } catch {
+      }
+      this.crawlerPromise = null;
+    }
+  }
+};
+function createOneCrawlPlugin(options = {}) {
+  return new OneCrawlPlugin(options);
+}
+
+// src/plugins/vectorless.plugin.ts
+import { z as z4 } from "zod";
+
+// src/adapters/chunking/default-chunking.adapter.ts
+import { randomUUID } from "crypto";
+var DEFAULT_MAX_TOKENS = 512;
+var DEFAULT_OVERLAP = 50;
+var DEFAULT_SEPARATORS = ["\n\n", "\n", ". ", " "];
+function wordCount(text) {
+  let count = 0;
+  const re = /\S+/g;
+  while (re.exec(text) !== null) count++;
+  return count;
+}
+function makeChunk(text, index, startOffset, source) {
+  return {
+    id: randomUUID(),
+    text,
+    index,
+    metadata: {
+      startOffset,
+      endOffset: startOffset + text.length,
+      tokenCount: wordCount(text),
+      source
+    }
+  };
+}
+function getWordPositions(text) {
+  const positions = [];
+  const regex = /\S+/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    positions.push({ word: match[0], start: match.index, end: match.index + match[0].length });
+  }
+  return positions;
+}
+function splitByWordsMax(text, maxTokens) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const parts = [];
+  for (let i = 0; i < words.length; i += maxTokens) {
+    parts.push(words.slice(i, i + maxTokens).join(" "));
+  }
+  return parts;
+}
+function chunkFixed(text, maxTokens) {
+  return splitByWordsMax(text, maxTokens);
+}
+function chunkSlidingWindow(text, maxTokens, overlap) {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [];
+  const step = Math.max(1, maxTokens - overlap);
+  const chunks = [];
+  for (let i = 0; i < words.length; i += step) {
+    chunks.push(words.slice(i, i + maxTokens).join(" "));
+    if (i + maxTokens >= words.length) break;
+  }
+  return chunks;
+}
+function chunkSemantic(text, maxTokens) {
+  const paragraphs = text.split(/\n\n+/).filter(Boolean);
+  const chunks = [];
+  let current = "";
+  for (const para of paragraphs) {
+    const candidate = current ? `${current}
+
+${para}` : para;
+    const candidateWc = wordCount(candidate);
+    if (candidateWc <= maxTokens) {
+      current = candidate;
+    } else {
+      if (current) chunks.push(current);
+      const paraWc = current ? wordCount(para) : candidateWc;
+      if (paraWc > maxTokens) {
+        const sentences = para.split(/(?<=[.!?])\s+/).filter(Boolean);
+        let sentBuf = "";
+        for (const s of sentences) {
+          const next = sentBuf ? `${sentBuf} ${s}` : s;
+          const nextWc = wordCount(next);
+          if (nextWc <= maxTokens) {
+            sentBuf = next;
+          } else {
+            if (sentBuf) chunks.push(sentBuf);
+            const sWc = sentBuf ? wordCount(s) : nextWc;
+            if (sWc > maxTokens) {
+              chunks.push(...splitByWordsMax(s, maxTokens));
+              sentBuf = "";
+            } else {
+              sentBuf = s;
+            }
+          }
+        }
+        current = sentBuf;
+      } else {
+        current = para;
+      }
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks;
+}
+function chunkRecursive(text, maxTokens, separators) {
+  const wc = wordCount(text);
+  if (wc <= maxTokens || separators.length === 0) {
+    if (wc > maxTokens) return splitByWordsMax(text, maxTokens);
+    return [text];
+  }
+  const sep = separators[0];
+  const rest = separators.slice(1);
+  const parts = text.split(sep).filter(Boolean);
+  const results = [];
+  let buffer = "";
+  for (const part of parts) {
+    const candidate = buffer ? `${buffer}${sep}${part}` : part;
+    const candidateWc = wordCount(candidate);
+    if (candidateWc <= maxTokens) {
+      buffer = candidate;
+    } else {
+      if (buffer) results.push(buffer);
+      const partWc = buffer ? wordCount(part) : candidateWc;
+      if (partWc > maxTokens) {
+        results.push(...chunkRecursive(part, maxTokens, rest));
+        buffer = "";
+      } else {
+        buffer = part;
+      }
+    }
+  }
+  if (buffer) results.push(buffer);
+  return results;
+}
+var DefaultChunkingAdapter = class {
+  chunk(text, options) {
+    if (!text || !text.trim()) return [];
+    const strategy = options?.strategy ?? "fixed";
+    const maxTokens = options?.maxTokens ?? DEFAULT_MAX_TOKENS;
+    const overlap = options?.overlap ?? DEFAULT_OVERLAP;
+    const separators = options?.separators ?? DEFAULT_SEPARATORS;
+    let rawChunks;
+    switch (strategy) {
+      case "fixed":
+        rawChunks = chunkFixed(text, maxTokens);
+        break;
+      case "sliding-window":
+        rawChunks = chunkSlidingWindow(text, maxTokens, overlap);
+        break;
+      case "semantic":
+        rawChunks = chunkSemantic(text, maxTokens);
+        break;
+      case "recursive":
+        rawChunks = chunkRecursive(text, maxTokens, separators);
+        break;
+      default:
+        rawChunks = chunkFixed(text, maxTokens);
+    }
+    const wordPositions = getWordPositions(text);
+    const chunks = [];
+    let searchWordIdx = 0;
+    for (let i = 0; i < rawChunks.length; i++) {
+      const raw = rawChunks[i];
+      const chunkWords = raw.split(/\s+/).filter(Boolean);
+      if (chunkWords.length === 0) continue;
+      let matchIdx = searchWordIdx;
+      for (let j = searchWordIdx; j < wordPositions.length; j++) {
+        if (wordPositions[j].word === chunkWords[0]) {
+          matchIdx = j;
+          break;
+        }
+      }
+      const startPos = matchIdx < wordPositions.length ? wordPositions[matchIdx].start : 0;
+      const lastWordIdx = Math.min(matchIdx + chunkWords.length - 1, wordPositions.length - 1);
+      const endPos = lastWordIdx >= 0 ? wordPositions[lastWordIdx].end : startPos + raw.length;
+      chunks.push(makeChunk(raw, i, startPos));
+      chunks[chunks.length - 1].metadata.endOffset = endPos;
+      searchWordIdx = matchIdx + 1;
+    }
+    return chunks;
+  }
+};
+
+// src/adapters/reranking/default-reranking.adapter.ts
+var K1 = 1.2;
+var B = 0.75;
+var PUNCTUATION_RE = /[^\w\s]/g;
+function tokenize(text) {
+  return text.toLowerCase().replace(PUNCTUATION_RE, "").split(/\s+/).filter(Boolean);
+}
+function buildTermFrequencyMap(tokens) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    freq.set(t, (freq.get(t) ?? 0) + 1);
+  }
+  return freq;
+}
+function computeTfIdf(query, results) {
+  const queryTokens = tokenize(query);
+  const docTokenSets = results.map((r) => tokenize(r.text));
+  const docFreqMaps = docTokenSets.map(buildTermFrequencyMap);
+  const n = results.length;
+  const idf = /* @__PURE__ */ new Map();
+  for (const term of queryTokens) {
+    let df = 0;
+    for (const fm of docFreqMaps) {
+      if (fm.has(term)) df++;
+    }
+    idf.set(term, Math.log((n + 1) / (df + 1)) + 1);
+  }
+  return results.map((r, i) => {
+    const tokens = docTokenSets[i];
+    const freqMap = docFreqMaps[i];
+    let score = 0;
+    for (const term of queryTokens) {
+      const tf = (freqMap.get(term) ?? 0) / (tokens.length || 1);
+      score += tf * (idf.get(term) ?? 0);
+    }
+    return { ...r, score };
+  }).sort((a, b) => b.score - a.score);
+}
+function computeBm25(query, results) {
+  const queryTokens = tokenize(query);
+  const docTokenSets = results.map((r) => tokenize(r.text));
+  const docFreqMaps = docTokenSets.map(buildTermFrequencyMap);
+  const n = results.length;
+  const avgDl = docTokenSets.reduce((sum, t) => sum + t.length, 0) / (n || 1) || 1;
+  const idf = /* @__PURE__ */ new Map();
+  for (const term of queryTokens) {
+    let df = 0;
+    for (const fm of docFreqMaps) {
+      if (fm.has(term)) df++;
+    }
+    idf.set(term, Math.log((n - df + 0.5) / (df + 0.5) + 1));
+  }
+  return results.map((r, i) => {
+    const tokens = docTokenSets[i];
+    const freqMap = docFreqMaps[i];
+    const dl = tokens.length;
+    let score = 0;
+    for (const term of queryTokens) {
+      const tf = freqMap.get(term) ?? 0;
+      const idfVal = idf.get(term) ?? 0;
+      score += idfVal * (tf * (K1 + 1) / (tf + K1 * (1 - B + B * (dl / avgDl))));
+    }
+    return { ...r, score };
+  }).sort((a, b) => b.score - a.score);
+}
+function cosineSimilarity(a, b) {
+  const denom = a.norm * b.norm;
+  if (denom === 0) return 0;
+  const [small, large] = a.vec.size <= b.vec.size ? [a.vec, b.vec] : [b.vec, a.vec];
+  let dot = 0;
+  for (const [k, v] of small) {
+    const other = large.get(k);
+    if (other !== void 0) dot += v * other;
+  }
+  return dot / denom;
+}
+function toTfVector(tokens) {
+  const freqMap = buildTermFrequencyMap(tokens);
+  const len = tokens.length;
+  let normSq = 0;
+  for (const [k, v] of freqMap) {
+    const tf = v / len;
+    freqMap.set(k, tf);
+    normSq += tf * tf;
+  }
+  return { vec: freqMap, norm: Math.sqrt(normSq) };
+}
+function computeMmr(query, results, lambda) {
+  if (results.length === 0) return [];
+  const queryVec = toTfVector(tokenize(query));
+  const docVecs = results.map((r) => toTfVector(tokenize(r.text)));
+  const relevances = docVecs.map((dv) => cosineSimilarity(queryVec, dv));
+  const pairwiseSim = /* @__PURE__ */ new Map();
+  const pairKey = (i, j) => i < j ? `${i},${j}` : `${j},${i}`;
+  const selected = [];
+  const remaining = new Set(results.map((_, i) => i));
+  const reranked = [];
+  while (remaining.size > 0) {
+    let bestIdx = -1;
+    let bestScore = -Infinity;
+    for (const idx of remaining) {
+      const rel = relevances[idx];
+      let maxSim = 0;
+      for (const selIdx of selected) {
+        const key = pairKey(idx, selIdx);
+        let sim = pairwiseSim.get(key);
+        if (sim === void 0) {
+          sim = cosineSimilarity(docVecs[idx], docVecs[selIdx]);
+          pairwiseSim.set(key, sim);
+        }
+        if (sim > maxSim) maxSim = sim;
+      }
+      const mmrScore = lambda * rel - (1 - lambda) * maxSim;
+      if (mmrScore > bestScore) {
+        bestScore = mmrScore;
+        bestIdx = idx;
+      }
+    }
+    if (bestIdx >= 0) {
+      selected.push(bestIdx);
+      remaining.delete(bestIdx);
+      reranked.push({ ...results[bestIdx], score: bestScore });
+    }
+  }
+  return reranked;
+}
+var DefaultReRankingAdapter = class {
+  rerank(query, results, options) {
+    if (results.length === 0) return [];
+    const strategy = options?.strategy ?? "bm25";
+    switch (strategy) {
+      case "tfidf":
+        return computeTfIdf(query, results);
+      case "bm25":
+        return computeBm25(query, results);
+      case "mmr":
+        return computeMmr(query, results, options?.lambda ?? 0.7);
+      default:
+        return computeBm25(query, results);
+    }
+  }
+};
+
+// src/plugins/vectorless.plugin.ts
+var DEFAULT_MAX_TOKENS_PER_CHUNK = 512;
+var VectorlessPlugin = class extends BasePlugin {
+  name = "knowledge";
+  options;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  vectorlessPromise = null;
+  currentKnowledge = null;
+  validator;
+  chunks = /* @__PURE__ */ new Map();
+  chunkingAdapter;
+  rerankingAdapter;
+  _toolsCache;
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.currentKnowledge = options.knowledgeBase ?? null;
+    this.validator = getValidator(options);
+    this.chunkingAdapter = options.chunkingAdapter ?? new DefaultChunkingAdapter();
+    this.rerankingAdapter = options.rerankingAdapter ?? new DefaultReRankingAdapter();
+  }
+  buildHooks() {
+    return {};
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getVectorless() {
+    if (!this.vectorlessPromise) {
+      this.vectorlessPromise = this.initVectorless();
+    }
+    return this.vectorlessPromise;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async initVectorless() {
+    if (this.options.vectorless) {
+      return this.options.vectorless;
+    }
+    try {
+      const mod = await import("@giulio-leone/gaussflow-vectorless");
+      return mod.default ?? mod;
+    } catch {
+      throw new Error(
+        'VectorlessPlugin requires "@giulio-leone/gaussflow-vectorless" package. Install it: pnpm add @giulio-leone/gaussflow-vectorless'
+      );
+    }
+  }
+  get tools() {
+    if (this._toolsCache) return this._toolsCache;
+    const getVectorless = this.getVectorless.bind(this);
+    const getKnowledge = () => this.currentKnowledge;
+    const setKnowledge = (k) => {
+      this.currentKnowledge = k;
+    };
+    const mergeKnowledge = (newK) => {
+      const existing = this.currentKnowledge;
+      const incoming = newK;
+      if (!existing || !incoming) {
+        this.currentKnowledge = incoming ?? existing;
+        return;
+      }
+      const merged = { ...existing };
+      for (const key of ["entities", "relations", "quotes"]) {
+        const a = Array.isArray(existing[key]) ? existing[key] : [];
+        const b = Array.isArray(incoming[key]) ? incoming[key] : [];
+        if (a.length > 0 || b.length > 0) merged[key] = [...a, ...b];
+      }
+      this.currentKnowledge = merged;
+    };
+    const validator = this.validator;
+    const chunks = this.chunks;
+    const chunkingAdapter = this.chunkingAdapter;
+    const rerankingAdapter = this.rerankingAdapter;
+    const toolsMap = {
+      generate: tool({
+        description: "Extract knowledge (entities, relations, quotes) from text. Must be called before query/search.",
+        inputSchema: z4.object({
+          text: z4.string().describe("The text to extract knowledge from"),
+          topic: z4.string().optional().describe("Optional topic to focus extraction on")
+        }),
+        execute: async (args) => {
+          const { text, topic } = validator.validateOrThrow(
+            z4.object({
+              text: z4.string(),
+              topic: z4.string().optional()
+            }),
+            args
+          );
+          const vl = await getVectorless();
+          const generate = vl.generateKnowledge ?? vl.generate ?? vl.extract;
+          if (!generate) throw new Error("vectorless: generateKnowledge function not found");
+          const knowledge = await generate(text, { topic });
+          setKnowledge(knowledge);
+          const summary = {
+            entities: Array.isArray(knowledge?.entities) ? knowledge.entities.length : 0,
+            relations: Array.isArray(knowledge?.relations) ? knowledge.relations.length : 0,
+            quotes: Array.isArray(knowledge?.quotes) ? knowledge.quotes.length : 0
+          };
+          return `Knowledge extracted: ${summary.entities} entities, ${summary.relations} relations, ${summary.quotes} quotes`;
+        }
+      }),
+      query: tool({
+        description: "Answer a question using the extracted knowledge base",
+        inputSchema: z4.object({
+          question: z4.string().describe("The question to answer")
+        }),
+        execute: async (args) => {
+          const { question } = validator.validateOrThrow(
+            z4.object({ question: z4.string() }),
+            args
+          );
+          const knowledge = getKnowledge();
+          if (!knowledge) return "No knowledge base loaded. Use knowledge:generate first.";
+          const vl = await getVectorless();
+          const query = vl.queryKnowledge ?? vl.query ?? vl.ask;
+          if (!query) throw new Error("vectorless: queryKnowledge function not found");
+          const result = await query(question, knowledge);
+          return typeof result === "string" ? result : JSON.stringify(result);
+        }
+      }),
+      "search-entities": tool({
+        description: "Search for entities in the extracted knowledge base",
+        inputSchema: z4.object({
+          query: z4.string().describe("Search query for entities"),
+          limit: z4.number().min(1).max(50).default(10).describe("Max results")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            z4.object({
+              query: z4.string(),
+              limit: z4.number().min(1).max(50).default(10)
+            }),
+            args
+          );
+          const knowledge = getKnowledge();
+          if (!knowledge) return "No knowledge base loaded. Use knowledge:generate first.";
+          const vl = await getVectorless();
+          if (typeof vl.searchEntities === "function") {
+            return await vl.searchEntities(query, knowledge, { limit });
+          }
+          const kb = knowledge;
+          const entities = Array.isArray(kb?.entities) ? kb.entities : [];
+          const lower = query.toLowerCase();
+          return entities.filter((e) => (e.name ?? e.label ?? "").toLowerCase().includes(lower)).slice(0, limit);
+        }
+      }),
+      list: tool({
+        description: "List all entities in the current knowledge base",
+        inputSchema: z4.object({}),
+        execute: async () => {
+          const knowledge = getKnowledge();
+          if (!knowledge) return "No knowledge base loaded. Use knowledge:generate first.";
+          const kb = knowledge;
+          const entities = Array.isArray(kb.entities) ? kb.entities : [];
+          return entities.map((e) => ({
+            name: e.name ?? e.label ?? "unknown",
+            type: e.type ?? e.category ?? "unknown"
+          }));
+        }
+      }),
+      // ─── Advanced RAG tools ──────────────────────────────────────────
+      "rag:ingest": tool({
+        description: "Chunk a document and extract knowledge from each chunk",
+        inputSchema: z4.object({
+          text: z4.string().describe("The document text to ingest"),
+          source: z4.string().optional().describe("Source identifier for attribution"),
+          chunkingStrategy: z4.enum(["fixed", "sliding-window", "semantic", "recursive"]).default("recursive").describe("Chunking strategy"),
+          maxTokens: z4.number().min(1).default(DEFAULT_MAX_TOKENS_PER_CHUNK).describe("Max tokens per chunk"),
+          overlap: z4.number().min(0).default(50).describe("Token overlap for sliding-window")
+        }),
+        execute: async (args) => {
+          const { text, source, chunkingStrategy, maxTokens, overlap } = validator.validateOrThrow(
+            z4.object({
+              text: z4.string(),
+              source: z4.string().optional(),
+              chunkingStrategy: z4.enum(["fixed", "sliding-window", "semantic", "recursive"]).default("recursive"),
+              maxTokens: z4.number().min(1).default(DEFAULT_MAX_TOKENS_PER_CHUNK),
+              overlap: z4.number().min(0).default(50)
+            }),
+            args
+          );
+          const produced = chunkingAdapter.chunk(text, {
+            strategy: chunkingStrategy,
+            maxTokens,
+            overlap
+          });
+          for (const c of produced) {
+            c.metadata.source = source;
+            chunks.set(c.id, c);
+          }
+          try {
+            const vl = await getVectorless();
+            const generate = vl.generateKnowledge ?? vl.generate ?? vl.extract;
+            if (generate) {
+              const knowledge = await generate(text, { topic: source });
+              mergeKnowledge(knowledge);
+            }
+          } catch {
+          }
+          return `Ingested ${produced.length} chunks (strategy: ${chunkingStrategy}, maxTokens: ${maxTokens})${source ? ` from "${source}"` : ""}`;
+        }
+      }),
+      "rag:search": tool({
+        description: "Hybrid search: combine entity search + keyword search, then re-rank results",
+        inputSchema: z4.object({
+          query: z4.string().describe("Search query"),
+          limit: z4.number().min(1).max(100).default(10).describe("Max results"),
+          rerankerStrategy: z4.enum(["tfidf", "bm25", "mmr"]).default("bm25").describe("Re-ranking strategy"),
+          includeAttribution: z4.boolean().default(true).describe("Include source attribution")
+        }),
+        execute: async (args) => {
+          const { query, limit, rerankerStrategy, includeAttribution } = validator.validateOrThrow(
+            z4.object({
+              query: z4.string(),
+              limit: z4.number().min(1).max(100).default(10),
+              rerankerStrategy: z4.enum(["tfidf", "bm25", "mmr"]).default("bm25"),
+              includeAttribution: z4.boolean().default(true)
+            }),
+            args
+          );
+          const candidates = [];
+          const queryLower = query.toLowerCase();
+          const queryWords = queryLower.split(/\s+/);
+          const knowledge = getKnowledge();
+          if (knowledge) {
+            const kb = knowledge;
+            const entities = Array.isArray(kb?.entities) ? kb.entities : [];
+            for (const e of entities) {
+              const name = (e.name ?? e.label ?? "").toLowerCase();
+              if (name.includes(queryLower) || queryLower.includes(name)) {
+                candidates.push({
+                  id: `entity:${e.name ?? e.label}`,
+                  text: `${e.name ?? e.label} (${e.type ?? e.category ?? "unknown"})`,
+                  score: 0
+                });
+              }
+            }
+          }
+          for (const [, chunk] of chunks) {
+            const chunkLower = chunk.text.toLowerCase();
+            if (chunkLower.includes(queryLower) || queryWords.some((w) => chunkLower.includes(w))) {
+              const result = {
+                id: chunk.id,
+                text: chunk.text,
+                score: 0
+              };
+              if (includeAttribution) {
+                result.source = {
+                  chunkId: chunk.id,
+                  chunkIndex: chunk.index,
+                  documentId: chunk.metadata.source,
+                  startOffset: chunk.metadata.startOffset,
+                  endOffset: chunk.metadata.endOffset,
+                  relevanceScore: 0
+                };
+              }
+              candidates.push(result);
+            }
+          }
+          if (candidates.length === 0) return [];
+          const reranked = rerankingAdapter.rerank(query, candidates, {
+            strategy: rerankerStrategy
+          });
+          const top = reranked.slice(0, limit);
+          for (const r of top) {
+            if (r.source) r.source.relevanceScore = r.score;
+          }
+          return top;
+        }
+      }),
+      "rag:search-chunks": tool({
+        description: "Search directly against stored chunks",
+        inputSchema: z4.object({
+          query: z4.string().describe("Search query"),
+          limit: z4.number().min(1).max(100).default(10).describe("Max results")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            z4.object({
+              query: z4.string(),
+              limit: z4.number().min(1).max(100).default(10)
+            }),
+            args
+          );
+          const queryWords = query.toLowerCase().split(/\s+/).filter(Boolean);
+          const results = [];
+          for (const [, chunk] of chunks) {
+            const chunkLower = chunk.text.toLowerCase();
+            const matchCount = queryWords.filter((w) => chunkLower.includes(w)).length;
+            if (matchCount > 0) {
+              results.push({ ...chunk, matchScore: matchCount / queryWords.length });
+            }
+          }
+          return results.sort((a, b) => b.matchScore - a.matchScore).slice(0, limit).map(({ matchScore, ...chunk }) => chunk);
+        }
+      })
+    };
+    this._toolsCache = toolsMap;
+    return toolsMap;
+  }
+  async dispose() {
+    this.currentKnowledge = null;
+    this.vectorlessPromise = null;
+    this.chunks.clear();
+    this._toolsCache = void 0;
+  }
+};
+function createVectorlessPlugin(options = {}) {
+  return new VectorlessPlugin(options);
+}
+
+// src/plugins/evals.plugin.ts
+var EvalsPlugin = class extends BasePlugin {
+  name = "evals";
+  options;
+  results = [];
+  runStates = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    super();
+    this.options = options;
+  }
+  buildHooks() {
+    return {
+      beforeRun: this.beforeRun.bind(this),
+      afterRun: this.afterRun.bind(this),
+      afterTool: this.afterTool.bind(this),
+      onError: this.onError.bind(this)
+    };
+  }
+  beforeRun(ctx, params) {
+    this.runStates.set(ctx.sessionId, {
+      startTime: Date.now(),
+      prompt: params.prompt,
+      toolCallCounts: {}
+    });
+  }
+  async afterRun(ctx, params) {
+    const state = this.runStates.get(ctx.sessionId);
+    const latencyMs = state ? Date.now() - state.startTime : 0;
+    const prompt = state?.prompt ?? "";
+    const toolCalls = state ? { ...state.toolCallCounts } : {};
+    this.runStates.delete(ctx.sessionId);
+    const steps = params.result.steps;
+    let promptTokens = 0;
+    let completionTokens = 0;
+    for (const step of steps) {
+      const usage = step?.usage;
+      if (usage) {
+        promptTokens += usage.promptTokens ?? 0;
+        completionTokens += usage.completionTokens ?? 0;
+      }
+    }
+    const metrics = {
+      latencyMs,
+      stepCount: steps.length,
+      toolCalls,
+      tokenUsage: {
+        prompt: promptTokens,
+        completion: completionTokens,
+        total: promptTokens + completionTokens
+      },
+      customScores: {}
+    };
+    for (const scorer of this.options.scorers ?? []) {
+      try {
+        metrics.customScores[scorer.name] = await scorer.score(
+          prompt,
+          params.result.text,
+          metrics
+        );
+      } catch {
+        metrics.customScores[scorer.name] = -1;
+      }
+    }
+    const evalResult = {
+      id: crypto.randomUUID(),
+      sessionId: params.result.sessionId,
+      prompt,
+      output: params.result.text,
+      metrics,
+      createdAt: Date.now()
+    };
+    this.results.push(evalResult);
+    if (this.options.persist) {
+      await ctx.memory.saveMetadata(
+        ctx.sessionId,
+        `eval:${evalResult.id}`,
+        evalResult
+      );
+    }
+    if (this.options.onEval) {
+      await this.options.onEval(evalResult);
+    }
+  }
+  afterTool(ctx, params) {
+    const state = this.runStates.get(ctx.sessionId);
+    if (state) {
+      state.toolCallCounts[params.toolName] = (state.toolCallCounts[params.toolName] ?? 0) + 1;
+    }
+  }
+  onError(ctx, params) {
+    if (params.phase === "run") {
+      this.runStates.delete(ctx.sessionId);
+    }
+  }
+  /** Get all collected eval results */
+  getResults() {
+    return this.results;
+  }
+  /** Get the most recent eval result */
+  getLastResult() {
+    return this.results[this.results.length - 1];
+  }
+  /** Clear collected results */
+  clearResults() {
+    this.results.length = 0;
+  }
+};
+function createEvalsPlugin(options = {}) {
+  return new EvalsPlugin(options);
+}
+
+// src/adapters/workflow/default-workflow.engine.ts
+var DEFAULT_RETRY = {
+  maxAttempts: 3,
+  backoffMs: 1e3,
+  backoffMultiplier: 2
+};
+var DEFAULT_MAX_ITERATIONS = 10;
+var DEFAULT_MAX_CONCURRENCY = 1;
+var DefaultWorkflowEngine = class {
+  agentExecutor;
+  onEvent;
+  constructor(options = {}) {
+    this.agentExecutor = options.agentExecutor;
+    this.onEvent = options.onEvent;
+  }
+  async execute(definition, context) {
+    const start = Date.now();
+    let ctx = structuredClone(definition.initialContext ?? {});
+    if (context) {
+      ctx = { ...ctx, ...structuredClone(context) };
+    }
+    const completedSteps = [];
+    const skippedSteps = [];
+    const executedRegistry = /* @__PURE__ */ new Map();
+    const timeoutMs = definition.maxDurationMs;
+    const deadline = timeoutMs ? start + timeoutMs : void 0;
+    for (const step of definition.steps) {
+      if (deadline && Date.now() >= deadline) {
+        await this.rollbackSteps(executedRegistry, completedSteps, ctx);
+        return {
+          status: "failed",
+          context: ctx,
+          completedSteps,
+          skippedSteps,
+          failedStep: step.id,
+          error: `Workflow timeout exceeded (${timeoutMs}ms)`,
+          totalDurationMs: Date.now() - start
+        };
+      }
+      try {
+        const stepResult = await this.executeStep(step, ctx, completedSteps, skippedSteps, executedRegistry, deadline);
+        if (skippedSteps.includes(step.id)) {
+          continue;
+        }
+        ctx = stepResult;
+        completedSteps.push(step.id);
+      } catch (error) {
+        await this.rollbackSteps(executedRegistry, completedSteps, ctx);
+        return {
+          status: "failed",
+          context: ctx,
+          completedSteps,
+          skippedSteps,
+          failedStep: step.id,
+          error: error instanceof Error ? error.message : String(error),
+          totalDurationMs: Date.now() - start
+        };
+      }
+    }
+    return {
+      status: "completed",
+      context: ctx,
+      completedSteps,
+      skippedSteps,
+      totalDurationMs: Date.now() - start
+    };
+  }
+  validate(definition) {
+    const errors = [];
+    if (!definition.id) errors.push("Workflow must have an id");
+    if (!definition.name) errors.push("Workflow must have a name");
+    if (!definition.steps || !Array.isArray(definition.steps)) {
+      errors.push("Workflow must have a steps array");
+    } else if (definition.steps.length === 0) {
+      errors.push("Workflow must have at least one step");
+    }
+    const ids = /* @__PURE__ */ new Set();
+    for (const step of definition.steps ?? []) {
+      if (!step.id) errors.push("Every step must have an id");
+      if (!step.name) errors.push(`Step "${step.id}" must have a name`);
+      if (ids.has(step.id)) errors.push(`Duplicate step id: "${step.id}"`);
+      ids.add(step.id);
+      this.validateStep(step, errors);
+    }
+    if (definition.maxDurationMs !== void 0 && definition.maxDurationMs <= 0) {
+      errors.push("maxDurationMs must be positive");
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  // ── Step execution ──────────────────────────────────────────────────────
+  async executeStep(step, ctx, completedSteps, skippedSteps, registry, deadline) {
+    this.emit({ type: "step:start", stepId: step.id, stepName: step.name, timestamp: Date.now() });
+    try {
+      let result;
+      if (this.isParallelStep(step)) {
+        result = await this.executeParallel(step, ctx, registry, deadline);
+      } else if (this.isConditionalStep(step)) {
+        result = await this.executeConditional(step, ctx, completedSteps, skippedSteps, registry, deadline);
+      } else if (this.isLoopStep(step)) {
+        result = await this.executeLoop(step, ctx, registry, deadline);
+      } else if (this.isForeachStep(step)) {
+        result = await this.executeForeach(step, ctx, registry, deadline);
+      } else if (this.isMapStep(step)) {
+        result = await this.executeMap(step, ctx, registry, deadline);
+      } else if (this.isAgentStep(step)) {
+        result = await this.executeAgent(step, ctx);
+        if ("rollback" in step && typeof step.rollback === "function") {
+          registry.set(step.id, step);
+        }
+      } else {
+        const ws = step;
+        if (ws.condition && !ws.condition(ctx)) {
+          skippedSteps.push(step.id);
+          this.emit({ type: "step:complete", stepId: step.id, stepName: step.name, timestamp: Date.now(), context: ctx });
+          return ctx;
+        }
+        const projectedCtx = this.applyInputMapping(ws, ctx);
+        const rawResult = await this.executeWithRetry(ws, projectedCtx);
+        result = ws.inputMapping ? { ...ctx, ...rawResult } : rawResult;
+        result = this.applyOutputMappings(ws, result);
+        if (ws.rollback) {
+          registry.set(step.id, ws);
+        }
+      }
+      this.emit({ type: "step:complete", stepId: step.id, stepName: step.name, timestamp: Date.now(), context: result });
+      return result;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      this.emit({ type: "step:error", stepId: step.id, stepName: step.name, timestamp: Date.now(), error: errMsg });
+      throw error;
+    }
+  }
+  async executeParallel(step, ctx, registry, deadline) {
+    const strategy = step.mergeStrategy ?? "all";
+    const branchCtx = structuredClone(ctx);
+    const wrapWithTimeout = (promise) => {
+      if (!deadline) return promise;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return Promise.reject(new Error("Workflow timeout exceeded"));
+      let timer;
+      const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Workflow timeout exceeded")), remaining);
+      });
+      return Promise.race([promise, timeoutPromise]).finally(() => clearTimeout(timer));
+    };
+    const promises = step.branches.map((branch) => {
+      if (branch.rollback) registry.set(branch.id, branch);
+      return wrapWithTimeout(this.executeWithRetry(branch, structuredClone(branchCtx)));
+    });
+    if (strategy === "race") {
+      return await Promise.race(promises);
+    }
+    if (strategy === "first") {
+      return await Promise.any(promises);
+    }
+    const results = await Promise.all(promises);
+    let merged = structuredClone(ctx);
+    for (const r of results) {
+      merged = { ...merged, ...r };
+    }
+    return merged;
+  }
+  async executeConditional(step, ctx, completedSteps, skippedSteps, registry, deadline) {
+    if (step.condition(ctx)) {
+      return this.executeStep(step.ifTrue, structuredClone(ctx), completedSteps, skippedSteps, registry, deadline);
+    } else if (step.ifFalse) {
+      return this.executeStep(step.ifFalse, structuredClone(ctx), completedSteps, skippedSteps, registry, deadline);
+    }
+    return ctx;
+  }
+  async executeLoop(step, ctx, registry, deadline) {
+    const maxIter = step.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    let current = structuredClone(ctx);
+    if (step.body.rollback) {
+      registry.set(step.body.id, step.body);
+    }
+    for (let i = 0; i < maxIter; i++) {
+      if (!step.condition(current)) break;
+      if (deadline && Date.now() >= deadline) {
+        throw new Error("Workflow timeout exceeded");
+      }
+      current = await this.executeWithRetry(step.body, current);
+    }
+    return current;
+  }
+  async executeForeach(step, ctx, registry, deadline) {
+    const iterable = this.getByPath(ctx, step.iterable);
+    if (!Array.isArray(iterable)) {
+      throw new Error(`Foreach step "${step.id}": iterable path "${step.iterable}" is not an array`);
+    }
+    const maxIter = step.maxIterations ? Math.min(step.maxIterations, iterable.length) : iterable.length;
+    const items = iterable.slice(0, maxIter);
+    const itemKey = step.itemKey ?? "item";
+    const indexKey = step.indexKey ?? "index";
+    const outputs = await this.executeItemsWithConcurrency(
+      items,
+      step.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
+      async (item, index) => {
+        if (deadline && Date.now() >= deadline) {
+          throw new Error("Workflow timeout exceeded");
+        }
+        const itemCtx = {
+          ...ctx,
+          [itemKey]: item,
+          [indexKey]: index
+        };
+        if (step.step.rollback) {
+          registry.set(step.step.id, step.step);
+        }
+        const projectedCtx = this.applyInputMapping(step.step, itemCtx);
+        const rawResult = await this.executeWithRetry(step.step, projectedCtx);
+        const mergedResult = step.step.inputMapping ? { ...itemCtx, ...rawResult } : rawResult;
+        const mappedResult = this.applyOutputMappings(step.step, mergedResult);
+        return this.extractStepOutput(mappedResult, step.step.id);
+      }
+    );
+    const aggregateKey = step.aggregateOutputKey ?? step.id;
+    return {
+      ...ctx,
+      [aggregateKey]: this.aggregateOutputs(outputs, step.aggregationMode ?? "array")
+    };
+  }
+  async executeMap(step, ctx, registry, deadline) {
+    const source = this.getByPath(ctx, step.input);
+    if (!Array.isArray(source)) {
+      throw new Error(`Map step "${step.id}": input path "${step.input}" is not an array`);
+    }
+    const filtered = source.filter(
+      (item, index) => step.filter ? step.filter(item, index, ctx) : true
+    );
+    const itemKey = step.itemKey ?? "item";
+    const indexKey = step.indexKey ?? "index";
+    const transformed = await this.executeItemsWithConcurrency(
+      filtered,
+      step.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY,
+      async (item, index) => {
+        if (deadline && Date.now() >= deadline) {
+          throw new Error("Workflow timeout exceeded");
+        }
+        const itemCtx = {
+          ...ctx,
+          [itemKey]: item,
+          [indexKey]: index
+        };
+        if (step.transform.rollback) {
+          registry.set(step.transform.id, step.transform);
+        }
+        const projectedCtx = this.applyInputMapping(step.transform, itemCtx);
+        const rawResult = await this.executeWithRetry(step.transform, projectedCtx);
+        const mergedResult = step.transform.inputMapping ? { ...itemCtx, ...rawResult } : rawResult;
+        const mappedResult = this.applyOutputMappings(step.transform, mergedResult);
+        return this.extractStepOutput(mappedResult, step.transform.id);
+      }
+    );
+    return {
+      ...ctx,
+      [step.outputKey]: transformed
+    };
+  }
+  async executeAgent(step, ctx) {
+    if (step.execute) {
+      return this.executeWithRetry(step, ctx);
+    }
+    if (!this.agentExecutor) {
+      throw new Error(`AgentStep "${step.id}" requires an agentExecutor`);
+    }
+    const prompt = typeof step.prompt === "function" ? step.prompt(ctx) : step.prompt;
+    const retry = { ...DEFAULT_RETRY, ...step.retry };
+    let lastError;
+    for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {
+      try {
+        const result = await this.agentExecutor(prompt, structuredClone(ctx));
+        return { ...ctx, [step.outputKey]: result };
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < retry.maxAttempts) {
+          const delay = retry.backoffMs * Math.pow(retry.backoffMultiplier, attempt - 1);
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  // ── Retry ───────────────────────────────────────────────────────────────
+  async executeWithRetry(step, ctx) {
+    const retry = { ...DEFAULT_RETRY, ...step.retry };
+    let lastError;
+    for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {
+      try {
+        return await step.execute(structuredClone(ctx));
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < retry.maxAttempts) {
+          const delay = retry.backoffMs * Math.pow(retry.backoffMultiplier, attempt - 1);
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  // ── Rollback ────────────────────────────────────────────────────────────
+  async rollbackSteps(registry, completedStepIds, ctx) {
+    const allIds = [...completedStepIds, ...Array.from(registry.keys())];
+    const uniqueIds = [...new Set(allIds)].reverse();
+    for (const stepId of uniqueIds) {
+      const step = registry.get(stepId);
+      if (step?.rollback) {
+        try {
+          await step.rollback(ctx);
+        } catch {
+        }
+      }
+    }
+  }
+  // ── Helpers ─────────────────────────────────────────────────────────────
+  emit(event) {
+    this.onEvent?.(event);
+  }
+  isParallelStep(step) {
+    return step.type === "parallel";
+  }
+  isConditionalStep(step) {
+    return step.type === "conditional";
+  }
+  isLoopStep(step) {
+    return step.type === "loop";
+  }
+  isForeachStep(step) {
+    return step.type === "foreach";
+  }
+  isMapStep(step) {
+    return step.type === "map";
+  }
+  isAgentStep(step) {
+    return step.type === "agent";
+  }
+  validateStep(step, errors) {
+    if (this.isParallelStep(step)) {
+      if (!step.branches || step.branches.length === 0) {
+        errors.push(`Parallel step "${step.id}" must have at least one branch`);
+      }
+    } else if (this.isConditionalStep(step)) {
+      if (!step.condition) errors.push(`Conditional step "${step.id}" must have a condition`);
+      if (!step.ifTrue) errors.push(`Conditional step "${step.id}" must have an ifTrue step`);
+    } else if (this.isLoopStep(step)) {
+      if (!step.body) errors.push(`Loop step "${step.id}" must have a body`);
+      if (!step.condition) errors.push(`Loop step "${step.id}" must have a condition`);
+    } else if (this.isForeachStep(step)) {
+      if (!step.iterable) errors.push(`Foreach step "${step.id}" must define iterable path`);
+      if (!step.step) errors.push(`Foreach step "${step.id}" must define an item step`);
+      if (step.maxConcurrency !== void 0 && step.maxConcurrency < 1) {
+        errors.push(`Foreach step "${step.id}" maxConcurrency must be >= 1`);
+      }
+      if (step.maxIterations !== void 0 && step.maxIterations < 1) {
+        errors.push(`Foreach step "${step.id}" maxIterations must be >= 1`);
+      }
+    } else if (this.isMapStep(step)) {
+      if (!step.input) errors.push(`Map step "${step.id}" must define input path`);
+      if (!step.transform) errors.push(`Map step "${step.id}" must define transform step`);
+      if (!step.outputKey) errors.push(`Map step "${step.id}" must define outputKey`);
+      if (step.maxConcurrency !== void 0 && step.maxConcurrency < 1) {
+        errors.push(`Map step "${step.id}" maxConcurrency must be >= 1`);
+      }
+    } else if (this.isAgentStep(step)) {
+      if (!step.prompt) errors.push(`Agent step "${step.id}" must have a prompt`);
+      if (!step.outputKey) errors.push(`Agent step "${step.id}" must have an outputKey`);
+    } else {
+      const ws = step;
+      if (!ws.execute) errors.push(`Step "${step.id}" must have an execute function`);
+    }
+  }
+  getByPath(ctx, path) {
+    if (!path) return void 0;
+    const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+    const segments = normalized.split(".").filter(Boolean);
+    let current = ctx;
+    for (const segment of segments) {
+      if (current === null || current === void 0) return void 0;
+      if (Array.isArray(current)) {
+        const index = Number(segment);
+        if (!Number.isInteger(index)) return void 0;
+        current = current[index];
+        continue;
+      }
+      if (typeof current !== "object") return void 0;
+      current = current[segment];
+    }
+    return current;
+  }
+  applyInputMapping(step, ctx) {
+    const mapping = step.inputMapping;
+    if (!mapping) {
+      return ctx;
+    }
+    let projected = mapping.defaults ? { ...mapping.defaults } : {};
+    if (mapping.keys) {
+      for (const key of mapping.keys) {
+        if (key in ctx) {
+          projected[key] = ctx[key];
+        }
+      }
+    }
+    if (mapping.paths) {
+      for (const [targetKey, path] of Object.entries(mapping.paths)) {
+        projected[targetKey] = this.getByPath(ctx, path);
+      }
+    }
+    if (mapping.overrides) {
+      projected = {
+        ...projected,
+        ...mapping.overrides
+      };
+    }
+    return projected;
+  }
+  applyOutputMappings(step, result) {
+    if (!step.outputMapping || step.outputMapping.length === 0) {
+      return result;
+    }
+    const mapped = { ...result };
+    for (const mapping of step.outputMapping) {
+      let value = this.getByPath(result, mapping.source);
+      if (mapping.transform) {
+        value = mapping.transform(value, result);
+      }
+      if (value === void 0) {
+        value = mapping.defaultValue;
+      }
+      mapped[mapping.targetKey] = value;
+    }
+    return mapped;
+  }
+  extractStepOutput(result, stepId) {
+    if (stepId in result) {
+      return result[stepId];
+    }
+    return result;
+  }
+  aggregateOutputs(outputs, mode) {
+    if (mode === "concat") {
+      return outputs.flatMap(
+        (output) => Array.isArray(output) ? output : [output]
+      );
+    }
+    if (mode === "merge") {
+      const merged = {};
+      for (const output of outputs) {
+        if (output && typeof output === "object" && !Array.isArray(output)) {
+          Object.assign(merged, output);
+        }
+      }
+      return merged;
+    }
+    return outputs;
+  }
+  async executeItemsWithConcurrency(items, concurrency, worker) {
+    const safeConcurrency = Math.max(1, Math.floor(concurrency));
+    if (safeConcurrency === 1 || items.length <= 1) {
+      const sequential = [];
+      for (let i = 0; i < items.length; i++) {
+        sequential.push(await worker(items[i], i));
+      }
+      return sequential;
+    }
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workers = Array.from(
+      { length: Math.min(safeConcurrency, items.length) },
+      async () => {
+        while (true) {
+          const current = nextIndex;
+          nextIndex++;
+          if (current >= items.length) return;
+          results[current] = await worker(items[current], current);
+        }
+      }
+    );
+    await Promise.all(workers);
+    return results;
+  }
+};
+
+// src/plugins/workflow.plugin.ts
+var DEFAULT_RETRY2 = {
+  maxAttempts: 3,
+  backoffMs: 1e3,
+  backoffMultiplier: 2
+};
+var WorkflowError = class extends Error {
+  result;
+  constructor(message, result) {
+    super(message);
+    this.name = "WorkflowError";
+    this.result = result;
+  }
+};
+function isWorkflowDefinition(input) {
+  return "id" in input && "name" in input;
+}
+var WorkflowPlugin = class extends BasePlugin {
+  name = "workflow";
+  steps;
+  initialContext;
+  definition;
+  engine;
+  lastResult;
+  constructor(config, engine) {
+    super();
+    if (isWorkflowDefinition(config)) {
+      this.definition = config;
+      this.steps = config.steps;
+      this.initialContext = config.initialContext ?? {};
+      this.engine = engine ?? new DefaultWorkflowEngine();
+    } else {
+      this.steps = config.steps;
+      this.initialContext = config.initialContext ?? {};
+    }
+  }
+  buildHooks() {
+    return {
+      beforeRun: this.beforeRun.bind(this)
+    };
+  }
+  getLastResult() {
+    return this.lastResult;
+  }
+  // ── Hook implementation ─────────────────────────────────────────────────
+  async beforeRun(_ctx, params) {
+    const result = this.definition && this.engine ? await this.engine.execute(this.definition) : await this.executeWorkflow();
+    this.lastResult = result;
+    if (result.status === "failed") {
+      throw new WorkflowError(
+        `Workflow failed at step "${result.failedStep}": ${result.error}`,
+        result
+      );
+    }
+    const contextSummary = Object.entries(result.context).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n");
+    return {
+      prompt: `${params.prompt}
+
+--- Workflow Context ---
+${contextSummary}`
+    };
+  }
+  // ── Built-in workflow engine (backward compatible) ──────────────────────
+  async executeWorkflow() {
+    const start = Date.now();
+    let context = structuredClone(this.initialContext);
+    const completedSteps = [];
+    const skippedSteps = [];
+    for (const step of this.steps) {
+      if (step.condition && !step.condition(context)) {
+        skippedSteps.push(step.id);
+        continue;
+      }
+      try {
+        context = await this.executeWithRetry(step, context);
+        completedSteps.push(step.id);
+      } catch (error) {
+        await this.rollback(completedSteps, context);
+        return {
+          status: "failed",
+          context,
+          completedSteps,
+          skippedSteps,
+          failedStep: step.id,
+          error: error instanceof Error ? error.message : String(error),
+          totalDurationMs: Date.now() - start
+        };
+      }
+    }
+    return {
+      status: "completed",
+      context,
+      completedSteps,
+      skippedSteps,
+      totalDurationMs: Date.now() - start
+    };
+  }
+  async executeWithRetry(step, context) {
+    const retry = { ...DEFAULT_RETRY2, ...step.retry };
+    let lastError;
+    for (let attempt = 1; attempt <= retry.maxAttempts; attempt++) {
+      try {
+        return await step.execute(context);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < retry.maxAttempts) {
+          const delay = retry.backoffMs * Math.pow(retry.backoffMultiplier, attempt - 1);
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+  async rollback(completedStepIds, context) {
+    for (const stepId of [...completedStepIds].reverse()) {
+      const step = this.steps.find((s) => s.id === stepId);
+      if (step?.rollback) {
+        try {
+          await step.rollback(context);
+        } catch {
+        }
+      }
+    }
+  }
+};
+function createWorkflowPlugin(config, engine) {
+  return new WorkflowPlugin(config, engine);
+}
+
+// src/plugins/utils/default-metrics.ts
+function createDefaultMetrics() {
+  return {
+    totalTokens: { input: 0, output: 0 },
+    totalLatencyMs: 0,
+    toolCalls: [],
+    llmCalls: []
+  };
+}
+
+// src/plugins/observability.plugin.ts
+var ObservabilityPlugin = class extends BasePlugin {
+  name = "observability";
+  version = "1.0.0";
+  config;
+  spans = /* @__PURE__ */ new Map();
+  rootSpans = [];
+  activeSpans = /* @__PURE__ */ new Map();
+  // sessionId → current root span
+  sessionMetrics = /* @__PURE__ */ new Map();
+  // sessionId → metrics
+  sessionStartTimes = /* @__PURE__ */ new Map();
+  // sessionId → run start time
+  toolStartTimes = /* @__PURE__ */ new Map();
+  // sessionId:toolName → start time stack (LIFO)
+  toolSpanStack = /* @__PURE__ */ new Map();
+  // sessionId:toolName → spanId stack (LIFO)
+  maxSpans;
+  constructor(config = {}) {
+    super();
+    this.config = {
+      enableTracing: true,
+      enableMetrics: true,
+      enableCostEstimation: false,
+      ...config
+    };
+    this.maxSpans = config.maxSpans ?? 1e4;
+  }
+  buildHooks() {
+    return {
+      beforeRun: this.onRequest.bind(this),
+      afterRun: this.onResponse.bind(this),
+      beforeTool: this.onToolStart.bind(this),
+      afterTool: this.onToolEnd.bind(this),
+      onError: this.onError.bind(this)
+    };
+  }
+  generateId() {
+    return Math.random().toString(36).substring(2, 15);
+  }
+  createSpan(name, traceId, parentId) {
+    if (this.spans.size >= this.maxSpans) {
+      const oldestKey = this.spans.keys().next().value;
+      if (oldestKey) {
+        const oldSpan = this.spans.get(oldestKey);
+        this.spans.delete(oldestKey);
+        if (oldSpan && !oldSpan.parentId) {
+          const idx = this.rootSpans.indexOf(oldSpan);
+          if (idx >= 0) this.rootSpans.splice(idx, 1);
+        }
+      }
+    }
+    const span = {
+      id: this.generateId(),
+      traceId,
+      name,
+      startTime: Date.now(),
+      attributes: {},
+      parentId,
+      status: "ok",
+      children: []
+    };
+    this.spans.set(span.id, span);
+    if (parentId) {
+      const parent = this.spans.get(parentId);
+      if (parent) {
+        parent.children.push(span);
+      }
+    } else {
+      this.rootSpans.push(span);
+    }
+    return span;
+  }
+  endSpan(spanId, status = "ok") {
+    const span = this.spans.get(spanId);
+    if (span) {
+      span.endTime = Date.now();
+      span.status = status;
+    }
+  }
+  getOrCreateMetrics(sessionId) {
+    let metrics = this.sessionMetrics.get(sessionId);
+    if (!metrics) {
+      metrics = createDefaultMetrics();
+      this.sessionMetrics.set(sessionId, metrics);
+    }
+    return metrics;
+  }
+  async onRequest(ctx, params) {
+    if (!this.config.enableTracing && !this.config.enableMetrics) {
+      return;
+    }
+    const sessionId = ctx.sessionId;
+    if (this.config.enableTracing) {
+      const traceId = this.generateId();
+      const span = this.createSpan("agent.run", traceId);
+      span.attributes = {
+        sessionId,
+        agentName: ctx.agentName,
+        prompt: params.prompt,
+        maxSteps: ctx.config.maxSteps
+      };
+      this.activeSpans.set(sessionId, span);
+    }
+    if (this.config.enableMetrics) {
+      this.sessionStartTimes.set(sessionId, Date.now());
+      this.sessionMetrics.set(sessionId, createDefaultMetrics());
+    }
+  }
+  async onResponse(ctx, params) {
+    if (!this.config.enableTracing && !this.config.enableMetrics) {
+      return;
+    }
+    const sessionId = ctx.sessionId;
+    const rootSpan = this.activeSpans.get(sessionId);
+    if (this.config.enableTracing && rootSpan) {
+      this.endSpan(rootSpan.id);
+      rootSpan.attributes.result = params.result.text;
+      rootSpan.attributes.steps = params.result.steps?.length || 0;
+    }
+    if (this.config.enableMetrics) {
+      const metrics = this.getOrCreateMetrics(sessionId);
+      const startTime = this.sessionStartTimes.get(sessionId);
+      if (startTime) {
+        metrics.totalLatencyMs = Date.now() - startTime;
+      }
+      if (this.config.enableCostEstimation && this.config.costPerInputToken && this.config.costPerOutputToken) {
+        metrics.estimatedCostUsd = metrics.totalTokens.input * this.config.costPerInputToken + metrics.totalTokens.output * this.config.costPerOutputToken;
+      }
+      this.sessionStartTimes.delete(sessionId);
+    }
+    this.activeSpans.delete(sessionId);
+  }
+  async onToolStart(ctx, params) {
+    if (!this.config.enableTracing && !this.config.enableMetrics) {
+      return;
+    }
+    if (this.config.enableMetrics) {
+      const metricsKey = `${ctx.sessionId}:${params.toolName}`;
+      const stack = this.toolStartTimes.get(metricsKey) ?? [];
+      stack.push(Date.now());
+      this.toolStartTimes.set(metricsKey, stack);
+    }
+    if (this.config.enableTracing) {
+      const rootSpan = this.activeSpans.get(ctx.sessionId);
+      const traceId = rootSpan?.traceId ?? this.generateId();
+      const toolSpan = this.createSpan(`tool.${params.toolName}`, traceId, rootSpan?.id);
+      toolSpan.attributes = {
+        toolName: params.toolName,
+        args: params.args
+      };
+      const stackKey = `${ctx.sessionId}:${params.toolName}`;
+      const stack = this.toolSpanStack.get(stackKey) ?? [];
+      stack.push(toolSpan.id);
+      this.toolSpanStack.set(stackKey, stack);
+    }
+  }
+  async onToolEnd(ctx, params) {
+    if (!this.config.enableTracing && !this.config.enableMetrics) {
+      return;
+    }
+    if (this.config.enableTracing) {
+      const spanKey = `${ctx.sessionId}:${params.toolName}`;
+      const stack = this.toolSpanStack.get(spanKey);
+      const spanId = stack?.pop();
+      if (spanId) {
+        const toolSpan = this.spans.get(spanId);
+        if (toolSpan) {
+          this.endSpan(toolSpan.id);
+          toolSpan.attributes.result = params.result;
+        }
+        if (stack && stack.length === 0) {
+          this.toolSpanStack.delete(spanKey);
+        }
+      }
+    }
+    if (this.config.enableMetrics) {
+      const key = `${ctx.sessionId}:${params.toolName}`;
+      const stack = this.toolStartTimes.get(key);
+      const startTime = stack?.pop();
+      const latencyMs = startTime ? Date.now() - startTime : 0;
+      if (stack && stack.length === 0) {
+        this.toolStartTimes.delete(key);
+      }
+      const metrics = this.getOrCreateMetrics(ctx.sessionId);
+      metrics.toolCalls.push({
+        name: params.toolName,
+        latencyMs,
+        success: true
+      });
+    }
+  }
+  async onError(ctx, params) {
+    if (!this.config.enableTracing) {
+      return;
+    }
+    const rootSpan = this.activeSpans.get(ctx.sessionId);
+    const unfinishedSpans = Array.from(this.spans.values()).filter((s) => !s.endTime && s.traceId === rootSpan?.traceId).sort((a, b) => b.startTime - a.startTime);
+    if (unfinishedSpans.length > 0) {
+      const span = unfinishedSpans[0];
+      this.endSpan(span.id, "error");
+      span.attributes.error = {
+        message: params.error instanceof Error ? params.error.message : String(params.error),
+        phase: params.phase
+      };
+    }
+  }
+  // Public methods
+  getTraces() {
+    return this.config.enableTracing ? [...this.rootSpans] : [];
+  }
+  getMetrics(sessionId) {
+    if (!this.config.enableMetrics) {
+      return createDefaultMetrics();
+    }
+    if (sessionId) {
+      const m = this.sessionMetrics.get(sessionId);
+      return m ? this.deepCopyMetrics(m) : createDefaultMetrics();
+    }
+    const entries = Array.from(this.sessionMetrics.values());
+    const last = entries[entries.length - 1];
+    return last ? this.deepCopyMetrics(last) : createDefaultMetrics();
+  }
+  deepCopyMetrics(m) {
+    return {
+      totalTokens: { ...m.totalTokens },
+      totalLatencyMs: m.totalLatencyMs,
+      toolCalls: m.toolCalls.map((t) => ({ ...t })),
+      llmCalls: m.llmCalls.map((l) => ({ ...l })),
+      estimatedCostUsd: m.estimatedCostUsd
+    };
+  }
+  exportOpenTelemetry() {
+    if (!this.config.enableTracing) {
+      return { resourceSpans: [] };
+    }
+    const spans = Array.from(this.spans.values()).map((span) => ({
+      traceId: span.traceId,
+      spanId: span.id,
+      parentSpanId: span.parentId,
+      name: span.name,
+      startTimeUnixNano: span.startTime * 1e6,
+      endTimeUnixNano: span.endTime ? span.endTime * 1e6 : void 0,
+      attributes: Object.entries(span.attributes).map(([key, value]) => ({
+        key,
+        value: { stringValue: String(value) }
+      })),
+      status: {
+        code: span.status === "ok" ? 1 : 2
+      }
+    }));
+    return {
+      resourceSpans: [{
+        resource: {
+          attributes: [
+            { key: "service.name", value: { stringValue: "deepagent" } },
+            { key: "service.version", value: { stringValue: this.version } }
+          ]
+        },
+        scopeSpans: [{
+          scope: {
+            name: "deepagent-observability",
+            version: this.version
+          },
+          spans
+        }]
+      }]
+    };
+  }
+  reset() {
+    this.spans.clear();
+    this.rootSpans = [];
+    this.activeSpans.clear();
+    this.sessionMetrics.clear();
+    this.sessionStartTimes.clear();
+    this.toolStartTimes.clear();
+    this.toolSpanStack.clear();
+  }
+};
+function createObservabilityPlugin(config) {
+  return new ObservabilityPlugin(config);
+}
+
+// src/plugins/semantic-scraping.plugin.ts
+import { z as z5 } from "zod";
+
+// src/adapters/semantic-scraping/semantic-scraping.adapter.ts
+function urlToPattern(url) {
+  try {
+    const u = new URL(url);
+    const path = u.pathname.replace(/\/+$/, "") || "/";
+    if (!u.search) return path;
+    const params = new URLSearchParams(u.search);
+    const wildcarded = [...params.keys()].sort().map((k) => `${k}=*`);
+    return `${path}?${wildcarded.join("&")}`;
+  } catch {
+    return url;
+  }
+}
+function hashTools(tools) {
+  const keys = tools.map(
+    (t) => `${t.name}:${t.description ?? ""}:${JSON.stringify(t.inputSchema ?? {})}`
+  ).sort();
+  let h = 0;
+  const s = keys.join("|");
+  for (let i = 0; i < s.length; i++) {
+    h = (h << 5) - h + s.charCodeAt(i) | 0;
+  }
+  return h.toString(36);
+}
+function parseSchema(schema) {
+  if (typeof schema === "string") {
+    try {
+      return JSON.parse(schema);
+    } catch {
+      return { type: "object", properties: {} };
+    }
+  }
+  return schema;
+}
+function toManifestTool(tool2, pattern) {
+  const schema = parseSchema(tool2.inputSchema);
+  const annotations = tool2.annotations ? { ...tool2.annotations } : void 0;
+  return {
+    name: tool2.name,
+    description: tool2.description,
+    inputSchema: schema,
+    category: tool2.category,
+    annotations,
+    pagePatterns: [pattern]
+  };
+}
+function rebuildTools(pages, toolsByName) {
+  const consolidated = /* @__PURE__ */ new Map();
+  for (const [, entry] of toolsByName) {
+    const existing = consolidated.get(entry.tool.name);
+    if (existing) {
+      for (const p of entry.patterns) existing.patterns.add(p);
+    } else {
+      consolidated.set(entry.tool.name, {
+        tool: entry.tool,
+        patterns: new Set(entry.patterns)
+      });
+    }
+  }
+  const activeToolNames = /* @__PURE__ */ new Set();
+  for (const page of Object.values(pages)) {
+    for (const name of page.tools) activeToolNames.add(name);
+  }
+  const result = [];
+  for (const [name, entry] of consolidated) {
+    if (!activeToolNames.has(name)) continue;
+    result.push({
+      ...entry.tool,
+      pagePatterns: [...entry.patterns].sort()
+    });
+  }
+  return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+var SemanticScrapingAdapter = class {
+  manifests = /* @__PURE__ */ new Map();
+  getManifest(origin) {
+    return this.manifests.get(origin)?.manifest ?? null;
+  }
+  updatePage(origin, url, tools) {
+    const pattern = urlToPattern(url);
+    const hash = hashTools(
+      tools.map((t) => ({
+        ...t,
+        inputSchema: parseSchema(t.inputSchema)
+      }))
+    );
+    const now = Date.now();
+    const existing = this.manifests.get(origin);
+    const toolIndex = existing?.toolIndex ?? /* @__PURE__ */ new Map();
+    const oldPages = existing?.manifest.pages ?? {};
+    const oldPage = oldPages[pattern];
+    if (oldPage) {
+      for (const toolName of oldPage.tools) {
+        const entry = toolIndex.get(toolName);
+        if (entry) {
+          entry.patterns.delete(pattern);
+          if (entry.patterns.size === 0) toolIndex.delete(toolName);
+        }
+      }
+    }
+    const toolNames = [];
+    for (const tool2 of tools) {
+      toolNames.push(tool2.name);
+      const entry = toolIndex.get(tool2.name);
+      if (entry) {
+        entry.patterns.add(pattern);
+        entry.tool = toManifestTool(tool2, pattern);
+      } else {
+        toolIndex.set(tool2.name, {
+          tool: toManifestTool(tool2, pattern),
+          patterns: /* @__PURE__ */ new Set([pattern])
+        });
+      }
+    }
+    const pageToolSet = {
+      urlPattern: pattern,
+      tools: toolNames,
+      lastScanned: now,
+      hash
+    };
+    const pages = {
+      ...oldPages,
+      [pattern]: pageToolSet
+    };
+    const deduped = rebuildTools(pages, toolIndex);
+    const manifest = {
+      origin,
+      version: (existing?.manifest.version ?? 0) + 1,
+      generatedAt: now,
+      pages,
+      tools: deduped
+    };
+    this.manifests.set(origin, { manifest, toolIndex });
+    return manifest;
+  }
+  applyDiff(origin, url, added, removed) {
+    const pattern = urlToPattern(url);
+    const now = Date.now();
+    const existing = this.manifests.get(origin);
+    const toolIndex = existing?.toolIndex ?? /* @__PURE__ */ new Map();
+    const oldPages = existing?.manifest.pages ?? {};
+    const oldPage = oldPages[pattern];
+    const currentTools = new Set(oldPage?.tools ?? []);
+    for (const name of removed) {
+      currentTools.delete(name);
+      const entry = toolIndex.get(name);
+      if (entry) {
+        entry.patterns.delete(pattern);
+        if (entry.patterns.size === 0) toolIndex.delete(name);
+      }
+    }
+    for (const tool2 of added) {
+      currentTools.add(tool2.name);
+      const entry = toolIndex.get(tool2.name);
+      if (entry) {
+        entry.patterns.add(pattern);
+        entry.tool = toManifestTool(tool2, pattern);
+      } else {
+        toolIndex.set(tool2.name, {
+          tool: toManifestTool(tool2, pattern),
+          patterns: /* @__PURE__ */ new Set([pattern])
+        });
+      }
+    }
+    const toolNames = [...currentTools];
+    const hash = hashTools(
+      toolNames.map((n) => toolIndex.get(n)?.tool).filter(Boolean).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }))
+    );
+    const pageToolSet = {
+      urlPattern: pattern,
+      tools: toolNames,
+      lastScanned: now,
+      hash
+    };
+    const pages = {
+      ...oldPages,
+      [pattern]: pageToolSet
+    };
+    const deduped = rebuildTools(pages, toolIndex);
+    const manifest = {
+      origin,
+      version: (existing?.manifest.version ?? 0) + 1,
+      generatedAt: now,
+      pages,
+      tools: deduped
+    };
+    this.manifests.set(origin, { manifest, toolIndex });
+    return manifest;
+  }
+  toMCPJson(origin) {
+    const manifest = this.getManifest(origin);
+    if (!manifest) return JSON.stringify({ tools: [] });
+    const mcpTools = manifest.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema,
+      ...t.annotations ? { annotations: t.annotations } : {}
+    }));
+    return JSON.stringify({
+      tools: mcpTools,
+      _meta: {
+        origin: manifest.origin,
+        version: manifest.version,
+        generatedAt: manifest.generatedAt,
+        pageCount: Object.keys(manifest.pages).length,
+        toolCount: manifest.tools.length
+      }
+    });
+  }
+  getToolsForUrl(origin, url) {
+    const manifest = this.getManifest(origin);
+    if (!manifest) return [];
+    const pattern = urlToPattern(url);
+    const page = manifest.pages[pattern];
+    if (!page) return [];
+    const toolNames = new Set(page.tools);
+    return manifest.tools.filter((t) => toolNames.has(t.name));
+  }
+};
+
+// src/plugins/semantic-scraping.plugin.ts
+var SemanticToolSchema = z5.object({
+  name: z5.string(),
+  description: z5.string(),
+  inputSchema: z5.union([z5.string(), z5.record(z5.string(), z5.unknown())]),
+  confidence: z5.number().optional(),
+  category: z5.string().optional(),
+  annotations: z5.record(z5.string(), z5.boolean()).optional()
+});
+var ScanPageInputSchema = z5.object({
+  url: z5.string().url().describe("The page URL that was scanned"),
+  tools: z5.array(SemanticToolSchema).describe("Semantic tools extracted from the page HTML")
+});
+var GetManifestInputSchema = z5.object({
+  origin: z5.string().describe("Site origin (e.g., https://example.com)")
+});
+var GetToolsForUrlInputSchema = z5.object({
+  origin: z5.string().describe("Site origin (e.g., https://example.com)"),
+  url: z5.string().url().describe("The URL to get tools for")
+});
+var SemanticScrapingPlugin = class extends BasePlugin {
+  name = "semantic-scraping";
+  adapter;
+  constructor(options = {}) {
+    super();
+    this.adapter = options.adapter ?? new SemanticScrapingAdapter();
+  }
+  buildHooks() {
+    return {};
+  }
+  get tools() {
+    const adapter = this.adapter;
+    return {
+      semantic_scan_page: tool({
+        description: "Register semantic tools extracted from a web page into the site manifest",
+        inputSchema: ScanPageInputSchema,
+        execute: async (args) => {
+          const { url, tools: rawTools } = args;
+          const origin = new URL(url).origin;
+          const semanticTools = rawTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            confidence: t.confidence,
+            category: t.category,
+            annotations: t.annotations
+          }));
+          const manifest = adapter.updatePage(origin, url, semanticTools);
+          return {
+            origin,
+            version: manifest.version,
+            toolCount: manifest.tools.length,
+            pageCount: Object.keys(manifest.pages).length
+          };
+        }
+      }),
+      get_site_manifest: tool({
+        description: "Get the MCP-compatible JSON manifest for a site",
+        inputSchema: GetManifestInputSchema,
+        execute: async (args) => {
+          const { origin } = args;
+          return adapter.toMCPJson(origin);
+        }
+      }),
+      get_tools_for_url: tool({
+        description: "Get the semantic tools available at a specific URL",
+        inputSchema: GetToolsForUrlInputSchema,
+        execute: async (args) => {
+          const { origin, url } = args;
+          return adapter.getToolsForUrl(origin, url);
+        }
+      })
+    };
+  }
+};
+function createSemanticScrapingPlugin(options = {}) {
+  return new SemanticScrapingPlugin(options);
+}
+
+// src/plugins/semantic-web-search.plugin.ts
+import { z as z6 } from "zod";
+var strategySchema = z6.enum(["tfidf", "bm25", "mmr"]);
+var SemanticWebSearchPlugin = class extends BasePlugin {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.reranker = options.reranker ?? new DefaultReRankingAdapter();
+    this.telemetry = options.telemetry;
+    this.costTracker = options.costTracker;
+    this.costModel = options.costModel ?? "gpt-5.2-mini";
+    this.emitTelemetry = options.emitTelemetry ?? true;
+    this.cache = options.cache ?? new ToolCache();
+    this.circuitBreaker = options.circuitBreaker ?? new CircuitBreaker();
+    this.defaultLimit = options.defaultLimit ?? 5;
+    this.defaultScrapeTopK = options.defaultScrapeTopK ?? 2;
+    this.defaultStrategy = options.defaultStrategy ?? "bm25";
+    this.fallbackStrategy = options.fallbackStrategy ?? "tfidf";
+    this.fallbackOnRerankError = options.fallbackOnRerankError ?? true;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.retryDelayMs = options.retryDelayMs ?? 200;
+    this.cacheTtlMs = options.cacheTtlMs ?? 6e4;
+  }
+  name = "Semantic Web Search";
+  description = "Native search\u2192rerank\u2192citation pipeline for high-quality web evidence.";
+  crawlerPromise = null;
+  reranker;
+  telemetry;
+  costTracker;
+  costModel;
+  emitTelemetry;
+  cache;
+  circuitBreaker;
+  defaultLimit;
+  defaultScrapeTopK;
+  defaultStrategy;
+  fallbackStrategy;
+  fallbackOnRerankError;
+  requestTimeoutMs;
+  maxRetries;
+  retryDelayMs;
+  cacheTtlMs;
+  buildHooks() {
+    return {};
+  }
+  get tools() {
+    return {
+      semantic_web_search: tool({
+        description: "Search the web, rerank semantically and return ranked citations.",
+        inputSchema: z6.object({
+          query: z6.string().min(1),
+          limit: z6.number().int().min(1).max(20).optional(),
+          scrapeTopK: z6.number().int().min(0).max(10).optional(),
+          strategy: strategySchema.optional()
+        }),
+        execute: async (input) => {
+          const limit = input.limit ?? this.defaultLimit;
+          const scrapeTopK = input.scrapeTopK ?? this.defaultScrapeTopK;
+          const strategy = input.strategy ?? this.defaultStrategy;
+          const startedAt = Date.now();
+          const traceId = crypto.randomUUID();
+          this.emitEvent("semantic_search_started", {
+            traceId,
+            query: input.query,
+            limit,
+            scrapeTopK,
+            strategy
+          });
+          const cacheKey = `semantic-web:${input.query}:${limit}:${scrapeTopK}:${strategy}`;
+          const cached = this.cache.get(cacheKey);
+          if (cached) {
+            const cacheResponse = {
+              ...cached,
+              quality: {
+                ...cached.quality,
+                traceId,
+                cacheServed: true
+              },
+              cacheHit: true
+            };
+            this.emitEvent("semantic_search_cache_hit", {
+              traceId,
+              query: input.query,
+              resultCount: cacheResponse.results.length
+            });
+            this.emitMetric("semantic_search_cache_hit", 1, {
+              strategy
+            });
+            return {
+              ...cacheResponse
+            };
+          }
+          try {
+            const crawler = await this.getCrawler();
+            const {
+              value: rawSearch,
+              attempts: searchAttempts
+            } = await this.executeWithRetry(
+              "search",
+              async () => crawler.search(input.query, { limit })
+            );
+            const normalized = this.normalizeResults(rawSearch, limit);
+            const { failures: scrapeFailures, attempts: scrapeAttempts } = await this.enrichTopResults(normalized, scrapeTopK, crawler);
+            const byId = new Map(normalized.map((candidate) => [candidate.id, candidate]));
+            const toRank = normalized.map((candidate) => ({
+              id: candidate.id,
+              text: candidate.content,
+              score: 1
+            }));
+            let reranked;
+            let strategyUsed = strategy;
+            let fallbackUsed = false;
+            try {
+              reranked = this.reranker.rerank(input.query, toRank, {
+                strategy
+              });
+            } catch (error) {
+              if (!this.fallbackOnRerankError || strategy === this.fallbackStrategy) {
+                throw error;
+              }
+              reranked = this.reranker.rerank(input.query, toRank, {
+                strategy: this.fallbackStrategy
+              });
+              strategyUsed = this.fallbackStrategy;
+              fallbackUsed = true;
+            }
+            const results = reranked.slice(0, limit).map((result, index) => {
+              const source = byId.get(result.id);
+              const title = source?.title ?? result.id;
+              const url = source?.url ?? "";
+              const snippet = source?.snippet ?? result.text.slice(0, 300);
+              const citation = `[${index + 1}] ${title} \u2014 ${url}`;
+              return {
+                rank: index + 1,
+                score: result.score,
+                title,
+                url,
+                snippet,
+                citation
+              };
+            });
+            const durationMs = Date.now() - startedAt;
+            const quality = {
+              traceId,
+              cacheServed: false,
+              durationMs,
+              strategyRequested: strategy,
+              strategyUsed,
+              fallbackUsed,
+              candidates: normalized.length,
+              reranked: reranked.length,
+              averageScore: this.calculateAverageScore(reranked),
+              searchAttempts,
+              scrapeAttempts,
+              scrapeFailures
+            };
+            const cost = this.buildCostRecord(
+              input.query,
+              results,
+              quality
+            );
+            const response = {
+              query: input.query,
+              results,
+              citations: results.map((result) => result.citation),
+              quality,
+              ...cost ? {
+                cost: {
+                  model: this.costModel,
+                  promptTokens: cost.promptTokens,
+                  completionTokens: cost.completionTokens,
+                  totalTokens: cost.totalTokens,
+                  totalCost: cost.totalCost,
+                  currency: "USD"
+                }
+              } : {},
+              cacheHit: false
+            };
+            this.emitEvent("semantic_search_completed", {
+              traceId,
+              query: input.query,
+              resultCount: results.length,
+              durationMs,
+              fallbackUsed,
+              strategyUsed,
+              cacheHit: false,
+              ...cost ? { totalCost: cost.totalCost, totalTokens: cost.totalTokens } : {}
+            });
+            this.emitMetric("semantic_search_duration_ms", durationMs, {
+              strategy: strategyUsed,
+              fallback: fallbackUsed ? "true" : "false"
+            });
+            if (cost) {
+              this.emitMetric("semantic_search_cost_usd", cost.totalCost, {
+                model: this.costModel
+              });
+            }
+            this.cache.set(cacheKey, response, this.cacheTtlMs);
+            return response;
+          } catch (error) {
+            this.emitEvent("semantic_search_failed", {
+              traceId,
+              query: input.query,
+              durationMs: Date.now() - startedAt,
+              error: error instanceof Error ? error.message : String(error)
+            }, "ERROR");
+            this.emitMetric("semantic_search_failure", 1, {
+              strategy
+            });
+            throw error;
+          }
+        }
+      })
+    };
+  }
+  async dispose() {
+    if (!this.crawlerPromise) return;
+    const crawler = await this.crawlerPromise;
+    await crawler?.close?.();
+  }
+  getCrawler() {
+    if (!this.crawlerPromise) {
+      this.crawlerPromise = this.initCrawler();
+    }
+    return this.crawlerPromise;
+  }
+  async initCrawler() {
+    if (this.options.crawler) {
+      return this.options.crawler;
+    }
+    try {
+      const mod = await import("onecrawl");
+      const CrawlerClass = mod.Crawler ?? mod.default?.Crawler ?? mod.default;
+      return new CrawlerClass({
+        ...this.options.apiKey ? { apiKey: this.options.apiKey } : {}
+      });
+    } catch {
+      throw new Error(
+        'SemanticWebSearchPlugin requires "onecrawl" package. Install it: pnpm add onecrawl'
+      );
+    }
+  }
+  normalizeResults(raw, limit) {
+    if (!Array.isArray(raw)) {
+      return [];
+    }
+    return raw.slice(0, limit).map((entry, index) => this.normalizeEntry(entry, index)).filter((entry) => entry !== null);
+  }
+  normalizeEntry(entry, index) {
+    if (!entry || typeof entry !== "object") {
+      return null;
+    }
+    const item = entry;
+    const url = item.url ?? item.link;
+    if (!url) {
+      return null;
+    }
+    const title = item.title ?? `Result ${index + 1}`;
+    const snippet = item.snippet ?? item.description ?? "";
+    const content = item.content ?? item.text ?? snippet ?? title;
+    return {
+      id: `result-${index + 1}`,
+      title,
+      url,
+      snippet,
+      content
+    };
+  }
+  async enrichTopResults(candidates, scrapeTopK, crawler) {
+    if (!crawler.crawl || scrapeTopK <= 0) {
+      return { failures: 0, attempts: 0 };
+    }
+    const targets = candidates.slice(0, Math.min(scrapeTopK, candidates.length));
+    let failures = 0;
+    let attempts = 0;
+    await Promise.all(
+      targets.map(async (candidate) => {
+        try {
+          const result = await this.executeWithRetry(
+            "scrape",
+            async () => crawler.crawl(candidate.url)
+          );
+          attempts += result.attempts;
+          const raw = result.value;
+          const normalized = this.normalizeCrawlContent(raw);
+          if (normalized.length > 0) {
+            candidate.content = normalized;
+          }
+        } catch {
+          failures += 1;
+          attempts += this.maxRetries + 1;
+        }
+      })
+    );
+    return { failures, attempts };
+  }
+  normalizeCrawlContent(raw) {
+    if (typeof raw === "string") {
+      return raw;
+    }
+    if (raw && typeof raw === "object") {
+      const item = raw;
+      return item.content ?? item.text ?? item.snippet ?? item.description ?? "";
+    }
+    return "";
+  }
+  async executeWithRetry(label, operation) {
+    let lastError;
+    for (let attempt = 1; attempt <= this.maxRetries + 1; attempt++) {
+      try {
+        const value = await this.circuitBreaker.execute(
+          () => this.withTimeout(operation(), `${label} attempt ${attempt}`)
+        );
+        return { value, attempts: attempt };
+      } catch (error) {
+        lastError = error;
+        if (attempt <= this.maxRetries) {
+          await this.sleep(this.retryDelayMs * attempt);
+        }
+      }
+    }
+    throw lastError;
+  }
+  async withTimeout(promise, label) {
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`${label} timed out after ${this.requestTimeoutMs}ms`));
+      }, this.requestTimeoutMs);
+      promise.then((value) => {
+        clearTimeout(timer);
+        resolve(value);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  async sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  calculateAverageScore(results) {
+    if (results.length === 0) return 0;
+    const sum = results.reduce((acc, item) => acc + item.score, 0);
+    return sum / results.length;
+  }
+  buildCostRecord(query, results, quality) {
+    if (!this.costTracker) {
+      return void 0;
+    }
+    const promptTokens = this.estimateTokens(query);
+    const completionText = results.map((result) => `${result.title}
+${result.snippet}
+${result.citation}`).join("\n\n");
+    const completionTokens = this.estimateTokens(completionText);
+    const totalTokens = promptTokens + completionTokens;
+    const usage = {
+      model: this.costModel,
+      provider: "semantic-web-search",
+      inputTokens: promptTokens,
+      outputTokens: completionTokens,
+      timestamp: Date.now()
+    };
+    const totalBefore = this.costTracker.getEstimate().totalCost;
+    this.costTracker.recordUsage(usage);
+    const totalAfter = this.costTracker.getEstimate().totalCost;
+    const totalCost = Math.max(0, totalAfter - totalBefore);
+    this.emitEvent("semantic_search_cost_recorded", {
+      traceId: quality.traceId,
+      model: this.costModel,
+      promptTokens,
+      completionTokens,
+      totalTokens,
+      totalCost
+    });
+    return {
+      promptTokens,
+      completionTokens,
+      totalTokens,
+      totalCost
+    };
+  }
+  estimateTokens(text) {
+    if (text.trim().length === 0) {
+      return 0;
+    }
+    return Math.max(1, Math.ceil(text.length / 4));
+  }
+  emitEvent(name, properties, status = "OK") {
+    if (!this.emitTelemetry || !this.telemetry) {
+      return;
+    }
+    try {
+      const span = this.telemetry.startSpan(name);
+      for (const [key, value] of Object.entries(properties)) {
+        span.setAttribute(key, this.toTelemetryAttribute(value));
+      }
+      span.setStatus(status);
+      span.end();
+    } catch {
+    }
+  }
+  emitMetric(name, value, tags) {
+    if (!this.emitTelemetry || !this.telemetry) {
+      return;
+    }
+    try {
+      this.telemetry.recordMetric(name, value, tags);
+    } catch {
+    }
+  }
+  toTelemetryAttribute(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      return value;
+    }
+    if (value === null || value === void 0) {
+      return "";
+    }
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+};
+function createSemanticWebSearchPlugin(options = {}) {
+  return new SemanticWebSearchPlugin(options);
+}
+
+// src/plugins/mcp-server.plugin.ts
+import { z as z7 } from "zod";
+
+// src/adapters/mcp-server/default-mcp-server.adapter.ts
+import { createServer } from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+var DefaultMcpServerAdapter = class _DefaultMcpServerAdapter {
+  tools = [];
+  toolsByName = /* @__PURE__ */ new Map();
+  executor;
+  options;
+  // stdio
+  stdinHandler;
+  stdinBuffer = "";
+  // sse
+  httpServer;
+  sseClients = /* @__PURE__ */ new Map();
+  constructor(tools, executor) {
+    this.tools = tools;
+    this.rebuildToolIndex();
+    this.executor = executor;
+  }
+  rebuildToolIndex() {
+    this.toolsByName.clear();
+    for (const t of this.tools) {
+      this.toolsByName.set(t.name, t);
+    }
+  }
+  // ── Public API ──────────────────────────────────────────────────────────
+  getRegisteredTools() {
+    return [...this.tools];
+  }
+  setTools(tools) {
+    this.tools = tools;
+    this.rebuildToolIndex();
+  }
+  async start(options) {
+    this.options = options;
+    const filtered = options.toolFilter ? this.tools.filter((t) => options.toolFilter.includes(t.name)) : this.tools;
+    this.tools = filtered;
+    this.rebuildToolIndex();
+    if (options.transport === "stdio") {
+      this.startStdio();
+    } else {
+      await this.startSse(options.port ?? 3100);
+    }
+  }
+  async stop() {
+    if (this.stdinHandler) {
+      process.stdin.removeListener("data", this.stdinHandler);
+      this.stdinHandler = void 0;
+      this.stdinBuffer = "";
+    }
+    if (this.httpServer) {
+      for (const [, client] of this.sseClients) {
+        client.end();
+      }
+      this.sseClients.clear();
+      await new Promise((resolve, reject) => {
+        this.httpServer.close((err) => err ? reject(err) : resolve());
+      });
+      this.httpServer = void 0;
+    }
+  }
+  // ── JSON-RPC handler ──────────────────────────────────────────────────
+  async handleRequest(request) {
+    const { id, method, params } = request;
+    switch (method) {
+      case "initialize":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            serverInfo: {
+              name: this.options?.name ?? "gaussflow-mcp-server",
+              version: this.options?.version ?? "1.0.0"
+            },
+            capabilities: {
+              tools: { listChanged: false }
+            }
+          }
+        };
+      case "tools/list":
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: this.tools.map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema
+            }))
+          }
+        };
+      case "tools/call": {
+        const toolName = params?.name ?? "";
+        const toolArgs = params?.arguments ?? {};
+        const toolDef = this.toolsByName.get(toolName);
+        if (!toolDef) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Unknown tool: ${toolName}` }
+          };
+        }
+        try {
+          const result = await this.executor(toolName, toolArgs);
+          return { jsonrpc: "2.0", id, result };
+        } catch (err) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            result: {
+              content: [{ type: "text", text: String(err) }],
+              isError: true
+            }
+          };
+        }
+      }
+      case "notifications/initialized":
+        return { jsonrpc: "2.0", id, result: {} };
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32601, message: `Method not found: ${method}` }
+        };
+    }
+  }
+  // ── Stdio transport ───────────────────────────────────────────────────
+  startStdio() {
+    this.stdinBuffer = "";
+    this.stdinHandler = (data) => {
+      this.stdinBuffer += data.toString("utf-8");
+      let newlineIdx;
+      while ((newlineIdx = this.stdinBuffer.indexOf("\n")) !== -1) {
+        const line = this.stdinBuffer.slice(0, newlineIdx).trim();
+        this.stdinBuffer = this.stdinBuffer.slice(newlineIdx + 1);
+        if (!line) continue;
+        this.processStdioLine(line).catch((err) => {
+          console.warn("[mcp-stdio] Unhandled error processing line:", err instanceof Error ? err.message : String(err));
+        });
+      }
+    };
+    process.stdin.on("data", this.stdinHandler);
+  }
+  async processStdioLine(line) {
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      const errResponse = {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Parse error" }
+      };
+      process.stdout.write(JSON.stringify(errResponse) + "\n");
+      return;
+    }
+    const response = await this.handleRequest(request);
+    if (request.id !== null && request.id !== void 0) {
+      process.stdout.write(JSON.stringify(response) + "\n");
+    }
+  }
+  // ── SSE transport ─────────────────────────────────────────────────────
+  startSse(port) {
+    return new Promise((resolve, reject) => {
+      this.httpServer = createServer((req, res) => {
+        this.handleHttpRequest(req, res).catch((err) => {
+          console.warn("[mcp-sse] Unhandled request error:", err instanceof Error ? err.message : String(err));
+          if (!res.headersSent) {
+            res.writeHead(500);
+            res.end();
+          }
+        });
+      });
+      this.httpServer.once("error", reject);
+      this.httpServer.listen(port, "127.0.0.1", () => resolve());
+    });
+  }
+  async handleHttpRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "http://localhost");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname === "/sse" && req.method === "GET") {
+      const clientId = randomUUID2();
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.write(`data: ${JSON.stringify({ type: "endpoint", url: `/message?clientId=${clientId}` })}
+
+`);
+      this.sseClients.set(clientId, res);
+      req.on("close", () => this.sseClients.delete(clientId));
+      return;
+    }
+    if (url.pathname === "/message" && req.method === "POST") {
+      const body = await this.readBody(req);
+      let request;
+      try {
+        request = JSON.parse(body);
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } }));
+        return;
+      }
+      const response = await this.handleRequest(request);
+      const responseJson = JSON.stringify(response);
+      const clientId = url.searchParams.get("clientId");
+      if (clientId) {
+        const client = this.sseClients.get(clientId);
+        if (client) client.write(`data: ${responseJson}
+
+`);
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(responseJson);
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found" }));
+  }
+  static MAX_BODY_SIZE = 1048576;
+  // 1 MB
+  readBody(req) {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let size = 0;
+      req.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > _DefaultMcpServerAdapter.MAX_BODY_SIZE) {
+          req.destroy(new Error("Request body too large"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      req.on("error", reject);
+    });
+  }
+};
+
+// src/plugins/mcp-server.plugin.ts
+var START_SCHEMA = z7.object({
+  transport: z7.enum(["stdio", "sse"]).default("stdio"),
+  port: z7.number().optional(),
+  toolFilter: z7.array(z7.string()).optional()
+});
+var STOP_SCHEMA = z7.object({});
+var McpServerPlugin = class {
+  name = "mcp-server";
+  version = "1.0.0";
+  tools;
+  adapter;
+  pluginOptions;
+  collectedTools = [];
+  constructor(options = {}) {
+    this.pluginOptions = options;
+    this.tools = {
+      "mcp:start-server": tool({
+        description: "Start an MCP server that exposes the agent's tools via MCP protocol. Supports stdio (default) and sse transports.",
+        inputSchema: START_SCHEMA,
+        execute: async (input) => {
+          const args = START_SCHEMA.parse(input ?? {});
+          if (this.adapter) {
+            await this.adapter.stop();
+          }
+          this.adapter = new DefaultMcpServerAdapter(
+            this.collectedTools,
+            this.pluginOptions.executor ?? this.defaultExecutor.bind(this)
+          );
+          await this.adapter.start({
+            name: this.pluginOptions.name ?? "gaussflow-mcp-server",
+            version: this.pluginOptions.version ?? "1.0.0",
+            transport: args.transport,
+            port: args.port,
+            toolFilter: args.toolFilter
+          });
+          const tools = this.adapter.getRegisteredTools();
+          return {
+            status: "started",
+            transport: args.transport,
+            port: args.transport === "sse" ? args.port ?? 3100 : void 0,
+            toolCount: tools.length,
+            tools: tools.map((t) => t.name)
+          };
+        }
+      }),
+      "mcp:stop-server": tool({
+        description: "Stop the running MCP server.",
+        inputSchema: STOP_SCHEMA,
+        execute: async () => {
+          if (!this.adapter) {
+            return { status: "not_running" };
+          }
+          await this.adapter.stop();
+          this.adapter = void 0;
+          return { status: "stopped" };
+        }
+      })
+    };
+  }
+  async setup(ctx) {
+    this.collectedTools = ctx.toolNames.map((name) => ({
+      name,
+      description: `Agent tool: ${name}`,
+      inputSchema: { type: "object", properties: {} }
+    }));
+    if (this.pluginOptions.extraTools) {
+      this.collectedTools.push(...this.pluginOptions.extraTools);
+    }
+  }
+  async dispose() {
+    if (this.adapter) {
+      await this.adapter.stop();
+      this.adapter = void 0;
+    }
+  }
+  /** Expose the underlying adapter for testing */
+  getAdapter() {
+    return this.adapter;
+  }
+  /** Expose collected tools for testing */
+  getCollectedTools() {
+    return [...this.collectedTools];
+  }
+  async defaultExecutor(name, _args) {
+    return {
+      content: [{ type: "text", text: `Tool "${name}" executed (no custom executor provided)` }]
+    };
+  }
+};
+function createMcpServerPlugin(options) {
+  return new McpServerPlugin(options);
+}
+export {
+  A2ADelegationManager,
+  A2APlugin,
+  A2APushNotifier,
+  AgentCardPlugin,
+  BasePlugin,
+  EvalsPlugin,
+  GuardrailsError,
+  GuardrailsPlugin,
+  McpServerPlugin,
+  ObservabilityPlugin,
+  OneCrawlPlugin,
+  PluginManager,
+  SemanticScrapingPlugin,
+  SemanticWebSearchPlugin,
+  VectorlessPlugin,
+  WorkflowError,
+  WorkflowPlugin,
+  createA2AHttpHandler,
+  createA2AJsonRpcHandler,
+  createA2APlugin,
+  createA2ASseHandler,
+  createAgentCardPlugin,
+  createEvalsPlugin,
+  createGuardrailsPlugin,
+  createMcpServerPlugin,
+  createObservabilityPlugin,
+  createOneCrawlPlugin,
+  createPiiFilter,
+  createSemanticScrapingPlugin,
+  createSemanticWebSearchPlugin,
+  createVectorlessPlugin,
+  createWorkflowPlugin
+};
+//# sourceMappingURL=plugins-L4ING3CX.js.map