gauss-ai 4.0.0

package/dist/chunk-CJZ66SU3.cjs

@@ -0,0 +1,4321 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15;
+
+
+var _chunk6XF673YCcjs = require('./chunk-6XF673YC.cjs');
+
+
+var _chunkPSJIAGDEcjs = require('./chunk-PSJIAGDE.cjs');
+
+
+var _chunkQYOMQBBZcjs = require('./chunk-QYOMQBBZ.cjs');
+
+
+var _chunkDAMT2CXWcjs = require('./chunk-DAMT2CXW.cjs');
+
+// src/plugins/base.plugin.ts
+var BasePlugin = (_class = class {
+  __init() {this.version = "1.0.0"}
+  
+  constructor() {;_class.prototype.__init.call(this);
+    this.hooks = this.buildHooks();
+  }
+}, _class);
+
+// src/plugins/agent-card.plugin.ts
+var _zod = require('zod');
+var DEFAULT_AGENTS_PATH = "agents.md";
+var DEFAULT_SKILLS_PATH = "skills.md";
+var DEFAULT_ZONES = ["persistent", "transient"];
+var AgentCardPlugin = (_class2 = class {
+  __init2() {this.name = "agent-card"}
+  __init3() {this.version = "1.0.0"}
+  
+  
+  
+  
+  __init4() {this.hooks = {
+    beforeRun: async (ctx, _params) => {
+      this.latestCtx = ctx;
+    },
+    afterRun: async (ctx, _params) => {
+      this.latestCtx = ctx;
+    }
+  }}
+  constructor(options = {}) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
+    this.options = {
+      paths: {
+        agents: _nullishCoalesce(_optionalChain([options, 'access', _2 => _2.paths, 'optionalAccess', _3 => _3.agents]), () => ( DEFAULT_AGENTS_PATH)),
+        skills: _nullishCoalesce(_optionalChain([options, 'access', _4 => _4.paths, 'optionalAccess', _5 => _5.skills]), () => ( DEFAULT_SKILLS_PATH))
+      },
+      readZones: _nullishCoalesce(options.readZones, () => ( DEFAULT_ZONES)),
+      overrides: options.overrides
+    };
+    this.tools = {
+      "agent-card:get": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Return generated or manual agent card documents.",
+        inputSchema: _zod.z.object({
+          target: _zod.z.enum(["agents", "skills", "all"]).default("all")
+        }),
+        execute: async (args) => {
+          const parsed = _zod.z.object({ target: _zod.z.enum(["agents", "skills", "all"]).default("all") }).parse(_nullishCoalesce(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 = _nullishCoalesce(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 = _optionalChain([this, 'access', _6 => _6.options, 'access', _7 => _7.overrides, 'optionalAccess', _8 => _8.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 = _optionalChain([this, 'access', _9 => _9.options, 'access', _10 => _10.overrides, 'optionalAccess', _11 => _11.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 (e2) {
+      }
+    }
+    return null;
+  }
+  createAutoAgentCard(ctx) {
+    const name = _nullishCoalesce(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 = _nullishCoalesce(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");
+  }
+}, _class2);
+function createAgentCardPlugin(options) {
+  return new AgentCardPlugin(options);
+}
+
+// src/plugins/a2a.plugin.ts
+
+
+// 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 = _nullishCoalesce(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 = _nullishCoalesce(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: _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(_optionalChain([agentCard, 'optionalAccess', _12 => _12.name]), () => ( _optionalChain([agentCard, 'optionalAccess', _13 => _13.source, 'optionalAccess', _14 => _14.name]))), () => ( "Agent"));
+        const cardDescription = _nullishCoalesce(_nullishCoalesce(_optionalChain([agentCard, 'optionalAccess', _15 => _15.instructions]), () => ( _optionalChain([agentCard, 'optionalAccess', _16 => _16.agentsMd]))), () => ( "A2A-compatible agent"));
+        const cardTools = _nullishCoalesce(_optionalChain([agentCard, 'optionalAccess', _17 => _17.tools]), () => ( []));
+        const cardSkills = _optionalChain([agentCard, 'optionalAccess', _18 => _18.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 (e3) {
+      return new Response(
+        JSON.stringify(createError(null, -32700, "Parse error")),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+    }
+    if (_optionalChain([sseHandlers, 'optionalAccess', _19 => _19.sendTaskSubscribe])) {
+      const requestObject2 = asRecord(parsed);
+      if (_optionalChain([requestObject2, 'optionalAccess', _20 => _20.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: _nullishCoalesce(taskId, () => ( void 0)),
+          metadata: _nullishCoalesce(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 ? _nullishCoalesce(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-push.ts
+var A2APushNotifier = (_class3 = class _A2APushNotifier {
+  __init5() {this.subscriptions = /* @__PURE__ */ new Map()}
+  
+  constructor(fetchImpl = globalThis.fetch) {;_class3.prototype.__init5.call(this);
+    if (!fetchImpl) {
+      throw new Error("A2APushNotifier requires a fetch implementation");
+    }
+    this.fetchImpl = fetchImpl;
+  }
+  static __initStatic() {this.BLOCKED_HEADERS = /* @__PURE__ */ new Set(["host", "authorization", "cookie", "content-type"])}
+  static __initStatic2() {this.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 = _nullishCoalesce(this.subscriptions.get(taskId), () => ( []));
+    existing.push(config);
+    this.subscriptions.set(taskId, existing);
+  }
+  unsubscribe(taskId, url) {
+    const existing = _nullishCoalesce(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 = _nullishCoalesce(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);
+  }
+}, _class3.__initStatic(), _class3.__initStatic2(), _class3);
+
+// 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 = (_class4 = class {
+  __init6() {this.entries = /* @__PURE__ */ new Map()}
+  
+  
+  
+  constructor(config = {}) {;_class4.prototype.__init6.call(this);
+    const retry = {
+      ...DEFAULT_RETRY_CONFIG,
+      ..._nullishCoalesce(config.retry, () => ( {}))
+    };
+    this.config = {
+      leaseDurationMs: _nullishCoalesce(config.leaseDurationMs, () => ( DEFAULT_QUEUE_CONFIG.leaseDurationMs)),
+      retentionMs: _nullishCoalesce(config.retentionMs, () => ( DEFAULT_QUEUE_CONFIG.retentionMs)),
+      maxTerminalTasks: _nullishCoalesce(config.maxTerminalTasks, () => ( DEFAULT_QUEUE_CONFIG.maxTerminalTasks)),
+      retry,
+      now: config.now,
+      idFactory: config.idFactory
+    };
+    this.now = _nullishCoalesce(config.now, () => ( (() => Date.now())));
+    this.idFactory = _nullishCoalesce(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, _nullishCoalesce(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, _nullishCoalesce(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 = _nullishCoalesce(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);
+  }
+}, _class4);
+
+// 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 = _zod.z.object({
+  endpoint: _zod.z.string().url(),
+  method: _zod.z.enum(["tasks/send", "tasks/get", "tasks/list", "tasks/cancel", "agent/card", "health"]).default("tasks/send"),
+  prompt: _zod.z.string().optional(),
+  taskId: _zod.z.string().optional(),
+  params: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+});
+var A2A_DELEGATE_SCHEMA = _zod.z.object({
+  prompt: _zod.z.string(),
+  requiredSkills: _zod.z.array(_zod.z.string()).default([])
+});
+var A2A_DISCOVER_SCHEMA = _zod.z.object({
+  endpoint: _zod.z.string().url()
+});
+var A2A_SUBSCRIBE_SCHEMA = _zod.z.object({
+  endpoint: _zod.z.string().url(),
+  prompt: _zod.z.string(),
+  taskId: _zod.z.string().optional()
+});
+var A2APlugin = (_class5 = class _A2APlugin {
+  __init7() {this.name = "a2a"}
+  __init8() {this.version = "1.0.0"}
+  
+  
+  
+  
+  
+  
+  
+  
+  __init9() {this.taskEventListeners = /* @__PURE__ */ new Set()}
+  static __initStatic3() {this.QUEUE_SNAPSHOT_KEY = "a2a:durable-task-queue:v1"}
+  static __initStatic4() {this.DEFAULT_MAX_TERMINAL_TASKS = 1e3}
+  static __initStatic5() {this.DEFAULT_RETENTION_MS = 36e5}
+  // 1 hour
+  
+  __init10() {this.queueHydrated = false}
+  __init11() {this.queueHydrationPromise = null}
+  
+  
+  __init12() {this.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 = {}) {;_class5.prototype.__init7.call(this);_class5.prototype.__init8.call(this);_class5.prototype.__init9.call(this);_class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this);
+    const fetchImpl = _nullishCoalesce(options.fetch, () => ( globalThis.fetch));
+    if (!fetchImpl) {
+      throw new Error("A2APlugin requires a fetch implementation");
+    }
+    this.fetchImpl = fetchImpl;
+    this.requestTimeoutMs = _nullishCoalesce(options.requestTimeoutMs, () => ( DEFAULT_REQUEST_TIMEOUT_MS));
+    this.agentCardProvider = options.agentCardProvider;
+    this.persistQueueStateEnabled = _nullishCoalesce(options.persistQueueState, () => ( true));
+    this.delegationManager = new (0, _chunkDAMT2CXWcjs.A2ADelegationManager)(fetchImpl);
+    this.pushNotifier = new A2APushNotifier(fetchImpl);
+    const normalizedRetry = options.retry ? {
+      maxAttempts: _nullishCoalesce(options.retry.maxAttempts, () => ( DEFAULT_RETRY_CONFIG2.maxAttempts)),
+      initialBackoffMs: _nullishCoalesce(options.retry.initialBackoffMs, () => ( DEFAULT_RETRY_CONFIG2.initialBackoffMs)),
+      backoffMultiplier: _nullishCoalesce(options.retry.backoffMultiplier, () => ( DEFAULT_RETRY_CONFIG2.backoffMultiplier)),
+      maxBackoffMs: _nullishCoalesce(options.retry.maxBackoffMs, () => ( DEFAULT_RETRY_CONFIG2.maxBackoffMs)),
+      jitterRatio: _nullishCoalesce(options.retry.jitterRatio, () => ( DEFAULT_RETRY_CONFIG2.jitterRatio))
+    } : void 0;
+    this.taskQueue = _nullishCoalesce(options.taskQueue, () => ( new A2ADurableTaskQueue({
+      leaseDurationMs: _optionalChain([options, 'access', _21 => _21.queue, 'optionalAccess', _22 => _22.leaseDurationMs]),
+      retentionMs: _nullishCoalesce(_optionalChain([options, 'access', _23 => _23.queue, 'optionalAccess', _24 => _24.retentionMs]), () => ( _A2APlugin.DEFAULT_RETENTION_MS)),
+      maxTerminalTasks: _nullishCoalesce(_optionalChain([options, 'access', _25 => _25.queue, 'optionalAccess', _26 => _26.maxTerminalTasks]), () => ( _A2APlugin.DEFAULT_MAX_TERMINAL_TASKS)),
+      retry: normalizedRetry
+    })));
+    this.evictionTimer = setInterval(() => this.evictStaleTasks(), 6e4);
+    this.tools = {
+      "a2a:call": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Call an external A2A-compatible JSON-RPC endpoint.",
+        inputSchema: A2A_CALL_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_CALL_SCHEMA.parse(_nullishCoalesce(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": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        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(_nullishCoalesce(input, () => ( {})));
+          return await this.delegationManager.delegate(args.prompt, args.requiredSkills, this.fetchImpl);
+        }
+      }),
+      "a2a:discover": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Discover agent capabilities at an A2A endpoint.",
+        inputSchema: A2A_DISCOVER_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_DISCOVER_SCHEMA.parse(_nullishCoalesce(input, () => ( {})));
+          return await this.discoverAgent(args.endpoint);
+        }
+      }),
+      "a2a:subscribe": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Subscribe to task status updates via Server-Sent Events.",
+        inputSchema: A2A_SUBSCRIBE_SCHEMA,
+        execute: async (input) => {
+          const args = A2A_SUBSCRIBE_SCHEMA.parse(_nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 (_optionalChain([before, 'optionalAccess', _27 => _27.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 = {
+        ..._nullishCoalesce(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 = _nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _28 => _28.latestCtx, 'optionalAccess', _29 => _29.sessionId]), () => ( _optionalChain([this, 'access', _30 => _30.setupCtx, 'optionalAccess', _31 => _31.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: _nullishCoalesce(_optionalChain([discoveryData, 'access', _32 => _32.skills, 'optionalAccess', _33 => _33.map, 'call', _34 => _34((s) => s.name)]), () => ( [])),
+            endpoint
+          };
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (e4) {
+    }
+    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: _nullishCoalesce(_optionalChain([card, 'optionalAccess', _35 => _35.name]), () => ( "Unknown Agent")),
+      description: _nullishCoalesce(_optionalChain([card, 'optionalAccess', _36 => _36.instructions]), () => ( "No description")),
+      skills: _nullishCoalesce(_optionalChain([card, 'optionalAccess', _37 => _37.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 = _optionalChain([response, 'access', _38 => _38.body, 'optionalAccess', _39 => _39.getReader, 'call', _40 => _40()]);
+      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 = _nullishCoalesce(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 (e5) {
+              }
+            }
+          }
+          if (sseCompleted) {
+            break;
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      return {
+        message: "Task subscription completed",
+        events
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  getTaskIdFromContext(ctx) {
+    const raw = _optionalChain([ctx, 'access', _41 => _41.runMetadata, 'optionalAccess', _42 => _42.a2aTaskId]);
+    return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+  }
+  getLeaseIdFromContext(ctx) {
+    const raw = _optionalChain([ctx, 'access', _43 => _43.runMetadata, 'optionalAccess', _44 => _44.a2aLeaseId]);
+    return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+  }
+  isQueueManagedRun(ctx) {
+    return _optionalChain([ctx, 'access', _45 => _45.runMetadata, 'optionalAccess', _46 => _46.a2aManagedByQueue]) === true;
+  }
+  async resolveAgentCard() {
+    if (this.agentCardProvider) {
+      return this.agentCardProvider.getAgentCard();
+    }
+    const ctx = _nullishCoalesce(this.latestCtx, () => ( this.setupCtx));
+    if (!ctx) {
+      return {
+        name: "Agent",
+        instructions: "",
+        tools: []
+      };
+    }
+    return {
+      name: _nullishCoalesce(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;
+  }
+}, _class5.__initStatic3(), _class5.__initStatic4(), _class5.__initStatic5(), _class5);
+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 _nullishCoalesce(options.validator, () => ( new ZodValidationAdapter()));
+}
+
+// src/plugins/guardrails.plugin.ts
+var GuardrailsError = class extends Error {
+  
+  constructor(code, message) {
+    super(message);
+    this.name = "GuardrailsError";
+    this.code = code;
+  }
+};
+var GuardrailsPlugin = (_class6 = class extends BasePlugin {
+  __init13() {this.name = "guardrails"}
+  
+  
+  constructor(options = {}) {
+    super();_class6.prototype.__init13.call(this);;
+    this.validator = getValidator(options);
+    this.options = {
+      onFailure: _nullishCoalesce(options.onFailure, () => ( "throw")),
+      contentFilters: _nullishCoalesce(options.contentFilters, () => ( [])),
+      inputValidators: _nullishCoalesce(options.inputValidators, () => ( [])),
+      outputValidators: _nullishCoalesce(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 = _optionalChain([this, 'access', _47 => _47.options, 'access', _48 => _48.toolSchemas, 'optionalAccess', _49 => _49[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);
+  }
+}, _class6);
+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
+
+var DEFAULT_REQUEST_TIMEOUT_MS2 = 3e4;
+var OneCrawlPlugin = (_class7 = class extends BasePlugin {
+  __init14() {this.name = "crawl"}
+  
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  __init15() {this.crawlerPromise = null}
+  
+  constructor(options = {}) {
+    super();_class7.prototype.__init14.call(this);_class7.prototype.__init15.call(this);;
+    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 Promise.resolve().then(() => _interopRequireWildcard(require("onecrawl")));
+      const CrawlerClass = _nullishCoalesce(_nullishCoalesce(mod.Crawler, () => ( _optionalChain([mod, 'access', _50 => _50.default, 'optionalAccess', _51 => _51.Crawler]))), () => ( mod.default));
+      return new CrawlerClass({
+        timeout: _nullishCoalesce(this.options.timeout, () => ( DEFAULT_REQUEST_TIMEOUT_MS2))
+      });
+    } catch (e6) {
+      throw new Error(
+        'OneCrawlPlugin requires "onecrawl" package. Install it: pnpm add onecrawl'
+      );
+    }
+  }
+  get tools() {
+    const maxLen = _nullishCoalesce(this.options.maxContentLength, () => ( 1e4));
+    const getCrawler = this.getCrawler.bind(this);
+    const validator = this.validator;
+    return {
+      scrape: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Scrape a web page and extract its text content",
+        inputSchema: _zod.z.object({
+          url: _zod.z.string().url().describe("The URL to scrape")
+        }),
+        execute: async (args) => {
+          const { url } = validator.validateOrThrow(
+            _zod.z.object({ url: _zod.z.string().url() }),
+            args
+          );
+          const crawler = await getCrawler();
+          const result = await crawler.crawl(url);
+          const content = typeof result === "string" ? result : _nullishCoalesce(_nullishCoalesce(_optionalChain([result, 'optionalAccess', _52 => _52.content]), () => ( _optionalChain([result, 'optionalAccess', _53 => _53.text]))), () => ( JSON.stringify(result)));
+          return content.length > maxLen ? content.slice(0, maxLen) + "\n...[truncated]" : content;
+        }
+      }),
+      search: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Search the web and return results",
+        inputSchema: _zod.z.object({
+          query: _zod.z.string().describe("The search query"),
+          limit: _zod.z.number().min(1).max(20).default(5).describe("Max results to return")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            _zod.z.object({
+              query: _zod.z.string(),
+              limit: _zod.z.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: _nullishCoalesce(r.title, () => ( "")),
+              url: _nullishCoalesce(_nullishCoalesce(r.url, () => ( r.link)), () => ( "")),
+              snippet: _nullishCoalesce(_nullishCoalesce(r.snippet, () => ( r.description)), () => ( ""))
+            }));
+          }
+          return results;
+        }
+      }),
+      batch: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Scrape multiple web pages in parallel",
+        inputSchema: _zod.z.object({
+          urls: _zod.z.array(_zod.z.string().url()).min(1).max(10).describe("URLs to scrape")
+        }),
+        execute: async (args) => {
+          const { urls } = validator.validateOrThrow(
+            _zod.z.object({ urls: _zod.z.array(_zod.z.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 : _nullishCoalesce(_nullishCoalesce(_optionalChain([r, 'optionalAccess', _54 => _54.content]), () => ( _optionalChain([r, 'optionalAccess', _55 => _55.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 : _nullishCoalesce(_nullishCoalesce(_optionalChain([r, 'optionalAccess', _56 => _56.content]), () => ( _optionalChain([r, 'optionalAccess', _57 => _57.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 (e7) {
+      }
+      this.crawlerPromise = null;
+    }
+  }
+}, _class7);
+function createOneCrawlPlugin(options = {}) {
+  return new OneCrawlPlugin(options);
+}
+
+// src/plugins/vectorless.plugin.ts
+
+
+// src/adapters/chunking/default-chunking.adapter.ts
+var _crypto = require('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: _crypto.randomUUID.call(void 0, ),
+    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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _58 => _58.strategy]), () => ( "fixed"));
+    const maxTokens = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _59 => _59.maxTokens]), () => ( DEFAULT_MAX_TOKENS));
+    const overlap = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _60 => _60.overlap]), () => ( DEFAULT_OVERLAP));
+    const separators = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _61 => _61.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, (_nullishCoalesce(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 = (_nullishCoalesce(freqMap.get(term), () => ( 0))) / (tokens.length || 1);
+      score += tf * (_nullishCoalesce(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 = _nullishCoalesce(freqMap.get(term), () => ( 0));
+      const idfVal = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.strategy]), () => ( "bm25"));
+    switch (strategy) {
+      case "tfidf":
+        return computeTfIdf(query, results);
+      case "bm25":
+        return computeBm25(query, results);
+      case "mmr":
+        return computeMmr(query, results, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _63 => _63.lambda]), () => ( 0.7)));
+      default:
+        return computeBm25(query, results);
+    }
+  }
+};
+
+// src/plugins/vectorless.plugin.ts
+var DEFAULT_MAX_TOKENS_PER_CHUNK = 512;
+var VectorlessPlugin = (_class8 = class extends BasePlugin {
+  __init16() {this.name = "knowledge"}
+  
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  __init17() {this.vectorlessPromise = null}
+  __init18() {this.currentKnowledge = null}
+  
+  __init19() {this.chunks = /* @__PURE__ */ new Map()}
+  
+  
+  
+  constructor(options = {}) {
+    super();_class8.prototype.__init16.call(this);_class8.prototype.__init17.call(this);_class8.prototype.__init18.call(this);_class8.prototype.__init19.call(this);;
+    this.options = options;
+    this.currentKnowledge = _nullishCoalesce(options.knowledgeBase, () => ( null));
+    this.validator = getValidator(options);
+    this.chunkingAdapter = _nullishCoalesce(options.chunkingAdapter, () => ( new DefaultChunkingAdapter()));
+    this.rerankingAdapter = _nullishCoalesce(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 Promise.resolve().then(() => _interopRequireWildcard(require("@giulio-leone/gaussflow-vectorless")));
+      return _nullishCoalesce(mod.default, () => ( mod));
+    } catch (e8) {
+      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 = _nullishCoalesce(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: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Extract knowledge (entities, relations, quotes) from text. Must be called before query/search.",
+        inputSchema: _zod.z.object({
+          text: _zod.z.string().describe("The text to extract knowledge from"),
+          topic: _zod.z.string().optional().describe("Optional topic to focus extraction on")
+        }),
+        execute: async (args) => {
+          const { text, topic } = validator.validateOrThrow(
+            _zod.z.object({
+              text: _zod.z.string(),
+              topic: _zod.z.string().optional()
+            }),
+            args
+          );
+          const vl = await getVectorless();
+          const generate = _nullishCoalesce(_nullishCoalesce(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(_optionalChain([knowledge, 'optionalAccess', _64 => _64.entities])) ? knowledge.entities.length : 0,
+            relations: Array.isArray(_optionalChain([knowledge, 'optionalAccess', _65 => _65.relations])) ? knowledge.relations.length : 0,
+            quotes: Array.isArray(_optionalChain([knowledge, 'optionalAccess', _66 => _66.quotes])) ? knowledge.quotes.length : 0
+          };
+          return `Knowledge extracted: ${summary.entities} entities, ${summary.relations} relations, ${summary.quotes} quotes`;
+        }
+      }),
+      query: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Answer a question using the extracted knowledge base",
+        inputSchema: _zod.z.object({
+          question: _zod.z.string().describe("The question to answer")
+        }),
+        execute: async (args) => {
+          const { question } = validator.validateOrThrow(
+            _zod.z.object({ question: _zod.z.string() }),
+            args
+          );
+          const knowledge = getKnowledge();
+          if (!knowledge) return "No knowledge base loaded. Use knowledge:generate first.";
+          const vl = await getVectorless();
+          const query = _nullishCoalesce(_nullishCoalesce(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": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Search for entities in the extracted knowledge base",
+        inputSchema: _zod.z.object({
+          query: _zod.z.string().describe("Search query for entities"),
+          limit: _zod.z.number().min(1).max(50).default(10).describe("Max results")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            _zod.z.object({
+              query: _zod.z.string(),
+              limit: _zod.z.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(_optionalChain([kb, 'optionalAccess', _67 => _67.entities])) ? kb.entities : [];
+          const lower = query.toLowerCase();
+          return entities.filter((e) => (_nullishCoalesce(_nullishCoalesce(e.name, () => ( e.label)), () => ( ""))).toLowerCase().includes(lower)).slice(0, limit);
+        }
+      }),
+      list: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "List all entities in the current knowledge base",
+        inputSchema: _zod.z.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: _nullishCoalesce(_nullishCoalesce(e.name, () => ( e.label)), () => ( "unknown")),
+            type: _nullishCoalesce(_nullishCoalesce(e.type, () => ( e.category)), () => ( "unknown"))
+          }));
+        }
+      }),
+      // ─── Advanced RAG tools ──────────────────────────────────────────
+      "rag:ingest": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Chunk a document and extract knowledge from each chunk",
+        inputSchema: _zod.z.object({
+          text: _zod.z.string().describe("The document text to ingest"),
+          source: _zod.z.string().optional().describe("Source identifier for attribution"),
+          chunkingStrategy: _zod.z.enum(["fixed", "sliding-window", "semantic", "recursive"]).default("recursive").describe("Chunking strategy"),
+          maxTokens: _zod.z.number().min(1).default(DEFAULT_MAX_TOKENS_PER_CHUNK).describe("Max tokens per chunk"),
+          overlap: _zod.z.number().min(0).default(50).describe("Token overlap for sliding-window")
+        }),
+        execute: async (args) => {
+          const { text, source, chunkingStrategy, maxTokens, overlap } = validator.validateOrThrow(
+            _zod.z.object({
+              text: _zod.z.string(),
+              source: _zod.z.string().optional(),
+              chunkingStrategy: _zod.z.enum(["fixed", "sliding-window", "semantic", "recursive"]).default("recursive"),
+              maxTokens: _zod.z.number().min(1).default(DEFAULT_MAX_TOKENS_PER_CHUNK),
+              overlap: _zod.z.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 = _nullishCoalesce(_nullishCoalesce(vl.generateKnowledge, () => ( vl.generate)), () => ( vl.extract));
+            if (generate) {
+              const knowledge = await generate(text, { topic: source });
+              mergeKnowledge(knowledge);
+            }
+          } catch (e9) {
+          }
+          return `Ingested ${produced.length} chunks (strategy: ${chunkingStrategy}, maxTokens: ${maxTokens})${source ? ` from "${source}"` : ""}`;
+        }
+      }),
+      "rag:search": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Hybrid search: combine entity search + keyword search, then re-rank results",
+        inputSchema: _zod.z.object({
+          query: _zod.z.string().describe("Search query"),
+          limit: _zod.z.number().min(1).max(100).default(10).describe("Max results"),
+          rerankerStrategy: _zod.z.enum(["tfidf", "bm25", "mmr"]).default("bm25").describe("Re-ranking strategy"),
+          includeAttribution: _zod.z.boolean().default(true).describe("Include source attribution")
+        }),
+        execute: async (args) => {
+          const { query, limit, rerankerStrategy, includeAttribution } = validator.validateOrThrow(
+            _zod.z.object({
+              query: _zod.z.string(),
+              limit: _zod.z.number().min(1).max(100).default(10),
+              rerankerStrategy: _zod.z.enum(["tfidf", "bm25", "mmr"]).default("bm25"),
+              includeAttribution: _zod.z.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(_optionalChain([kb, 'optionalAccess', _68 => _68.entities])) ? kb.entities : [];
+            for (const e of entities) {
+              const name = (_nullishCoalesce(_nullishCoalesce(e.name, () => ( e.label)), () => ( ""))).toLowerCase();
+              if (name.includes(queryLower) || queryLower.includes(name)) {
+                candidates.push({
+                  id: `entity:${_nullishCoalesce(e.name, () => ( e.label))}`,
+                  text: `${_nullishCoalesce(e.name, () => ( e.label))} (${_nullishCoalesce(_nullishCoalesce(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": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Search directly against stored chunks",
+        inputSchema: _zod.z.object({
+          query: _zod.z.string().describe("Search query"),
+          limit: _zod.z.number().min(1).max(100).default(10).describe("Max results")
+        }),
+        execute: async (args) => {
+          const { query, limit } = validator.validateOrThrow(
+            _zod.z.object({
+              query: _zod.z.string(),
+              limit: _zod.z.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;
+  }
+}, _class8);
+function createVectorlessPlugin(options = {}) {
+  return new VectorlessPlugin(options);
+}
+
+// src/plugins/evals.plugin.ts
+var EvalsPlugin = (_class9 = class extends BasePlugin {
+  __init20() {this.name = "evals"}
+  
+  __init21() {this.results = []}
+  __init22() {this.runStates = /* @__PURE__ */ new Map()}
+  constructor(options = {}) {
+    super();_class9.prototype.__init20.call(this);_class9.prototype.__init21.call(this);_class9.prototype.__init22.call(this);;
+    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 = _nullishCoalesce(_optionalChain([state, 'optionalAccess', _69 => _69.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 = _optionalChain([step, 'optionalAccess', _70 => _70.usage]);
+      if (usage) {
+        promptTokens += _nullishCoalesce(usage.promptTokens, () => ( 0));
+        completionTokens += _nullishCoalesce(usage.completionTokens, () => ( 0));
+      }
+    }
+    const metrics = {
+      latencyMs,
+      stepCount: steps.length,
+      toolCalls,
+      tokenUsage: {
+        prompt: promptTokens,
+        completion: completionTokens,
+        total: promptTokens + completionTokens
+      },
+      customScores: {}
+    };
+    for (const scorer of _nullishCoalesce(this.options.scorers, () => ( []))) {
+      try {
+        metrics.customScores[scorer.name] = await scorer.score(
+          prompt,
+          params.result.text,
+          metrics
+        );
+      } catch (e10) {
+        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] = (_nullishCoalesce(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;
+  }
+}, _class9);
+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 {
+  
+  
+  constructor(options = {}) {
+    this.agentExecutor = options.agentExecutor;
+    this.onEvent = options.onEvent;
+  }
+  async execute(definition, context) {
+    const start = Date.now();
+    let ctx = structuredClone(_nullishCoalesce(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 _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(step.itemKey, () => ( "item"));
+    const indexKey = _nullishCoalesce(step.indexKey, () => ( "index"));
+    const outputs = await this.executeItemsWithConcurrency(
+      items,
+      _nullishCoalesce(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 = _nullishCoalesce(step.aggregateOutputKey, () => ( step.id));
+    return {
+      ...ctx,
+      [aggregateKey]: this.aggregateOutputs(outputs, _nullishCoalesce(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 = _nullishCoalesce(step.itemKey, () => ( "item"));
+    const indexKey = _nullishCoalesce(step.indexKey, () => ( "index"));
+    const transformed = await this.executeItemsWithConcurrency(
+      filtered,
+      _nullishCoalesce(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 (_optionalChain([step, 'optionalAccess', _71 => _71.rollback])) {
+        try {
+          await step.rollback(ctx);
+        } catch (e11) {
+        }
+      }
+    }
+  }
+  // ── Helpers ─────────────────────────────────────────────────────────────
+  emit(event) {
+    _optionalChain([this, 'access', _72 => _72.onEvent, 'optionalCall', _73 => _73(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 {
+  
+  constructor(message, result) {
+    super(message);
+    this.name = "WorkflowError";
+    this.result = result;
+  }
+};
+function isWorkflowDefinition(input) {
+  return "id" in input && "name" in input;
+}
+var WorkflowPlugin = (_class10 = class extends BasePlugin {
+  __init23() {this.name = "workflow"}
+  
+  
+  
+  
+  
+  constructor(config, engine) {
+    super();_class10.prototype.__init23.call(this);;
+    if (isWorkflowDefinition(config)) {
+      this.definition = config;
+      this.steps = config.steps;
+      this.initialContext = _nullishCoalesce(config.initialContext, () => ( {}));
+      this.engine = _nullishCoalesce(engine, () => ( new DefaultWorkflowEngine()));
+    } else {
+      this.steps = config.steps;
+      this.initialContext = _nullishCoalesce(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 (_optionalChain([step, 'optionalAccess', _74 => _74.rollback])) {
+        try {
+          await step.rollback(context);
+        } catch (e12) {
+        }
+      }
+    }
+  }
+}, _class10);
+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 = (_class11 = class extends BasePlugin {
+  __init24() {this.name = "observability"}
+  __init25() {this.version = "1.0.0"}
+  
+  __init26() {this.spans = /* @__PURE__ */ new Map()}
+  __init27() {this.rootSpans = []}
+  __init28() {this.activeSpans = /* @__PURE__ */ new Map()}
+  // sessionId → current root span
+  __init29() {this.sessionMetrics = /* @__PURE__ */ new Map()}
+  // sessionId → metrics
+  __init30() {this.sessionStartTimes = /* @__PURE__ */ new Map()}
+  // sessionId → run start time
+  __init31() {this.toolStartTimes = /* @__PURE__ */ new Map()}
+  // sessionId:toolName → start time stack (LIFO)
+  __init32() {this.toolSpanStack = /* @__PURE__ */ new Map()}
+  // sessionId:toolName → spanId stack (LIFO)
+  
+  constructor(config = {}) {
+    super();_class11.prototype.__init24.call(this);_class11.prototype.__init25.call(this);_class11.prototype.__init26.call(this);_class11.prototype.__init27.call(this);_class11.prototype.__init28.call(this);_class11.prototype.__init29.call(this);_class11.prototype.__init30.call(this);_class11.prototype.__init31.call(this);_class11.prototype.__init32.call(this);;
+    this.config = {
+      enableTracing: true,
+      enableMetrics: true,
+      enableCostEstimation: false,
+      ...config
+    };
+    this.maxSpans = _nullishCoalesce(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 = _optionalChain([params, 'access', _75 => _75.result, 'access', _76 => _76.steps, 'optionalAccess', _77 => _77.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 = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([rootSpan, 'optionalAccess', _78 => _78.traceId]), () => ( this.generateId()));
+      const toolSpan = this.createSpan(`tool.${params.toolName}`, traceId, _optionalChain([rootSpan, 'optionalAccess', _79 => _79.id]));
+      toolSpan.attributes = {
+        toolName: params.toolName,
+        args: params.args
+      };
+      const stackKey = `${ctx.sessionId}:${params.toolName}`;
+      const stack = _nullishCoalesce(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 = _optionalChain([stack, 'optionalAccess', _80 => _80.pop, 'call', _81 => _81()]);
+      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 = _optionalChain([stack, 'optionalAccess', _82 => _82.pop, 'call', _83 => _83()]);
+      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 === _optionalChain([rootSpan, 'optionalAccess', _84 => _84.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();
+  }
+}, _class11);
+function createObservabilityPlugin(config) {
+  return new ObservabilityPlugin(config);
+}
+
+// src/plugins/semantic-scraping.plugin.ts
+
+var SemanticToolSchema = _zod.z.object({
+  name: _zod.z.string(),
+  description: _zod.z.string(),
+  inputSchema: _zod.z.union([_zod.z.string(), _zod.z.record(_zod.z.string(), _zod.z.unknown())]),
+  confidence: _zod.z.number().optional(),
+  category: _zod.z.string().optional(),
+  annotations: _zod.z.record(_zod.z.string(), _zod.z.boolean()).optional()
+});
+var ScanPageInputSchema = _zod.z.object({
+  url: _zod.z.string().url().describe("The page URL that was scanned"),
+  tools: _zod.z.array(SemanticToolSchema).describe("Semantic tools extracted from the page HTML")
+});
+var GetManifestInputSchema = _zod.z.object({
+  origin: _zod.z.string().describe("Site origin (e.g., https://example.com)")
+});
+var GetToolsForUrlInputSchema = _zod.z.object({
+  origin: _zod.z.string().describe("Site origin (e.g., https://example.com)"),
+  url: _zod.z.string().url().describe("The URL to get tools for")
+});
+var SemanticScrapingPlugin = (_class12 = class extends BasePlugin {
+  __init33() {this.name = "semantic-scraping"}
+  
+  constructor(options = {}) {
+    super();_class12.prototype.__init33.call(this);;
+    this.adapter = _nullishCoalesce(options.adapter, () => ( new (0, _chunkQYOMQBBZcjs.SemanticScrapingAdapter)()));
+  }
+  buildHooks() {
+    return {};
+  }
+  get tools() {
+    const adapter = this.adapter;
+    return {
+      semantic_scan_page: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        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: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        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: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Get the semantic tools available at a specific URL",
+        inputSchema: GetToolsForUrlInputSchema,
+        execute: async (args) => {
+          const { origin, url } = args;
+          return adapter.getToolsForUrl(origin, url);
+        }
+      })
+    };
+  }
+}, _class12);
+function createSemanticScrapingPlugin(options = {}) {
+  return new SemanticScrapingPlugin(options);
+}
+
+// src/plugins/semantic-web-search.plugin.ts
+
+var strategySchema = _zod.z.enum(["tfidf", "bm25", "mmr"]);
+var SemanticWebSearchPlugin = (_class13 = class extends BasePlugin {
+  constructor(options = {}) {
+    super();_class13.prototype.__init34.call(this);_class13.prototype.__init35.call(this);_class13.prototype.__init36.call(this);;
+    this.options = options;
+    this.reranker = _nullishCoalesce(options.reranker, () => ( new DefaultReRankingAdapter()));
+    this.telemetry = options.telemetry;
+    this.costTracker = options.costTracker;
+    this.costModel = _nullishCoalesce(options.costModel, () => ( "gpt-5.2-mini"));
+    this.emitTelemetry = _nullishCoalesce(options.emitTelemetry, () => ( true));
+    this.cache = _nullishCoalesce(options.cache, () => ( new (0, _chunk6XF673YCcjs.ToolCache)()));
+    this.circuitBreaker = _nullishCoalesce(options.circuitBreaker, () => ( new (0, _chunk6XF673YCcjs.CircuitBreaker)()));
+    this.defaultLimit = _nullishCoalesce(options.defaultLimit, () => ( 5));
+    this.defaultScrapeTopK = _nullishCoalesce(options.defaultScrapeTopK, () => ( 2));
+    this.defaultStrategy = _nullishCoalesce(options.defaultStrategy, () => ( "bm25"));
+    this.fallbackStrategy = _nullishCoalesce(options.fallbackStrategy, () => ( "tfidf"));
+    this.fallbackOnRerankError = _nullishCoalesce(options.fallbackOnRerankError, () => ( true));
+    this.requestTimeoutMs = _nullishCoalesce(options.requestTimeoutMs, () => ( 1e4));
+    this.maxRetries = _nullishCoalesce(options.maxRetries, () => ( 2));
+    this.retryDelayMs = _nullishCoalesce(options.retryDelayMs, () => ( 200));
+    this.cacheTtlMs = _nullishCoalesce(options.cacheTtlMs, () => ( 6e4));
+  }
+  __init34() {this.name = "Semantic Web Search"}
+  __init35() {this.description = "Native search\u2192rerank\u2192citation pipeline for high-quality web evidence."}
+  __init36() {this.crawlerPromise = null}
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  
+  buildHooks() {
+    return {};
+  }
+  get tools() {
+    return {
+      semantic_web_search: _chunkPSJIAGDEcjs.tool.call(void 0, {
+        description: "Search the web, rerank semantically and return ranked citations.",
+        inputSchema: _zod.z.object({
+          query: _zod.z.string().min(1),
+          limit: _zod.z.number().int().min(1).max(20).optional(),
+          scrapeTopK: _zod.z.number().int().min(0).max(10).optional(),
+          strategy: strategySchema.optional()
+        }),
+        execute: async (input) => {
+          const limit = _nullishCoalesce(input.limit, () => ( this.defaultLimit));
+          const scrapeTopK = _nullishCoalesce(input.scrapeTopK, () => ( this.defaultScrapeTopK));
+          const strategy = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _85 => _85.title]), () => ( result.id));
+              const url = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _86 => _86.url]), () => ( ""));
+              const snippet = _nullishCoalesce(_optionalChain([source, 'optionalAccess', _87 => _87.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 _optionalChain([crawler, 'optionalAccess', _88 => _88.close, 'optionalCall', _89 => _89()]);
+  }
+  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 Promise.resolve().then(() => _interopRequireWildcard(require("onecrawl")));
+      const CrawlerClass = _nullishCoalesce(_nullishCoalesce(mod.Crawler, () => ( _optionalChain([mod, 'access', _90 => _90.default, 'optionalAccess', _91 => _91.Crawler]))), () => ( mod.default));
+      return new CrawlerClass({
+        ...this.options.apiKey ? { apiKey: this.options.apiKey } : {}
+      });
+    } catch (e13) {
+      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 = _nullishCoalesce(item.url, () => ( item.link));
+    if (!url) {
+      return null;
+    }
+    const title = _nullishCoalesce(item.title, () => ( `Result ${index + 1}`));
+    const snippet = _nullishCoalesce(_nullishCoalesce(item.snippet, () => ( item.description)), () => ( ""));
+    const content = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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 (e14) {
+          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 _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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 (e15) {
+    }
+  }
+  emitMetric(name, value, tags) {
+    if (!this.emitTelemetry || !this.telemetry) {
+      return;
+    }
+    try {
+      this.telemetry.recordMetric(name, value, tags);
+    } catch (e16) {
+    }
+  }
+  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 (e17) {
+      return String(value);
+    }
+  }
+}, _class13);
+function createSemanticWebSearchPlugin(options = {}) {
+  return new SemanticWebSearchPlugin(options);
+}
+
+// src/plugins/mcp-server.plugin.ts
+
+
+// src/adapters/mcp-server/default-mcp-server.adapter.ts
+var _http = require('http');
+
+var DefaultMcpServerAdapter = (_class14 = class _DefaultMcpServerAdapter {
+  __init37() {this.tools = []}
+  __init38() {this.toolsByName = /* @__PURE__ */ new Map()}
+  
+  
+  // stdio
+  
+  __init39() {this.stdinBuffer = ""}
+  // sse
+  
+  __init40() {this.sseClients = /* @__PURE__ */ new Map()}
+  constructor(tools, executor) {;_class14.prototype.__init37.call(this);_class14.prototype.__init38.call(this);_class14.prototype.__init39.call(this);_class14.prototype.__init40.call(this);
+    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(_nullishCoalesce(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: _nullishCoalesce(_optionalChain([this, 'access', _92 => _92.options, 'optionalAccess', _93 => _93.name]), () => ( "gaussflow-mcp-server")),
+              version: _nullishCoalesce(_optionalChain([this, 'access', _94 => _94.options, 'optionalAccess', _95 => _95.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 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _96 => _96.name]), () => ( ""));
+        const toolArgs = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _97 => _97.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 (e18) {
+      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 = _http.createServer.call(void 0, (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(_nullishCoalesce(req.url, () => ( "/")), `http://${_nullishCoalesce(req.headers.host, () => ( "localhost"))}`);
+    if (url.pathname === "/sse" && req.method === "GET") {
+      const clientId = _crypto.randomUUID.call(void 0, );
+      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 (e19) {
+        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 __initStatic6() {this.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);
+    });
+  }
+}, _class14.__initStatic6(), _class14);
+
+// src/plugins/mcp-server.plugin.ts
+var START_SCHEMA = _zod.z.object({
+  transport: _zod.z.enum(["stdio", "sse"]).default("stdio"),
+  port: _zod.z.number().optional(),
+  toolFilter: _zod.z.array(_zod.z.string()).optional()
+});
+var STOP_SCHEMA = _zod.z.object({});
+var McpServerPlugin = (_class15 = class {
+  __init41() {this.name = "mcp-server"}
+  __init42() {this.version = "1.0.0"}
+  
+  
+  
+  __init43() {this.collectedTools = []}
+  constructor(options = {}) {;_class15.prototype.__init41.call(this);_class15.prototype.__init42.call(this);_class15.prototype.__init43.call(this);
+    this.pluginOptions = options;
+    this.tools = {
+      "mcp:start-server": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        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(_nullishCoalesce(input, () => ( {})));
+          if (this.adapter) {
+            await this.adapter.stop();
+          }
+          this.adapter = new DefaultMcpServerAdapter(
+            this.collectedTools,
+            _nullishCoalesce(this.pluginOptions.executor, () => ( this.defaultExecutor.bind(this)))
+          );
+          await this.adapter.start({
+            name: _nullishCoalesce(this.pluginOptions.name, () => ( "gaussflow-mcp-server")),
+            version: _nullishCoalesce(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" ? _nullishCoalesce(args.port, () => ( 3100)) : void 0,
+            toolCount: tools.length,
+            tools: tools.map((t) => t.name)
+          };
+        }
+      }),
+      "mcp:stop-server": _chunkPSJIAGDEcjs.tool.call(void 0, {
+        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)` }]
+    };
+  }
+}, _class15);
+function createMcpServerPlugin(options) {
+  return new McpServerPlugin(options);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BasePlugin = BasePlugin; exports.AgentCardPlugin = AgentCardPlugin; exports.createAgentCardPlugin = createAgentCardPlugin; exports.createA2AJsonRpcHandler = createA2AJsonRpcHandler; exports.createA2AHttpHandler = createA2AHttpHandler; exports.createA2ASseHandler = createA2ASseHandler; exports.A2APushNotifier = A2APushNotifier; exports.A2APlugin = A2APlugin; exports.createA2APlugin = createA2APlugin; exports.ZodValidationAdapter = ZodValidationAdapter; exports.GuardrailsError = GuardrailsError; exports.GuardrailsPlugin = GuardrailsPlugin; exports.createGuardrailsPlugin = createGuardrailsPlugin; exports.createPiiFilter = createPiiFilter; exports.OneCrawlPlugin = OneCrawlPlugin; exports.createOneCrawlPlugin = createOneCrawlPlugin; exports.DefaultChunkingAdapter = DefaultChunkingAdapter; exports.DefaultReRankingAdapter = DefaultReRankingAdapter; exports.VectorlessPlugin = VectorlessPlugin; exports.createVectorlessPlugin = createVectorlessPlugin; exports.EvalsPlugin = EvalsPlugin; exports.createEvalsPlugin = createEvalsPlugin; exports.DefaultWorkflowEngine = DefaultWorkflowEngine; exports.WorkflowError = WorkflowError; exports.WorkflowPlugin = WorkflowPlugin; exports.createWorkflowPlugin = createWorkflowPlugin; exports.ObservabilityPlugin = ObservabilityPlugin; exports.createObservabilityPlugin = createObservabilityPlugin; exports.SemanticScrapingPlugin = SemanticScrapingPlugin; exports.createSemanticScrapingPlugin = createSemanticScrapingPlugin; exports.SemanticWebSearchPlugin = SemanticWebSearchPlugin; exports.createSemanticWebSearchPlugin = createSemanticWebSearchPlugin; exports.DefaultMcpServerAdapter = DefaultMcpServerAdapter; exports.McpServerPlugin = McpServerPlugin; exports.createMcpServerPlugin = createMcpServerPlugin;
+//# sourceMappingURL=chunk-CJZ66SU3.cjs.map