oh-my-opencode-kikokikok 2.14.2 → 2.15.1

package/dist/index.js

@@ -2902,37 +2902,37 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema2) {
-    const types19 = getJSONTypes(schema2.type);
-    const hasNull = types19.includes("null");
+    const types18 = getJSONTypes(schema2.type);
+    const hasNull = types18.includes("null");
     if (hasNull) {
       if (schema2.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types19.length && schema2.nullable !== undefined) {
+      if (!types18.length && schema2.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema2.nullable === true)
-        types19.push("null");
+        types18.push("null");
     }
-    return types19;
+    return types18;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types19 = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types19.every(rules_1.isJSONType))
-      return types19;
-    throw new Error("type must be JSONType or JSONType[]: " + types19.join(","));
+    const types18 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types18.every(rules_1.isJSONType))
+      return types18;
+    throw new Error("type must be JSONType or JSONType[]: " + types18.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types19) {
+  function coerceAndCheckDataType(it, types18) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types19, opts.coerceTypes);
-    const checkTypes = types19.length > 0 && !(coerceTo.length === 0 && types19.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types19[0]));
+    const coerceTo = coerceToTypes(types18, opts.coerceTypes);
+    const checkTypes = types18.length > 0 && !(coerceTo.length === 0 && types18.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types18[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types19, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types18, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types19, coerceTo);
+          coerceData(it, types18, coerceTo);
         else
           reportTypeError(it);
       });
@@ -2941,15 +2941,15 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types19, coerceTypes) {
-    return coerceTypes ? types19.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+  function coerceToTypes(types18, coerceTypes) {
+    return coerceTypes ? types18.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
   }
-  function coerceData(it, types19, coerceTo) {
+  function coerceData(it, types18, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types19, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types18, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t of coerceTo) {
@@ -3025,19 +3025,19 @@ var require_dataType = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types19 = (0, util_1.toHash)(dataTypes);
-    if (types19.array && types19.object) {
+    const types18 = (0, util_1.toHash)(dataTypes);
+    if (types18.array && types18.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types19.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types19.null;
-      delete types19.array;
-      delete types19.object;
+      cond = types18.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types18.null;
+      delete types18.array;
+      delete types18.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types19.number)
-      delete types19.integer;
-    for (const t in types19)
+    if (types18.number)
+      delete types18.integer;
+    for (const t in types18)
       cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
     return cond;
   }
@@ -3825,9 +3825,9 @@ var require_validate = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types19 = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types19);
-    schemaKeywords(it, types19, !checkedTypes, errsCount);
+    const types18 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types18);
+    schemaKeywords(it, types18, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema: schema2, errSchemaPath, opts, self } = it;
@@ -3877,7 +3877,7 @@ var require_validate = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types19, typeErrors, errsCount) {
+  function schemaKeywords(it, types18, typeErrors, errsCount) {
     const { gen, schema: schema2, data, allErrors, opts, self } = it;
     const { RULES } = self;
     if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
@@ -3885,7 +3885,7 @@ var require_validate = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types19);
+      checkStrictTypes(it, types18);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -3897,7 +3897,7 @@ var require_validate = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types19.length === 1 && types19[0] === group.type && typeErrors) {
+        if (types18.length === 1 && types18[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -3921,27 +3921,27 @@ var require_validate = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types19) {
+  function checkStrictTypes(it, types18) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types19);
+    checkContextTypes(it, types18);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types19);
+      checkMultipleTypes(it, types18);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types19) {
-    if (!types19.length)
+  function checkContextTypes(it, types18) {
+    if (!types18.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types19;
+      it.dataTypes = types18;
       return;
     }
-    types19.forEach((t) => {
+    types18.forEach((t) => {
       if (!includesType(it.dataTypes, t)) {
         strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types19);
+    narrowSchemaTypes(it, types18);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -42134,6 +42134,203 @@ var knowledge_propose = tool({
     }
   }
 });
+
+// src/tools/knowledge/provider-tools.ts
+function createKnowledgeProviderTools(registry2) {
+  const knowledge_query2 = tool({
+    description: "Search and query the knowledge repository. " + "Find ADRs, policies, patterns, and specs by keywords, type, layer, or full-text search. " + "Returns summaries to conserve context - use knowledge_show for full details.",
+    args: {
+      query: tool.schema.string().optional().describe("Full-text search query across knowledge summaries"),
+      type: tool.schema.enum(["adr", "policy", "pattern", "spec"]).optional().describe("Filter by knowledge type"),
+      layer: tool.schema.enum(["company", "org", "project"]).optional().describe("Filter by organizational layer"),
+      severity: tool.schema.enum(["info", "warn", "block"]).optional().describe("Filter by severity level"),
+      tags: tool.schema.array(tool.schema.string()).optional().describe("Filter by tags"),
+      limit: tool.schema.number().optional().describe(`Maximum results to return (default: ${DEFAULT_QUERY_LIMIT})`)
+    },
+    execute: async (args) => {
+      try {
+        const types14 = args.type ? [args.type] : undefined;
+        const results = await registry2.search({
+          text: args.query ?? "",
+          types: types14,
+          layers: args.layer ? [args.layer] : undefined,
+          limit: args.limit ?? DEFAULT_QUERY_LIMIT,
+          includeContent: false
+        });
+        if (results.length === 0) {
+          return "No knowledge items found matching the query.";
+        }
+        const lines = [`Found ${results.length} knowledge items:`, ""];
+        for (const { item, score } of results) {
+          const severity = item.metadata.severity ?? "info";
+          lines.push(`**${item.id}** [${item.type}/${item.layer ?? "unknown"}] ${severity.toUpperCase()} (score: ${score.toFixed(2)})`);
+          lines.push(`  ${item.title}`);
+          lines.push(`  ${item.summary}`);
+          if (item.metadata.tags && item.metadata.tags.length > 0) {
+            lines.push(`  Tags: ${item.metadata.tags.join(", ")}`);
+          }
+          lines.push(`  Provider: ${item.provider}`);
+          lines.push("");
+        }
+        return lines.join(`
+`);
+      } catch (e) {
+        return `Error querying knowledge: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }
+  });
+  const knowledge_list2 = tool({
+    description: "List all knowledge items in the repository with statistics. " + "Provides an overview of ADRs, policies, patterns, and specs organized by layer and type.",
+    args: {
+      layer: tool.schema.enum(["company", "org", "project"]).optional().describe("Filter to specific layer"),
+      type: tool.schema.enum(["adr", "policy", "pattern", "spec"]).optional().describe("Filter to specific type"),
+      verbose: tool.schema.boolean().optional().describe("Include item summaries (default: false)")
+    },
+    execute: async (args) => {
+      try {
+        const health = await registry2.healthCheck();
+        const providers = registry2.getProviders();
+        const types14 = args.type ? [args.type] : undefined;
+        const results = await registry2.search({
+          text: "",
+          types: types14,
+          layers: args.layer ? [args.layer] : undefined,
+          limit: 200,
+          includeContent: false
+        });
+        const lines = [
+          "# Knowledge Provider Statistics",
+          "",
+          `Total providers: ${providers.length}`,
+          "",
+          "## Providers"
+        ];
+        for (const provider of providers) {
+          const status = health.get(provider.name);
+          const statusStr = status?.status ?? "unknown";
+          lines.push(`- ${provider.name} (${provider.type}): ${statusStr}`);
+        }
+        lines.push("");
+        lines.push("## Items Found");
+        lines.push(`Total: ${results.length}`);
+        lines.push("");
+        const byType = {};
+        const byLayer = {};
+        const byProvider = {};
+        for (const { item } of results) {
+          byType[item.type] = (byType[item.type] ?? 0) + 1;
+          byLayer[item.layer ?? "unknown"] = (byLayer[item.layer ?? "unknown"] ?? 0) + 1;
+          byProvider[item.provider] = (byProvider[item.provider] ?? 0) + 1;
+        }
+        lines.push("### By Type");
+        for (const [type2, count] of Object.entries(byType)) {
+          lines.push(`- ${type2}: ${count}`);
+        }
+        lines.push("");
+        lines.push("### By Layer");
+        for (const [layer, count] of Object.entries(byLayer)) {
+          lines.push(`- ${layer}: ${count}`);
+        }
+        lines.push("");
+        lines.push("### By Provider");
+        for (const [provider, count] of Object.entries(byProvider)) {
+          lines.push(`- ${provider}: ${count}`);
+        }
+        if (args.verbose && results.length > 0) {
+          lines.push("");
+          lines.push("## Items");
+          for (const { item } of results) {
+            lines.push(`- **${item.id}** [${item.type}/${item.layer ?? "unknown"}] ${item.title}`);
+          }
+        }
+        return lines.join(`
+`);
+      } catch (e) {
+        return `Error listing knowledge: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }
+  });
+  const knowledge_show2 = tool({
+    description: "Show full details of a specific knowledge item by ID. " + "Includes complete content, constraints, metadata, and optionally version history.",
+    args: {
+      id: tool.schema.string().describe("The knowledge item ID to retrieve"),
+      includeConstraints: tool.schema.boolean().optional().describe("Include constraint details (default: true)"),
+      includeHistory: tool.schema.boolean().optional().describe("Include version history (default: false)")
+    },
+    execute: async (args) => {
+      try {
+        const item = await registry2.getById(args.id);
+        if (!item) {
+          return `Knowledge item not found: ${args.id}`;
+        }
+        const includeConstraints = args.includeConstraints ?? true;
+        const lines = [
+          `# ${item.title}`,
+          "",
+          `**ID:** ${item.id}`,
+          `**Type:** ${item.type}`,
+          `**Layer:** ${item.layer ?? "unknown"}`,
+          `**Provider:** ${item.provider}`
+        ];
+        if (item.metadata.severity) {
+          lines.push(`**Severity:** ${item.metadata.severity}`);
+        }
+        if (item.createdAt) {
+          lines.push(`**Created:** ${item.createdAt}`);
+        }
+        lines.push("");
+        if (item.metadata.tags && item.metadata.tags.length > 0) {
+          lines.push(`**Tags:** ${item.metadata.tags.join(", ")}`);
+          lines.push("");
+        }
+        lines.push("## Summary");
+        lines.push("");
+        lines.push(item.summary);
+        lines.push("");
+        if (item.content) {
+          lines.push("## Content");
+          lines.push("");
+          lines.push(item.content);
+          lines.push("");
+        }
+        if (includeConstraints && item.metadata.extra?.constraints && Array.isArray(item.metadata.extra.constraints)) {
+          const constraints = item.metadata.extra.constraints;
+          if (constraints.length > 0) {
+            lines.push("## Constraints");
+            lines.push("");
+            for (const c of constraints) {
+              lines.push(`### ${c.id ?? "constraint"}`);
+              if (c.operator)
+                lines.push(`- **Operator:** ${c.operator}`);
+              if (c.target)
+                lines.push(`- **Target:** ${c.target}`);
+              if (c.pattern)
+                lines.push(`- **Pattern:** \`${c.pattern}\``);
+              if (c.severity)
+                lines.push(`- **Severity:** ${c.severity}`);
+              if (c.message)
+                lines.push(`- **Message:** ${c.message}`);
+              if (c.appliesTo?.length)
+                lines.push(`- **Applies To:** ${c.appliesTo.join(", ")}`);
+              if (c.excludes?.length)
+                lines.push(`- **Excludes:** ${c.excludes.join(", ")}`);
+              lines.push("");
+            }
+          }
+        }
+        return lines.join(`
+`);
+      } catch (e) {
+        return `Error showing knowledge: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }
+  });
+  return {
+    knowledge_query: knowledge_query2,
+    knowledge_list: knowledge_list2,
+    knowledge_show: knowledge_show2
+  };
+}
 // src/tools/interactive-bash/constants.ts
 var DEFAULT_TIMEOUT_MS4 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
@@ -43580,399 +43777,1156 @@ class Mem0Adapter {
     });
   }
 }
-// src/features/background-agent/manager.ts
-import { existsSync as existsSync48, readdirSync as readdirSync17 } from "fs";
-import { join as join61 } from "path";
-var TASK_TTL_MS = 30 * 60 * 1000;
-function getMessageDir11(sessionID) {
-  if (!existsSync48(MESSAGE_STORAGE))
-    return null;
-  const directPath = join61(MESSAGE_STORAGE, sessionID);
-  if (existsSync48(directPath))
-    return directPath;
-  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
-    const sessionPath = join61(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync48(sessionPath))
-      return sessionPath;
-  }
-  return null;
-}
 
-class BackgroundManager {
-  tasks;
-  notifications;
-  client;
-  directory;
-  pollingInterval;
-  constructor(ctx) {
-    this.tasks = new Map;
-    this.notifications = new Map;
-    this.client = ctx.client;
-    this.directory = ctx.directory;
+// src/features/letta-memory/adapter.ts
+var DEFAULT_ENDPOINT2 = "http://localhost:8283";
+var DEFAULT_AGENT_PREFIX = "opencode";
+var DEFAULT_LLM_MODEL = "openai/gpt-4.1";
+var DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small";
+
+class LettaAdapter {
+  config;
+  endpoint;
+  agentCache = new Map;
+  constructor(config3) {
+    this.config = config3;
+    this.endpoint = config3.endpoint ?? DEFAULT_ENDPOINT2;
   }
-  async launch(input) {
-    if (!input.agent || input.agent.trim() === "") {
-      throw new Error("Agent parameter is required");
+  async add(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
     }
-    const createResult = await this.client.session.create({
-      body: {
-        parentID: input.parentSessionID,
-        title: `Background: ${input.description}`
-      }
+    const agent = await this.getOrCreateAgent(input.layer);
+    const tags = [
+      `layer:${input.layer}`,
+      ...input.tags ?? [],
+      ...input.metadata ? Object.entries(input.metadata).map(([k, v]) => `${k}:${v}`) : []
+    ];
+    const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, {
+      method: "POST",
+      body: JSON.stringify({
+        text: input.content,
+        tags
+      })
     });
-    if (createResult.error) {
-      throw new Error(`Failed to create background session: ${createResult.error}`);
+    const passage = await response2.json();
+    return this.passageToMemory(passage, input.layer, agent.id);
+  }
+  async search(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
     }
-    const sessionID = createResult.data.id;
-    subagentSessions.add(sessionID);
-    const task = {
-      id: `bg_${crypto.randomUUID().slice(0, 8)}`,
-      sessionID,
-      parentSessionID: input.parentSessionID,
-      parentMessageID: input.parentMessageID,
-      description: input.description,
-      prompt: input.prompt,
-      agent: input.agent,
-      status: "running",
-      startedAt: new Date,
-      progress: {
-        toolCalls: 0,
-        lastUpdate: new Date
-      },
-      parentModel: input.parentModel
-    };
-    this.tasks.set(task.id, task);
-    this.startPolling();
-    log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent });
-    this.client.session.promptAsync({
-      path: { id: sessionID },
-      body: {
-        agent: input.agent,
-        tools: {
-          task: false,
-          background_task: false
-        },
-        parts: [{ type: "text", text: input.prompt }]
+    const layers = this.normalizeLayers(input.layer);
+    const results = [];
+    for (const layer of layers) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        const params = new URLSearchParams;
+        params.set("query", input.query);
+        if (input.limit)
+          params.set("limit", String(input.limit));
+        if (input.tags?.length) {
+          params.set("tags", input.tags.join(","));
+          params.set("tag_match_mode", input.tagMatchMode ?? "any");
+        }
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory/search?${params.toString()}`, { method: "GET" });
+        const data = await response2.json();
+        const layerResults = data.map((passage, index) => ({
+          memory: this.passageToMemory(passage, layer, agent.id),
+          score: 1 - index * 0.05
+        }));
+        results.push(...layerResults);
+      } catch {
+        continue;
       }
-    }).catch((error45) => {
-      log("[background-agent] promptAsync error:", error45);
-      const existingTask = this.findBySession(sessionID);
-      if (existingTask) {
-        existingTask.status = "error";
-        const errorMessage = error45 instanceof Error ? error45.message : String(error45);
-        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-          existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
-        } else {
-          existingTask.error = errorMessage;
+    }
+    return results.filter((r) => !input.threshold || r.score >= input.threshold).sort((a, b) => b.score - a.score).slice(0, input.limit ?? 10);
+  }
+  async get(id) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    for (const layer of this.getAllLayers()) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, { method: "GET" });
+        const passages = await response2.json();
+        const passage = passages.find((p) => p.id === id);
+        if (passage) {
+          return this.passageToMemory(passage, layer, agent.id);
         }
-        existingTask.completedAt = new Date;
-        this.markForNotification(existingTask);
-        this.notifyParentSession(existingTask);
+      } catch {
+        continue;
       }
-    });
-    return task;
+    }
+    return null;
   }
-  getTask(id) {
-    return this.tasks.get(id);
+  async update(input) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    const existing = await this.get(input.id);
+    if (!existing) {
+      throw new Error(`Memory not found: ${input.id}`);
+    }
+    await this.delete(input.id);
+    return this.add({
+      content: input.content ?? existing.content,
+      layer: existing.layer,
+      metadata: input.metadata ? { ...existing.metadata, ...input.metadata } : existing.metadata,
+      tags: input.tags
+    });
   }
-  getTasksByParentSession(sessionID) {
-    const result = [];
-    for (const task of this.tasks.values()) {
-      if (task.parentSessionID === sessionID) {
-        result.push(task);
+  async delete(id) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
+    }
+    for (const layer of this.getAllLayers()) {
+      try {
+        const agent = await this.getAgent(layer);
+        if (!agent)
+          continue;
+        await this.request(`/v1/agents/${agent.id}/archival-memory/${id}`, {
+          method: "DELETE"
+        });
+        return;
+      } catch {
+        continue;
       }
     }
-    return result;
+    throw new Error(`Memory not found: ${id}`);
   }
-  getAllDescendantTasks(sessionID) {
-    const result = [];
-    const directChildren = this.getTasksByParentSession(sessionID);
-    for (const child of directChildren) {
-      result.push(child);
-      const descendants = this.getAllDescendantTasks(child.sessionID);
-      result.push(...descendants);
+  async getAll(layer) {
+    if (!this.config.enabled) {
+      throw new Error("Letta is not enabled");
     }
-    return result;
-  }
-  findBySession(sessionID) {
-    for (const task of this.tasks.values()) {
-      if (task.sessionID === sessionID) {
-        return task;
+    const layers = layer ? [layer] : this.getAllLayers();
+    const memories = [];
+    for (const l of layers) {
+      try {
+        const agent = await this.getAgent(l);
+        if (!agent)
+          continue;
+        const response2 = await this.request(`/v1/agents/${agent.id}/archival-memory`, { method: "GET" });
+        const passages = await response2.json();
+        memories.push(...passages.map((p) => this.passageToMemory(p, l, agent.id)));
+      } catch {
+        continue;
       }
     }
-    return;
+    return memories;
   }
-  async checkSessionTodos(sessionID) {
+  async getStats() {
+    const memories = await this.getAll();
+    const byLayer = {
+      user: 0,
+      session: 0,
+      project: 0,
+      team: 0,
+      org: 0,
+      company: 0,
+      agent: 0
+    };
+    for (const memory of memories) {
+      byLayer[memory.layer]++;
+    }
+    const agents = await this.listAgents();
+    return {
+      totalMemories: memories.length,
+      byLayer,
+      totalAgents: agents.length,
+      totalPassages: memories.length
+    };
+  }
+  async isAvailable() {
     try {
-      const response2 = await this.client.session.todo({
-        path: { id: sessionID }
+      const response2 = await fetch(`${this.endpoint}/v1/health`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5000)
       });
-      const todos = response2.data ?? response2;
-      if (!todos || todos.length === 0)
-        return false;
-      const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-      return incomplete.length > 0;
+      return response2.ok;
     } catch {
       return false;
     }
   }
-  handleEvent(event) {
-    const props = event.properties;
-    if (event.type === "message.part.updated") {
-      if (!props || typeof props !== "object" || !("sessionID" in props))
-        return;
-      const partInfo = props;
-      const sessionID = partInfo?.sessionID;
-      if (!sessionID)
-        return;
-      const task = this.findBySession(sessionID);
-      if (!task)
-        return;
-      if (partInfo?.type === "tool" || partInfo?.tool) {
-        if (!task.progress) {
-          task.progress = {
-            toolCalls: 0,
-            lastUpdate: new Date
-          };
-        }
-        task.progress.toolCalls += 1;
-        task.progress.lastTool = partInfo.tool;
-        task.progress.lastUpdate = new Date;
-      }
-    }
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID;
-      if (!sessionID)
-        return;
-      const task = this.findBySession(sessionID);
-      if (!task || task.status !== "running")
-        return;
-      this.checkSessionTodos(sessionID).then((hasIncompleteTodos2) => {
-        if (hasIncompleteTodos2) {
-          log("[background-agent] Task has incomplete todos, waiting for todo-continuation:", task.id);
-          return;
+  async getOrCreateAgent(layer) {
+    const existing = await this.getAgent(layer);
+    if (existing)
+      return existing;
+    const agentName = this.getAgentName(layer);
+    const response2 = await this.request("/v1/agents", {
+      method: "POST",
+      body: JSON.stringify({
+        name: agentName,
+        model: this.config.llmModel ?? DEFAULT_LLM_MODEL,
+        embedding: this.config.embeddingModel ?? DEFAULT_EMBEDDING_MODEL,
+        memory_blocks: [
+          { label: "persona", value: `OpenCode memory agent for ${layer} layer` },
+          { label: "human", value: this.getUserId(layer) }
+        ],
+        metadata: {
+          layer,
+          user_id: this.getUserId(layer),
+          created_by: "oh-my-opencode"
         }
-        task.status = "completed";
-        task.completedAt = new Date;
-        this.markForNotification(task);
-        this.notifyParentSession(task);
-        log("[background-agent] Task completed via session.idle event:", task.id);
-      });
+      })
+    });
+    const agent = await response2.json();
+    this.agentCache.set(layer, agent);
+    return agent;
+  }
+  async getAgent(layer) {
+    if (this.agentCache.has(layer)) {
+      return this.agentCache.get(layer);
     }
-    if (event.type === "session.deleted") {
-      const info = props?.info;
-      if (!info || typeof info.id !== "string")
-        return;
-      const sessionID = info.id;
-      const task = this.findBySession(sessionID);
-      if (!task)
-        return;
-      if (task.status === "running") {
-        task.status = "cancelled";
-        task.completedAt = new Date;
-        task.error = "Session deleted";
-      }
-      this.tasks.delete(task.id);
-      this.clearNotificationsForTask(task.id);
-      subagentSessions.delete(sessionID);
+    const agentName = this.getAgentName(layer);
+    const agents = await this.listAgents();
+    const agent = agents.find((a) => a.name === agentName);
+    if (agent) {
+      this.agentCache.set(layer, agent);
     }
+    return agent ?? null;
   }
-  markForNotification(task) {
-    const queue = this.notifications.get(task.parentSessionID) ?? [];
-    queue.push(task);
-    this.notifications.set(task.parentSessionID, queue);
+  async listAgents() {
+    try {
+      const response2 = await this.request("/v1/agents", { method: "GET" });
+      const data = await response2.json();
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
   }
-  getPendingNotifications(sessionID) {
-    return this.notifications.get(sessionID) ?? [];
+  async request(path7, options) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    const response2 = await fetch(`${this.endpoint}${path7}`, {
+      method: options.method,
+      headers,
+      body: options.body
+    });
+    if (!response2.ok) {
+      const text = await response2.text().catch(() => "");
+      throw new Error(`Letta API error: ${response2.status} ${response2.statusText} - ${text}`);
+    }
+    return response2;
   }
-  clearNotifications(sessionID) {
-    this.notifications.delete(sessionID);
+  getAgentName(layer) {
+    const prefix = this.config.agentPrefix ?? DEFAULT_AGENT_PREFIX;
+    const userId = this.getUserId(layer);
+    return `${prefix}-${layer}-${userId}`;
   }
-  clearNotificationsForTask(taskId) {
-    for (const [sessionID, tasks] of this.notifications.entries()) {
-      const filtered = tasks.filter((t) => t.id !== taskId);
-      if (filtered.length === 0) {
-        this.notifications.delete(sessionID);
-      } else {
-        this.notifications.set(sessionID, filtered);
-      }
+  getUserId(layer) {
+    switch (layer) {
+      case "user":
+        return this.config.userId ?? "default-user";
+      case "session":
+        return `session-${this.config.userId ?? "default"}`;
+      case "project":
+        return this.config.projectId ?? "default-project";
+      case "team":
+        return this.config.teamId ?? "default-team";
+      case "org":
+        return this.config.orgId ?? "default-org";
+      case "company":
+        return this.config.companyId ?? "default-company";
+      case "agent":
+        return "default-agent";
     }
   }
-  startPolling() {
-    if (this.pollingInterval)
-      return;
-    this.pollingInterval = setInterval(() => {
-      this.pollRunningTasks();
-    }, 2000);
-    this.pollingInterval.unref();
+  normalizeLayers(layer) {
+    if (!layer)
+      return this.getAllLayers();
+    return Array.isArray(layer) ? layer : [layer];
   }
-  stopPolling() {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-      this.pollingInterval = undefined;
+  getAllLayers() {
+    return ["user", "session", "project", "team", "org", "company", "agent"];
+  }
+  passageToMemory(passage, layer, agentId) {
+    return {
+      id: passage.id,
+      content: passage.text,
+      layer,
+      metadata: passage.metadata,
+      createdAt: passage.created_at,
+      source: "passage",
+      agentId
+    };
+  }
+}
+// src/features/knowledge-provider/registry.ts
+var DEFAULT_CONFIG2 = {
+  defaultLimit: 10,
+  defaultThreshold: 0.5,
+  mergeStrategy: "score",
+  deduplicate: true
+};
+
+class KnowledgeProviderRegistry {
+  providers = new Map;
+  config;
+  constructor(config3) {
+    this.config = { ...DEFAULT_CONFIG2, ...config3 };
+  }
+  async register(provider) {
+    if (this.providers.has(provider.name)) {
+      throw new Error(`Provider "${provider.name}" is already registered`);
     }
+    await provider.initialize();
+    this.providers.set(provider.name, provider);
   }
-  cleanup() {
-    this.stopPolling();
-    this.tasks.clear();
-    this.notifications.clear();
+  async unregister(name) {
+    const provider = this.providers.get(name);
+    if (!provider) {
+      return;
+    }
+    if (provider.dispose) {
+      await provider.dispose();
+    }
+    this.providers.delete(name);
   }
-  notifyParentSession(task) {
-    const duration3 = this.formatDuration(task.startedAt, task.completedAt);
-    log("[background-agent] notifyParentSession called for task:", task.id);
-    const tuiClient = this.client;
-    if (tuiClient.tui?.showToast) {
-      tuiClient.tui.showToast({
-        body: {
-          title: "Background Task Completed",
-          message: `Task "${task.description}" finished in ${duration3}.`,
-          variant: "success",
-          duration: 5000
-        }
-      }).catch(() => {});
+  async search(query) {
+    const targetProviders = this.getTargetProviders(query.providers);
+    if (targetProviders.length === 0) {
+      return [];
     }
-    const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished in ${duration3}. Use background_output with task_id="${task.id}" to get results.`;
-    log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
-    const taskId = task.id;
-    setTimeout(async () => {
+    const limit = query.limit ?? this.config.defaultLimit;
+    const threshold = query.threshold ?? this.config.defaultThreshold;
+    const searchPromises = targetProviders.map(async (provider) => {
       try {
-        const messageDir = getMessageDir11(task.parentSessionID);
-        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-        const modelContext = task.parentModel ?? prevMessage?.model;
-        const modelField = modelContext?.providerID && modelContext?.modelID ? { providerID: modelContext.providerID, modelID: modelContext.modelID } : undefined;
-        await this.client.session.prompt({
-          path: { id: task.parentSessionID },
-          body: {
-            agent: prevMessage?.agent,
-            model: modelField,
-            parts: [{ type: "text", text: message }]
-          },
-          query: { directory: this.directory }
+        const results = await provider.search({
+          ...query,
+          limit: limit * 2,
+          threshold
         });
-        log("[background-agent] Successfully sent prompt to parent session:", { parentSessionID: task.parentSessionID });
-      } catch (error45) {
-        log("[background-agent] prompt failed:", String(error45));
-      } finally {
-        this.clearNotificationsForTask(taskId);
-        this.tasks.delete(taskId);
-        log("[background-agent] Removed completed task from memory:", taskId);
+        return { provider: provider.name, results };
+      } catch {
+        return { provider: provider.name, results: [] };
       }
-    }, 200);
-  }
-  formatDuration(start, end) {
-    const duration3 = (end ?? new Date).getTime() - start.getTime();
-    const seconds = Math.floor(duration3 / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    } else if (minutes > 0) {
-      return `${minutes}m ${seconds % 60}s`;
+    });
+    const allResults = await Promise.all(searchPromises);
+    const merged = this.mergeResults(allResults.flatMap((r) => r.results), this.config.mergeStrategy, limit);
+    if (this.config.deduplicate) {
+      return this.deduplicateResults(merged);
     }
-    return `${seconds}s`;
+    return merged.slice(0, limit);
   }
-  hasRunningTasks() {
-    for (const task of this.tasks.values()) {
-      if (task.status === "running")
-        return true;
+  async getById(id) {
+    const [providerName, itemId] = this.parseId(id);
+    if (providerName) {
+      const provider = this.providers.get(providerName);
+      if (provider?.getById) {
+        return provider.getById(itemId);
+      }
+      return null;
     }
-    return false;
-  }
-  pruneStaleTasksAndNotifications() {
-    const now = Date.now();
-    for (const [taskId, task] of this.tasks.entries()) {
-      const age = now - task.startedAt.getTime();
-      if (age > TASK_TTL_MS) {
-        log("[background-agent] Pruning stale task:", { taskId, age: Math.round(age / 1000) + "s" });
-        task.status = "error";
-        task.error = "Task timed out after 30 minutes";
-        task.completedAt = new Date;
-        this.clearNotificationsForTask(taskId);
-        this.tasks.delete(taskId);
-        subagentSessions.delete(task.sessionID);
+    for (const provider of this.providers.values()) {
+      if (provider.getById) {
+        const item = await provider.getById(id);
+        if (item) {
+          return item;
+        }
       }
     }
-    for (const [sessionID, notifications] of this.notifications.entries()) {
-      if (notifications.length === 0) {
-        this.notifications.delete(sessionID);
-        continue;
+    return null;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+  getProvider(name) {
+    return this.providers.get(name);
+  }
+  async healthCheck() {
+    const results = new Map;
+    const checks3 = Array.from(this.providers.entries()).map(async ([name, provider]) => {
+      try {
+        const health = await provider.healthCheck();
+        results.set(name, health);
+      } catch (error45) {
+        results.set(name, {
+          status: "unavailable",
+          message: error45 instanceof Error ? error45.message : "Unknown error",
+          lastChecked: new Date().toISOString()
+        });
       }
-      const validNotifications = notifications.filter((task) => {
-        const age = now - task.startedAt.getTime();
-        return age <= TASK_TTL_MS;
-      });
-      if (validNotifications.length === 0) {
-        this.notifications.delete(sessionID);
-      } else if (validNotifications.length !== notifications.length) {
-        this.notifications.set(sessionID, validNotifications);
+    });
+    await Promise.all(checks3);
+    return results;
+  }
+  getTargetProviders(filterNames) {
+    if (!filterNames || filterNames.length === 0) {
+      return Array.from(this.providers.values());
+    }
+    return filterNames.map((name) => this.providers.get(name)).filter((p) => p !== undefined);
+  }
+  mergeResults(results, strategy, limit) {
+    switch (strategy) {
+      case "score":
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+      case "round-robin":
+        return this.roundRobinMerge(results, limit);
+      case "provider-priority":
+        return this.priorityMerge(results, limit);
+      default:
+        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+    }
+  }
+  roundRobinMerge(results, limit) {
+    const byProvider = new Map;
+    for (const result of results) {
+      const provider = result.item.provider;
+      const existing = byProvider.get(provider) ?? [];
+      existing.push(result);
+      byProvider.set(provider, existing);
+    }
+    for (const [provider, items] of byProvider) {
+      byProvider.set(provider, items.sort((a, b) => b.score - a.score));
+    }
+    const merged = [];
+    const providers = Array.from(byProvider.keys());
+    let index = 0;
+    while (merged.length < limit) {
+      let added = false;
+      for (const provider of providers) {
+        const items = byProvider.get(provider);
+        if (index < items.length) {
+          merged.push(items[index]);
+          added = true;
+          if (merged.length >= limit)
+            break;
+        }
       }
+      if (!added)
+        break;
+      index++;
     }
+    return merged;
   }
-  async pollRunningTasks() {
-    this.pruneStaleTasksAndNotifications();
-    const statusResult = await this.client.session.status();
-    const allStatuses = statusResult.data ?? {};
-    for (const task of this.tasks.values()) {
-      if (task.status !== "running")
-        continue;
-      try {
-        const sessionStatus = allStatuses[task.sessionID];
-        if (!sessionStatus) {
-          log("[background-agent] Session not found in status:", task.sessionID);
-          continue;
-        }
-        if (sessionStatus.type === "idle") {
-          const hasIncompleteTodos2 = await this.checkSessionTodos(task.sessionID);
-          if (hasIncompleteTodos2) {
-            log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
-            continue;
-          }
-          task.status = "completed";
-          task.completedAt = new Date;
-          this.markForNotification(task);
-          this.notifyParentSession(task);
-          log("[background-agent] Task completed via polling:", task.id);
-          continue;
+  priorityMerge(results, limit) {
+    const priority = this.config.providerPriority ?? [];
+    return results.sort((a, b) => {
+      const aPriority = priority.indexOf(a.item.provider);
+      const bPriority = priority.indexOf(b.item.provider);
+      const aOrder = aPriority === -1 ? Infinity : aPriority;
+      const bOrder = bPriority === -1 ? Infinity : bPriority;
+      if (aOrder !== bOrder) {
+        return aOrder - bOrder;
+      }
+      return b.score - a.score;
+    }).slice(0, limit);
+  }
+  deduplicateResults(results) {
+    const seen = new Set;
+    const deduplicated = [];
+    for (const result of results) {
+      const hash2 = this.contentHash(result.item);
+      if (!seen.has(hash2)) {
+        seen.add(hash2);
+        deduplicated.push(result);
+      }
+    }
+    return deduplicated;
+  }
+  contentHash(item) {
+    const content = item.content ?? item.summary;
+    return `${item.title}:${content.slice(0, 200)}`;
+  }
+  parseId(id) {
+    const separator = "::";
+    const index = id.indexOf(separator);
+    if (index === -1) {
+      return [null, id];
+    }
+    return [id.slice(0, index), id.slice(index + separator.length)];
+  }
+}
+// src/features/knowledge-provider/providers/local.ts
+var DEFAULT_CONFIG3 = {
+  enabled: true,
+  rootDir: ".opencode/knowledge"
+};
+
+class LocalKnowledgeProvider {
+  name = "local";
+  type = "local";
+  description = "Local file-based knowledge repository";
+  config;
+  repository = null;
+  initialized = false;
+  constructor(config3) {
+    this.config = { ...DEFAULT_CONFIG3, ...config3 };
+  }
+  async initialize() {
+    if (!this.config.enabled) {
+      return;
+    }
+    this.repository = new KnowledgeRepository({
+      rootDir: this.config.rootDir ?? DEFAULT_CONFIG3.rootDir
+    });
+    await this.repository.initialize();
+    this.initialized = true;
+  }
+  async search(query) {
+    if (!this.initialized || !this.repository) {
+      return [];
+    }
+    const filter = {
+      search: query.text,
+      limit: query.limit ?? 10
+    };
+    if (query.layers && query.layers.length > 0) {
+      const validLayers = query.layers.filter(this.isKnowledgeLayer);
+      if (validLayers.length > 0) {
+        filter.layer = validLayers;
+      }
+    }
+    if (query.types && query.types.length > 0) {
+      const validTypes = query.types.filter(this.isKnowledgeType);
+      if (validTypes.length > 0) {
+        filter.type = validTypes;
+      }
+    }
+    const result = await this.repository.query(filter);
+    return result.items.map((commit) => ({
+      item: this.commitToItem(commit, query.includeContent),
+      score: this.calculateScore(commit, query.text)
+    }));
+  }
+  async getById(id) {
+    if (!this.initialized || !this.repository) {
+      return null;
+    }
+    const commit = await this.repository.getCommitById(id);
+    if (!commit) {
+      return null;
+    }
+    return this.commitToItem(commit, true);
+  }
+  async healthCheck() {
+    const now = new Date().toISOString();
+    if (!this.config.enabled) {
+      return {
+        status: "unavailable",
+        message: "Provider is disabled",
+        lastChecked: now
+      };
+    }
+    if (!this.initialized || !this.repository) {
+      return {
+        status: "unavailable",
+        message: "Provider not initialized",
+        lastChecked: now
+      };
+    }
+    try {
+      const start = Date.now();
+      await this.repository.getStats();
+      const latencyMs = Date.now() - start;
+      return {
+        status: "healthy",
+        latencyMs,
+        lastChecked: now
+      };
+    } catch (error45) {
+      return {
+        status: "degraded",
+        message: error45 instanceof Error ? error45.message : "Unknown error",
+        lastChecked: now
+      };
+    }
+  }
+  commitToItem(commit, includeContent) {
+    return {
+      id: `local::${commit.id}`,
+      provider: this.name,
+      title: commit.title,
+      summary: commit.summary,
+      content: includeContent ? commit.content : undefined,
+      type: commit.type,
+      layer: commit.layer,
+      metadata: {
+        sourceType: "local",
+        sourceId: commit.id,
+        tags: commit.tags,
+        severity: commit.severity,
+        knowledgeLayer: commit.layer,
+        extra: {
+          constraints: commit.constraints,
+          triggerKeywords: commit.triggerKeywords,
+          author: commit.author
         }
-        const messagesResult = await this.client.session.messages({
-          path: { id: task.sessionID }
+      },
+      createdAt: commit.createdAt
+    };
+  }
+  calculateScore(commit, searchText) {
+    if (!searchText) {
+      return 0.5;
+    }
+    const lowerSearch = searchText.toLowerCase();
+    const titleMatch = commit.title.toLowerCase().includes(lowerSearch);
+    const summaryMatch = commit.summary.toLowerCase().includes(lowerSearch);
+    const contentMatch = commit.content.toLowerCase().includes(lowerSearch);
+    const tagMatch = commit.tags.some((t) => t.toLowerCase().includes(lowerSearch));
+    const keywordMatch = commit.triggerKeywords.some((k) => k.toLowerCase().includes(lowerSearch));
+    let score = 0.3;
+    if (titleMatch)
+      score += 0.3;
+    if (summaryMatch)
+      score += 0.15;
+    if (contentMatch)
+      score += 0.1;
+    if (tagMatch)
+      score += 0.1;
+    if (keywordMatch)
+      score += 0.05;
+    return Math.min(score, 1);
+  }
+  isKnowledgeType(type2) {
+    return ["adr", "policy", "pattern", "spec"].includes(type2);
+  }
+  isKnowledgeLayer(layer) {
+    return ["company", "org", "team", "project"].includes(layer);
+  }
+}
+// src/features/knowledge-provider/providers/mem0.ts
+var DEFAULT_SEARCH_LAYERS = [
+  "user",
+  "project",
+  "team",
+  "org",
+  "company"
+];
+
+class Mem0KnowledgeProvider {
+  mem0Config;
+  name = "mem0";
+  type = "mem0";
+  description = "Vector-based semantic memory via Mem0";
+  config;
+  adapter = null;
+  initialized = false;
+  constructor(config3, mem0Config) {
+    this.mem0Config = mem0Config;
+    this.config = config3;
+  }
+  async initialize() {
+    if (!this.config.enabled || !this.mem0Config.enabled) {
+      return;
+    }
+    this.adapter = new Mem0Adapter(this.mem0Config);
+    this.initialized = true;
+  }
+  async search(query) {
+    if (!this.initialized || !this.adapter) {
+      return [];
+    }
+    const layers = this.resolveSearchLayers(query.layers);
+    const results = await this.adapter.search({
+      query: query.text,
+      layer: layers,
+      limit: query.limit ?? 10,
+      threshold: query.threshold ?? 0.5
+    });
+    return results.map((result) => ({
+      item: this.memoryToItem(result.memory, query.includeContent),
+      score: result.score
+    }));
+  }
+  async getById(id) {
+    if (!this.initialized || !this.adapter) {
+      return null;
+    }
+    const memory = await this.adapter.get(id);
+    if (!memory) {
+      return null;
+    }
+    return this.memoryToItem(memory, true);
+  }
+  async index(item) {
+    if (!this.initialized || !this.adapter) {
+      return;
+    }
+    const layer = this.itemLayerToMemoryLayer(item.layer);
+    if (!layer) {
+      return;
+    }
+    await this.adapter.add({
+      content: `${item.title}
+
+${item.summary}
+
+${item.content ?? ""}`,
+      layer,
+      metadata: {
+        sourceProvider: item.provider,
+        sourceId: item.metadata.sourceId,
+        type: item.type,
+        tags: item.metadata.tags
+      }
+    });
+  }
+  async healthCheck() {
+    const now = new Date().toISOString();
+    if (!this.config.enabled) {
+      return {
+        status: "unavailable",
+        message: "Provider is disabled",
+        lastChecked: now
+      };
+    }
+    if (!this.initialized || !this.adapter) {
+      return {
+        status: "unavailable",
+        message: "Provider not initialized",
+        lastChecked: now
+      };
+    }
+    try {
+      const start = Date.now();
+      await this.adapter.getStats();
+      const latencyMs = Date.now() - start;
+      return {
+        status: "healthy",
+        latencyMs,
+        lastChecked: now
+      };
+    } catch (error45) {
+      return {
+        status: "degraded",
+        message: error45 instanceof Error ? error45.message : "Unknown error",
+        lastChecked: now
+      };
+    }
+  }
+  memoryToItem(memory, includeContent) {
+    const metadata = memory.metadata ?? {};
+    return {
+      id: `mem0::${memory.id}`,
+      provider: this.name,
+      title: this.extractTitle(memory.content),
+      summary: this.extractSummary(memory.content),
+      content: includeContent ? memory.content : undefined,
+      type: metadata.type ?? "memory",
+      layer: memory.layer,
+      metadata: {
+        sourceType: "mem0",
+        sourceId: memory.id,
+        tags: metadata.tags,
+        memoryLayer: memory.layer,
+        extra: metadata
+      },
+      createdAt: memory.createdAt,
+      updatedAt: memory.updatedAt
+    };
+  }
+  extractTitle(content) {
+    const firstLine = content.split(`
+`)[0] ?? "";
+    return firstLine.slice(0, 100).trim() || "Untitled Memory";
+  }
+  extractSummary(content) {
+    const lines = content.split(`
+`).filter((l) => l.trim());
+    const summary = lines.slice(0, 2).join(" ");
+    return summary.slice(0, 200).trim() || content.slice(0, 200).trim();
+  }
+  resolveSearchLayers(queryLayers) {
+    if (!queryLayers || queryLayers.length === 0) {
+      return this.config.searchLayers ?? DEFAULT_SEARCH_LAYERS;
+    }
+    return queryLayers.filter(this.isMemoryLayer);
+  }
+  itemLayerToMemoryLayer(layer) {
+    if (!layer)
+      return "project";
+    const mapping = {
+      company: "company",
+      org: "org",
+      team: "team",
+      project: "project",
+      user: "user",
+      session: "session",
+      agent: "agent"
+    };
+    return mapping[layer] ?? "project";
+  }
+  isMemoryLayer(layer) {
+    return ["user", "session", "project", "team", "org", "company", "agent"].includes(layer);
+  }
+}
+// src/features/knowledge-provider/providers/mcp.ts
+class MCPKnowledgeProvider {
+  name;
+  type = "mcp";
+  description;
+  config;
+  invoker;
+  initialized = false;
+  constructor(config3, invoker) {
+    this.config = config3;
+    this.invoker = invoker;
+    this.name = `mcp:${config3.name}`;
+    this.description = `MCP knowledge provider via ${config3.name}`;
+  }
+  async initialize() {
+    const available = await this.invoker.isServerAvailable(this.config.name);
+    if (!available) {
+      throw new Error(`MCP server "${this.config.name}" is not available`);
+    }
+    this.initialized = true;
+  }
+  async search(query) {
+    if (!this.initialized) {
+      return [];
+    }
+    try {
+      const result = await this.invoker.invoke(this.config.name, this.config.searchTool, {
+        query: query.text,
+        limit: query.limit ?? 10,
+        ...this.config.config
+      });
+      return this.parseSearchResponse(result, query.includeContent);
+    } catch {
+      return [];
+    }
+  }
+  async getById(id) {
+    if (!this.initialized || !this.config.getTool) {
+      return null;
+    }
+    try {
+      const result = await this.invoker.invoke(this.config.name, this.config.getTool, { id });
+      return this.parseGetResponse(result);
+    } catch {
+      return null;
+    }
+  }
+  async healthCheck() {
+    const now = new Date().toISOString();
+    try {
+      const start = Date.now();
+      const available = await this.invoker.isServerAvailable(this.config.name);
+      const latencyMs = Date.now() - start;
+      if (!available) {
+        return {
+          status: "unavailable",
+          message: `MCP server "${this.config.name}" is not available`,
+          lastChecked: now
+        };
+      }
+      return {
+        status: "healthy",
+        latencyMs,
+        lastChecked: now
+      };
+    } catch (error45) {
+      return {
+        status: "degraded",
+        message: error45 instanceof Error ? error45.message : "Unknown error",
+        lastChecked: now
+      };
+    }
+  }
+  async dispose() {
+    this.initialized = false;
+  }
+  parseSearchResponse(response2, includeContent) {
+    if (!response2) {
+      return [];
+    }
+    if (Array.isArray(response2)) {
+      return response2.map((item, index) => this.responseItemToSearchResult(item, index, includeContent));
+    }
+    const obj = response2;
+    if (obj.results && Array.isArray(obj.results)) {
+      return obj.results.map((item, index) => this.responseItemToSearchResult(item, index, includeContent));
+    }
+    if (obj.items && Array.isArray(obj.items)) {
+      return obj.items.map((item, index) => this.responseItemToSearchResult(item, index, includeContent));
+    }
+    return [this.responseItemToSearchResult(response2, 0, includeContent)];
+  }
+  responseItemToSearchResult(item, index, includeContent) {
+    const obj = item ?? {};
+    const id = String(obj.id ?? obj.document_id ?? obj.url ?? `result-${index}`);
+    const title = String(obj.title ?? obj.name ?? "Untitled");
+    const summary = String(obj.summary ?? obj.snippet ?? obj.excerpt ?? obj.description ?? "");
+    const content = obj.content ?? obj.text ?? obj.body;
+    const score = Number(obj.score ?? obj.relevance ?? obj.similarity ?? 0.5);
+    const url2 = obj.url ? String(obj.url) : undefined;
+    const knowledgeItem = {
+      id: `${this.name}::${id}`,
+      provider: this.name,
+      title,
+      summary: summary.slice(0, 200),
+      content: includeContent && content ? String(content) : undefined,
+      type: this.inferType(obj),
+      metadata: {
+        sourceType: "mcp",
+        sourceId: id,
+        url: url2,
+        extra: obj
+      }
+    };
+    return {
+      item: knowledgeItem,
+      score: Math.min(Math.max(score, 0), 1),
+      highlights: obj.highlights ? obj.highlights : obj.snippet ? [String(obj.snippet)] : undefined
+    };
+  }
+  parseGetResponse(response2) {
+    if (!response2) {
+      return null;
+    }
+    const obj = response2;
+    const id = String(obj.id ?? obj.document_id ?? "unknown");
+    const title = String(obj.title ?? obj.name ?? "Untitled");
+    const content = String(obj.content ?? obj.text ?? obj.body ?? "");
+    return {
+      id: `${this.name}::${id}`,
+      provider: this.name,
+      title,
+      summary: content.slice(0, 200),
+      content,
+      type: this.inferType(obj),
+      metadata: {
+        sourceType: "mcp",
+        sourceId: id,
+        url: obj.url ? String(obj.url) : undefined,
+        extra: obj
+      }
+    };
+  }
+  inferType(obj) {
+    const typeField = obj.type ?? obj.kind ?? obj.category;
+    if (typeof typeField === "string") {
+      const lowerType = typeField.toLowerCase();
+      if (["adr", "policy", "pattern", "spec"].includes(lowerType)) {
+        return lowerType;
+      }
+      if (lowerType.includes("doc"))
+        return "document";
+      if (lowerType.includes("article"))
+        return "article";
+      if (lowerType.includes("snippet") || lowerType.includes("code"))
+        return "snippet";
+    }
+    if (obj.url && String(obj.url).includes("github")) {
+      return "snippet";
+    }
+    return "document";
+  }
+}
+// src/features/knowledge-provider/providers/notebooklm.ts
+class NotebookLMKnowledgeProvider {
+  name = "notebooklm";
+  type = "mcp";
+  description = "Google NotebookLM AI-powered knowledge notebooks";
+  config;
+  invoker;
+  initialized = false;
+  notebooks = new Map;
+  constructor(config3, invoker) {
+    this.config = config3;
+    this.invoker = invoker;
+  }
+  async initialize() {
+    if (!this.config.enabled) {
+      return;
+    }
+    const available = await this.invoker.isServerAvailable("notebooklm-mcp");
+    if (!available) {
+      throw new Error("NotebookLM MCP server is not available");
+    }
+    await this.refreshNotebooks();
+    this.initialized = true;
+  }
+  async search(query) {
+    if (!this.initialized) {
+      return [];
+    }
+    const results = [];
+    const notebookIds = this.getTargetNotebooks(query);
+    for (const notebookId of notebookIds) {
+      try {
+        const response2 = await this.invoker.invoke("notebooklm-mcp", "notebook_query", {
+          notebook_id: notebookId,
+          query: query.text
         });
-        if (!messagesResult.error && messagesResult.data) {
-          const messages = messagesResult.data;
-          const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
-          let toolCalls = 0;
-          let lastTool;
-          let lastMessage;
-          for (const msg of assistantMsgs) {
-            const parts = msg.parts ?? [];
-            for (const part of parts) {
-              if (part.type === "tool_use" || part.tool) {
-                toolCalls++;
-                lastTool = part.tool || part.name || "unknown";
-              }
-              if (part.type === "text" && part.text) {
-                lastMessage = part.text;
+        if (response2?.answer) {
+          const notebook = this.notebooks.get(notebookId);
+          results.push({
+            item: {
+              id: `notebooklm::${notebookId}::query`,
+              provider: this.name,
+              title: `Answer from "${notebook?.title ?? notebookId}"`,
+              summary: response2.answer.slice(0, 200),
+              content: query.includeContent ? response2.answer : undefined,
+              type: "document",
+              metadata: {
+                sourceType: "mcp",
+                sourceId: notebookId,
+                extra: {
+                  notebookId,
+                  notebookTitle: notebook?.title,
+                  citedSources: response2.sources
+                }
               }
-            }
-          }
-          if (!task.progress) {
-            task.progress = { toolCalls: 0, lastUpdate: new Date };
+            },
+            score: 0.9,
+            highlights: response2.sources?.map((s) => s.snippet).filter(Boolean)
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return results.slice(0, query.limit ?? 10);
+  }
+  async getById(id) {
+    if (!this.initialized) {
+      return null;
+    }
+    const parts = id.split("::");
+    if (parts.length < 2) {
+      return null;
+    }
+    const notebookId = parts[0];
+    const itemType = parts[1];
+    try {
+      if (itemType === "notebook") {
+        const response2 = await this.invoker.invoke("notebooklm-mcp", "notebook_describe", { notebook_id: notebookId });
+        const notebook = this.notebooks.get(notebookId);
+        return {
+          id: `notebooklm::${notebookId}::notebook`,
+          provider: this.name,
+          title: notebook?.title ?? "Notebook",
+          summary: response2.description?.slice(0, 200) ?? "",
+          content: response2.description,
+          type: "document",
+          metadata: {
+            sourceType: "mcp",
+            sourceId: notebookId,
+            tags: response2.keywords,
+            extra: { notebookId }
           }
-          task.progress.toolCalls = toolCalls;
-          task.progress.lastTool = lastTool;
-          task.progress.lastUpdate = new Date;
-          if (lastMessage) {
-            task.progress.lastMessage = lastMessage;
-            task.progress.lastMessageAt = new Date;
+        };
+      }
+      if (itemType === "source") {
+        const sourceId = parts[2];
+        const response2 = await this.invoker.invoke("notebooklm-mcp", "source_describe", { notebook_id: notebookId, source_id: sourceId });
+        return {
+          id: `notebooklm::${notebookId}::source::${sourceId}`,
+          provider: this.name,
+          title: `Source ${sourceId}`,
+          summary: response2.summary?.slice(0, 200) ?? "",
+          content: response2.summary,
+          type: "document",
+          metadata: {
+            sourceType: "mcp",
+            sourceId: `${notebookId}/${sourceId}`,
+            tags: response2.keywords,
+            extra: { notebookId, sourceId }
           }
-        }
-      } catch (error45) {
-        log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
+        };
       }
+    } catch {
+      return null;
     }
-    if (!this.hasRunningTasks()) {
-      this.stopPolling();
+    return null;
+  }
+  async index(item) {
+    if (!this.initialized) {
+      return;
+    }
+    const notebookId = this.config.defaultNotebookId;
+    if (!notebookId) {
+      return;
+    }
+    try {
+      if (item.metadata.url) {
+        await this.invoker.invoke("notebooklm-mcp", "notebook_add_url", {
+          notebook_id: notebookId,
+          url: item.metadata.url
+        });
+      } else if (item.content) {
+        await this.invoker.invoke("notebooklm-mcp", "notebook_add_text", {
+          notebook_id: notebookId,
+          text: `# ${item.title}
+
+${item.content}`,
+          title: item.title
+        });
+      }
+    } catch {}
+  }
+  async healthCheck() {
+    const now = new Date().toISOString();
+    if (!this.config.enabled) {
+      return {
+        status: "unavailable",
+        message: "Provider is disabled",
+        lastChecked: now
+      };
+    }
+    try {
+      const start = Date.now();
+      const available = await this.invoker.isServerAvailable("notebooklm-mcp");
+      const latencyMs = Date.now() - start;
+      if (!available) {
+        return {
+          status: "unavailable",
+          message: "NotebookLM MCP server is not available",
+          lastChecked: now
+        };
+      }
+      return {
+        status: "healthy",
+        latencyMs,
+        message: `${this.notebooks.size} notebooks cached`,
+        lastChecked: now
+      };
+    } catch (error45) {
+      return {
+        status: "degraded",
+        message: error45 instanceof Error ? error45.message : "Unknown error",
+        lastChecked: now
+      };
+    }
+  }
+  async dispose() {
+    this.initialized = false;
+    this.notebooks.clear();
+  }
+  async listNotebooks() {
+    await this.refreshNotebooks();
+    return Array.from(this.notebooks.values());
+  }
+  async refreshNotebooks() {
+    try {
+      const response2 = await this.invoker.invoke("notebooklm-mcp", "notebook_list", {});
+      this.notebooks.clear();
+      if (response2?.notebooks) {
+        for (const nb of response2.notebooks) {
+          this.notebooks.set(nb.id, nb);
+        }
+      }
+    } catch {}
+  }
+  getTargetNotebooks(query) {
+    if (this.config.defaultNotebookId) {
+      return [this.config.defaultNotebookId];
     }
+    const notebookIds = Array.from(this.notebooks.keys());
+    return notebookIds.slice(0, 3);
   }
 }
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
@@ -46250,289 +47204,2237 @@ class Client extends Protocol {
         }
       }
     }
-    return result;
+    return result;
+  }
+  isToolTask(toolName) {
+    if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+      return false;
+    }
+    return this._cachedKnownTaskTools.has(toolName);
+  }
+  isToolTaskRequired(toolName) {
+    return this._cachedRequiredTaskTools.has(toolName);
+  }
+  cacheToolMetadata(tools4) {
+    this._cachedToolOutputValidators.clear();
+    this._cachedKnownTaskTools.clear();
+    this._cachedRequiredTaskTools.clear();
+    for (const tool3 of tools4) {
+      if (tool3.outputSchema) {
+        const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
+        this._cachedToolOutputValidators.set(tool3.name, toolValidator);
+      }
+      const taskSupport = tool3.execution?.taskSupport;
+      if (taskSupport === "required" || taskSupport === "optional") {
+        this._cachedKnownTaskTools.add(tool3.name);
+      }
+      if (taskSupport === "required") {
+        this._cachedRequiredTaskTools.add(tool3.name);
+      }
+    }
+  }
+  getToolOutputValidator(toolName) {
+    return this._cachedToolOutputValidators.get(toolName);
+  }
+  async listTools(params, options) {
+    const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
+    this.cacheToolMetadata(result.tools);
+    return result;
+  }
+  _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+    const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+    if (!parseResult.success) {
+      throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+    }
+    if (typeof options.onChanged !== "function") {
+      throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+    }
+    const { autoRefresh, debounceMs } = parseResult.data;
+    const { onChanged } = options;
+    const refresh = async () => {
+      if (!autoRefresh) {
+        onChanged(null, null);
+        return;
+      }
+      try {
+        const items = await fetcher();
+        onChanged(null, items);
+      } catch (e) {
+        const error45 = e instanceof Error ? e : new Error(String(e));
+        onChanged(error45, null);
+      }
+    };
+    const handler = () => {
+      if (debounceMs) {
+        const existingTimer = this._listChangedDebounceTimers.get(listType);
+        if (existingTimer) {
+          clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(refresh, debounceMs);
+        this._listChangedDebounceTimers.set(listType, timer);
+      } else {
+        refresh();
+      }
+    };
+    this.setNotificationHandler(notificationSchema, handler);
+  }
+  async sendRootsListChanged() {
+    return this.notification({ method: "notifications/roots/list_changed" });
+  }
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import process2 from "process";
+import { PassThrough } from "stream";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+class ReadBuffer {
+  append(chunk) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  }
+  readMessage() {
+    if (!this._buffer) {
+      return null;
+    }
+    const index = this._buffer.indexOf(`
+`);
+    if (index === -1) {
+      return null;
+    }
+    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+    this._buffer = this._buffer.subarray(index + 1);
+    return deserializeMessage(line);
+  }
+  clear() {
+    this._buffer = undefined;
+  }
+}
+function deserializeMessage(line) {
+  return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+  return JSON.stringify(message) + `
+`;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
+var DEFAULT_INHERITED_ENV_VARS = process2.platform === "win32" ? [
+  "APPDATA",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "LOCALAPPDATA",
+  "PATH",
+  "PROCESSOR_ARCHITECTURE",
+  "SYSTEMDRIVE",
+  "SYSTEMROOT",
+  "TEMP",
+  "USERNAME",
+  "USERPROFILE",
+  "PROGRAMFILES"
+] : ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"];
+function getDefaultEnvironment() {
+  const env = {};
+  for (const key of DEFAULT_INHERITED_ENV_VARS) {
+    const value = process2.env[key];
+    if (value === undefined) {
+      continue;
+    }
+    if (value.startsWith("()")) {
+      continue;
+    }
+    env[key] = value;
+  }
+  return env;
+}
+
+class StdioClientTransport {
+  constructor(server) {
+    this._readBuffer = new ReadBuffer;
+    this._stderrStream = null;
+    this._serverParams = server;
+    if (server.stderr === "pipe" || server.stderr === "overlapped") {
+      this._stderrStream = new PassThrough;
+    }
+  }
+  async start() {
+    if (this._process) {
+      throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    return new Promise((resolve8, reject) => {
+      this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
+        env: {
+          ...getDefaultEnvironment(),
+          ...this._serverParams.env
+        },
+        stdio: ["pipe", "pipe", this._serverParams.stderr ?? "inherit"],
+        shell: false,
+        windowsHide: process2.platform === "win32" && isElectron(),
+        cwd: this._serverParams.cwd
+      });
+      this._process.on("error", (error45) => {
+        reject(error45);
+        this.onerror?.(error45);
+      });
+      this._process.on("spawn", () => {
+        resolve8();
+      });
+      this._process.on("close", (_code) => {
+        this._process = undefined;
+        this.onclose?.();
+      });
+      this._process.stdin?.on("error", (error45) => {
+        this.onerror?.(error45);
+      });
+      this._process.stdout?.on("data", (chunk) => {
+        this._readBuffer.append(chunk);
+        this.processReadBuffer();
+      });
+      this._process.stdout?.on("error", (error45) => {
+        this.onerror?.(error45);
+      });
+      if (this._stderrStream && this._process.stderr) {
+        this._process.stderr.pipe(this._stderrStream);
+      }
+    });
+  }
+  get stderr() {
+    if (this._stderrStream) {
+      return this._stderrStream;
+    }
+    return this._process?.stderr ?? null;
+  }
+  get pid() {
+    return this._process?.pid ?? null;
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error45) {
+        this.onerror?.(error45);
+      }
+    }
+  }
+  async close() {
+    if (this._process) {
+      const processToClose = this._process;
+      this._process = undefined;
+      const closePromise = new Promise((resolve8) => {
+        processToClose.once("close", () => {
+          resolve8();
+        });
+      });
+      try {
+        processToClose.stdin?.end();
+      } catch {}
+      await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2000).unref())]);
+      if (processToClose.exitCode === null) {
+        try {
+          processToClose.kill("SIGTERM");
+        } catch {}
+        await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2000).unref())]);
+      }
+      if (processToClose.exitCode === null) {
+        try {
+          processToClose.kill("SIGKILL");
+        } catch {}
+      }
+    }
+    this._readBuffer.clear();
+  }
+  send(message) {
+    return new Promise((resolve8) => {
+      if (!this._process?.stdin) {
+        throw new Error("Not connected");
+      }
+      const json3 = serializeMessage(message);
+      if (this._process.stdin.write(json3)) {
+        resolve8();
+      } else {
+        this._process.stdin.once("drain", resolve8);
+      }
+    });
+  }
+}
+function isElectron() {
+  return "type" in process2;
+}
+
+// node_modules/eventsource-parser/dist/index.js
+class ParseError2 extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+function noop(_arg) {}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError("`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?");
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\x00") ? undefined : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(new ParseError2(`Invalid \`retry\` value: "${value}"`, {
+          type: "invalid-retry",
+          value,
+          line
+        }));
+        break;
+      default:
+        onError(new ParseError2(`Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`, { type: "unknown-field", field, value, line }));
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || undefined,
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = undefined, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = undefined, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (;searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// node_modules/eventsource/dist/index.js
+class ErrorEvent extends Event {
+  constructor(type2, errorEventInitDict) {
+    var _a, _b;
+    super(type2), this.code = (_a = errorEventInitDict == null ? undefined : errorEventInitDict.code) != null ? _a : undefined, this.message = (_b = errorEventInitDict == null ? undefined : errorEventInitDict.message) != null ? _b : undefined;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  [Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+}
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError2(err) {
+  return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError2).join(", ") : ("cause" in err) && err.cause instanceof Error ? `${err}: ${flattenError2(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _readyState;
+var _url2;
+var _redirectUrl;
+var _withCredentials;
+var _fetch;
+var _reconnectInterval;
+var _reconnectTimer;
+var _lastEventId;
+var _controller;
+var _parser;
+var _onError;
+var _onMessage;
+var _onOpen;
+var _EventSource_instances;
+var connect_fn;
+var _onFetchResponse;
+var _onFetchError;
+var getRequestOptions_fn;
+var _onEvent;
+var _onRetryChange;
+var failConnection_fn;
+var scheduleReconnect_fn;
+var _reconnect;
+
+class EventSource extends EventTarget {
+  constructor(url2, eventSourceInitDict) {
+    var _a, _b;
+    super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url2), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response2) => {
+      var _a2;
+      __privateGet(this, _parser).reset();
+      const { body, redirected, status, headers } = response2;
+      if (status === 204) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (redirected ? __privateSet(this, _redirectUrl, new URL(response2.url)) : __privateSet(this, _redirectUrl, undefined), status !== 200) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+        return;
+      }
+      if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+        return;
+      }
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.OPEN);
+      const openEvent = new Event("open");
+      if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+        return;
+      }
+      const decoder2 = new TextDecoder, reader = body.getReader();
+      let open = true;
+      do {
+        const { done, value } = await reader.read();
+        value && __privateGet(this, _parser).feed(decoder2.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+      } while (open);
+    }), __privateAdd(this, _onFetchError, (err) => {
+      __privateSet(this, _controller, undefined), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError2(err));
+    }), __privateAdd(this, _onEvent, (event) => {
+      typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+      const messageEvent = new MessageEvent(event.event || "message", {
+        data: event.data,
+        origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url2).origin,
+        lastEventId: event.id || ""
+      });
+      __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+    }), __privateAdd(this, _onRetryChange, (value) => {
+      __privateSet(this, _reconnectInterval, value);
+    }), __privateAdd(this, _reconnect, () => {
+      __privateSet(this, _reconnectTimer, undefined), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+    });
+    try {
+      if (url2 instanceof URL)
+        __privateSet(this, _url2, url2);
+      else if (typeof url2 == "string")
+        __privateSet(this, _url2, new URL(url2, getBaseURL()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    __privateSet(this, _parser, createParser({
+      onEvent: __privateGet(this, _onEvent),
+      onRetry: __privateGet(this, _onRetryChange)
+    })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3000), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? undefined : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? undefined : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+  }
+  get readyState() {
+    return __privateGet(this, _readyState);
+  }
+  get url() {
+    return __privateGet(this, _url2).href;
+  }
+  get withCredentials() {
+    return __privateGet(this, _withCredentials);
+  }
+  get onerror() {
+    return __privateGet(this, _onError);
+  }
+  set onerror(value) {
+    __privateSet(this, _onError, value);
+  }
+  get onmessage() {
+    return __privateGet(this, _onMessage);
+  }
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
+  }
+  get onopen() {
+    return __privateGet(this, _onOpen);
+  }
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
+  }
+  addEventListener(type2, listener, options) {
+    const listen = listener;
+    super.addEventListener(type2, listen, options);
+  }
+  removeEventListener(type2, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type2, listen, options);
+  }
+  close() {
+    __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, undefined));
+  }
+}
+_readyState = /* @__PURE__ */ new WeakMap, _url2 = /* @__PURE__ */ new WeakMap, _redirectUrl = /* @__PURE__ */ new WeakMap, _withCredentials = /* @__PURE__ */ new WeakMap, _fetch = /* @__PURE__ */ new WeakMap, _reconnectInterval = /* @__PURE__ */ new WeakMap, _reconnectTimer = /* @__PURE__ */ new WeakMap, _lastEventId = /* @__PURE__ */ new WeakMap, _controller = /* @__PURE__ */ new WeakMap, _parser = /* @__PURE__ */ new WeakMap, _onError = /* @__PURE__ */ new WeakMap, _onMessage = /* @__PURE__ */ new WeakMap, _onOpen = /* @__PURE__ */ new WeakMap, _EventSource_instances = /* @__PURE__ */ new WeakSet, connect_fn = function() {
+  __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController), __privateGet(this, _fetch)(__privateGet(this, _url2), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap, _onFetchError = /* @__PURE__ */ new WeakMap, getRequestOptions_fn = function() {
+  var _a;
+  const init = {
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : undefined },
+    cache: "no-store",
+    signal: (_a = __privateGet(this, _controller)) == null ? undefined : _a.signal
+  };
+  return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+}, _onEvent = /* @__PURE__ */ new WeakMap, _onRetryChange = /* @__PURE__ */ new WeakMap, failConnection_fn = function(message, code) {
+  var _a;
+  __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, scheduleReconnect_fn = function(message, code) {
+  var _a;
+  if (__privateGet(this, _readyState) === this.CLOSED)
+    return;
+  __privateSet(this, _readyState, this.CONNECTING);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap, EventSource.CONNECTING = 0, EventSource.OPEN = 1, EventSource.CLOSED = 2;
+function getBaseURL() {
+  const doc2 = "document" in globalThis ? globalThis.document : undefined;
+  return doc2 && typeof doc2 == "object" && "baseURI" in doc2 && typeof doc2.baseURI == "string" ? doc2.baseURI : undefined;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/transport.js
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  return { ...headers };
+}
+function createFetchWithInit(baseFetch = fetch, baseInit) {
+  if (!baseInit) {
+    return baseFetch;
+  }
+  return async (url2, init) => {
+    const mergedInit = {
+      ...baseInit,
+      ...init,
+      headers: init?.headers ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
+    };
+    return baseFetch(url2, mergedInit);
+  };
+}
+
+// node_modules/pkce-challenge/dist/index.node.js
+var crypto2;
+crypto2 = globalThis.crypto?.webcrypto ?? globalThis.crypto ?? import("crypto").then((m) => m.webcrypto);
+async function getRandomValues(size) {
+  return (await crypto2).getRandomValues(new Uint8Array(size));
+}
+async function random(size) {
+  const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
+  const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask.length;
+  let result = "";
+  while (result.length < size) {
+    const randomBytes = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes) {
+      if (randomByte < evenDistCutoff) {
+        result += mask[randomByte % mask.length];
+      }
+    }
+  }
+  return result;
+}
+async function generateVerifier2(length) {
+  return await random(length);
+}
+async function generateChallenge2(code_verifier) {
+  const buffer = await (await crypto2).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
+}
+async function pkceChallenge(length) {
+  if (!length)
+    length = 43;
+  if (length < 43 || length > 128) {
+    throw `Expected a length between 43 and 128. Received ${length}.`;
+  }
+  const verifier = await generateVerifier2(length);
+  const challenge = await generateChallenge2(verifier);
+  return {
+    code_verifier: verifier,
+    code_challenge: challenge
+  };
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth.js
+var SafeUrlSchema = url().superRefine((val, ctx) => {
+  if (!URL.canParse(val)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: "URL must be parseable",
+      fatal: true
+    });
+    return NEVER;
+  }
+}).refine((url2) => {
+  const u = new URL(url2);
+  return u.protocol !== "javascript:" && u.protocol !== "data:" && u.protocol !== "vbscript:";
+}, { message: "URL cannot use javascript:, data:, or vbscript: scheme" });
+var OAuthProtectedResourceMetadataSchema = looseObject({
+  resource: string2().url(),
+  authorization_servers: array(SafeUrlSchema).optional(),
+  jwks_uri: string2().url().optional(),
+  scopes_supported: array(string2()).optional(),
+  bearer_methods_supported: array(string2()).optional(),
+  resource_signing_alg_values_supported: array(string2()).optional(),
+  resource_name: string2().optional(),
+  resource_documentation: string2().optional(),
+  resource_policy_uri: string2().url().optional(),
+  resource_tos_uri: string2().url().optional(),
+  tls_client_certificate_bound_access_tokens: boolean2().optional(),
+  authorization_details_types_supported: array(string2()).optional(),
+  dpop_signing_alg_values_supported: array(string2()).optional(),
+  dpop_bound_access_tokens_required: boolean2().optional()
+});
+var OAuthMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  service_documentation: SafeUrlSchema.optional(),
+  revocation_endpoint: SafeUrlSchema.optional(),
+  revocation_endpoint_auth_methods_supported: array(string2()).optional(),
+  revocation_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  introspection_endpoint: string2().optional(),
+  introspection_endpoint_auth_methods_supported: array(string2()).optional(),
+  introspection_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  code_challenge_methods_supported: array(string2()).optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderMetadataSchema = looseObject({
+  issuer: string2(),
+  authorization_endpoint: SafeUrlSchema,
+  token_endpoint: SafeUrlSchema,
+  userinfo_endpoint: SafeUrlSchema.optional(),
+  jwks_uri: SafeUrlSchema,
+  registration_endpoint: SafeUrlSchema.optional(),
+  scopes_supported: array(string2()).optional(),
+  response_types_supported: array(string2()),
+  response_modes_supported: array(string2()).optional(),
+  grant_types_supported: array(string2()).optional(),
+  acr_values_supported: array(string2()).optional(),
+  subject_types_supported: array(string2()),
+  id_token_signing_alg_values_supported: array(string2()),
+  id_token_encryption_alg_values_supported: array(string2()).optional(),
+  id_token_encryption_enc_values_supported: array(string2()).optional(),
+  userinfo_signing_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_alg_values_supported: array(string2()).optional(),
+  userinfo_encryption_enc_values_supported: array(string2()).optional(),
+  request_object_signing_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_alg_values_supported: array(string2()).optional(),
+  request_object_encryption_enc_values_supported: array(string2()).optional(),
+  token_endpoint_auth_methods_supported: array(string2()).optional(),
+  token_endpoint_auth_signing_alg_values_supported: array(string2()).optional(),
+  display_values_supported: array(string2()).optional(),
+  claim_types_supported: array(string2()).optional(),
+  claims_supported: array(string2()).optional(),
+  service_documentation: string2().optional(),
+  claims_locales_supported: array(string2()).optional(),
+  ui_locales_supported: array(string2()).optional(),
+  claims_parameter_supported: boolean2().optional(),
+  request_parameter_supported: boolean2().optional(),
+  request_uri_parameter_supported: boolean2().optional(),
+  require_request_uri_registration: boolean2().optional(),
+  op_policy_uri: SafeUrlSchema.optional(),
+  op_tos_uri: SafeUrlSchema.optional(),
+  client_id_metadata_document_supported: boolean2().optional()
+});
+var OpenIdProviderDiscoveryMetadataSchema = object({
+  ...OpenIdProviderMetadataSchema.shape,
+  ...OAuthMetadataSchema.pick({
+    code_challenge_methods_supported: true
+  }).shape
+});
+var OAuthTokensSchema = object({
+  access_token: string2(),
+  id_token: string2().optional(),
+  token_type: string2(),
+  expires_in: exports_coerce.number().optional(),
+  scope: string2().optional(),
+  refresh_token: string2().optional()
+}).strip();
+var OAuthErrorResponseSchema = object({
+  error: string2(),
+  error_description: string2().optional(),
+  error_uri: string2().optional()
+});
+var OptionalSafeUrlSchema = SafeUrlSchema.optional().or(literal("").transform(() => {
+  return;
+}));
+var OAuthClientMetadataSchema = object({
+  redirect_uris: array(SafeUrlSchema),
+  token_endpoint_auth_method: string2().optional(),
+  grant_types: array(string2()).optional(),
+  response_types: array(string2()).optional(),
+  client_name: string2().optional(),
+  client_uri: SafeUrlSchema.optional(),
+  logo_uri: OptionalSafeUrlSchema,
+  scope: string2().optional(),
+  contacts: array(string2()).optional(),
+  tos_uri: OptionalSafeUrlSchema,
+  policy_uri: string2().optional(),
+  jwks_uri: SafeUrlSchema.optional(),
+  jwks: any().optional(),
+  software_id: string2().optional(),
+  software_version: string2().optional(),
+  software_statement: string2().optional()
+}).strip();
+var OAuthClientInformationSchema = object({
+  client_id: string2(),
+  client_secret: string2().optional(),
+  client_id_issued_at: number2().optional(),
+  client_secret_expires_at: number2().optional()
+}).strip();
+var OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
+var OAuthClientRegistrationErrorSchema = object({
+  error: string2(),
+  error_description: string2().optional()
+}).strip();
+var OAuthTokenRevocationRequestSchema = object({
+  token: string2(),
+  token_type_hint: string2().optional()
+}).strip();
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/auth-utils.js
+function resourceUrlFromServerUrl(url2) {
+  const resourceURL = typeof url2 === "string" ? new URL(url2) : new URL(url2.href);
+  resourceURL.hash = "";
+  return resourceURL;
+}
+function checkResourceAllowed({ requestedResource, configuredResource }) {
+  const requested = typeof requestedResource === "string" ? new URL(requestedResource) : new URL(requestedResource.href);
+  const configured = typeof configuredResource === "string" ? new URL(configuredResource) : new URL(configuredResource.href);
+  if (requested.origin !== configured.origin) {
+    return false;
+  }
+  if (requested.pathname.length < configured.pathname.length) {
+    return false;
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : requested.pathname + "/";
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : configured.pathname + "/";
+  return requestedPath.startsWith(configuredPath);
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/auth/errors.js
+class OAuthError extends Error {
+  constructor(message, errorUri) {
+    super(message);
+    this.errorUri = errorUri;
+    this.name = this.constructor.name;
+  }
+  toResponseObject() {
+    const response2 = {
+      error: this.errorCode,
+      error_description: this.message
+    };
+    if (this.errorUri) {
+      response2.error_uri = this.errorUri;
+    }
+    return response2;
+  }
+  get errorCode() {
+    return this.constructor.errorCode;
+  }
+}
+
+class InvalidRequestError extends OAuthError {
+}
+InvalidRequestError.errorCode = "invalid_request";
+
+class InvalidClientError extends OAuthError {
+}
+InvalidClientError.errorCode = "invalid_client";
+
+class InvalidGrantError extends OAuthError {
+}
+InvalidGrantError.errorCode = "invalid_grant";
+
+class UnauthorizedClientError extends OAuthError {
+}
+UnauthorizedClientError.errorCode = "unauthorized_client";
+
+class UnsupportedGrantTypeError extends OAuthError {
+}
+UnsupportedGrantTypeError.errorCode = "unsupported_grant_type";
+
+class InvalidScopeError extends OAuthError {
+}
+InvalidScopeError.errorCode = "invalid_scope";
+
+class AccessDeniedError extends OAuthError {
+}
+AccessDeniedError.errorCode = "access_denied";
+
+class ServerError extends OAuthError {
+}
+ServerError.errorCode = "server_error";
+
+class TemporarilyUnavailableError extends OAuthError {
+}
+TemporarilyUnavailableError.errorCode = "temporarily_unavailable";
+
+class UnsupportedResponseTypeError extends OAuthError {
+}
+UnsupportedResponseTypeError.errorCode = "unsupported_response_type";
+
+class UnsupportedTokenTypeError extends OAuthError {
+}
+UnsupportedTokenTypeError.errorCode = "unsupported_token_type";
+
+class InvalidTokenError extends OAuthError {
+}
+InvalidTokenError.errorCode = "invalid_token";
+
+class MethodNotAllowedError extends OAuthError {
+}
+MethodNotAllowedError.errorCode = "method_not_allowed";
+
+class TooManyRequestsError extends OAuthError {
+}
+TooManyRequestsError.errorCode = "too_many_requests";
+
+class InvalidClientMetadataError extends OAuthError {
+}
+InvalidClientMetadataError.errorCode = "invalid_client_metadata";
+
+class InsufficientScopeError extends OAuthError {
+}
+InsufficientScopeError.errorCode = "insufficient_scope";
+
+class InvalidTargetError extends OAuthError {
+}
+InvalidTargetError.errorCode = "invalid_target";
+var OAUTH_ERRORS = {
+  [InvalidRequestError.errorCode]: InvalidRequestError,
+  [InvalidClientError.errorCode]: InvalidClientError,
+  [InvalidGrantError.errorCode]: InvalidGrantError,
+  [UnauthorizedClientError.errorCode]: UnauthorizedClientError,
+  [UnsupportedGrantTypeError.errorCode]: UnsupportedGrantTypeError,
+  [InvalidScopeError.errorCode]: InvalidScopeError,
+  [AccessDeniedError.errorCode]: AccessDeniedError,
+  [ServerError.errorCode]: ServerError,
+  [TemporarilyUnavailableError.errorCode]: TemporarilyUnavailableError,
+  [UnsupportedResponseTypeError.errorCode]: UnsupportedResponseTypeError,
+  [UnsupportedTokenTypeError.errorCode]: UnsupportedTokenTypeError,
+  [InvalidTokenError.errorCode]: InvalidTokenError,
+  [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
+  [TooManyRequestsError.errorCode]: TooManyRequestsError,
+  [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
+  [InsufficientScopeError.errorCode]: InsufficientScopeError,
+  [InvalidTargetError.errorCode]: InvalidTargetError
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/auth.js
+class UnauthorizedError extends Error {
+  constructor(message) {
+    super(message ?? "Unauthorized");
+  }
+}
+function isClientAuthMethod(method) {
+  return ["client_secret_basic", "client_secret_post", "none"].includes(method);
+}
+var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
+var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
+function selectClientAuthMethod(clientInformation, supportedMethods) {
+  const hasClientSecret = clientInformation.client_secret !== undefined;
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_post" : "none";
+  }
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && supportedMethods.includes(clientInformation.token_endpoint_auth_method)) {
+    return clientInformation.token_endpoint_auth_method;
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
+    return "client_secret_basic";
+  }
+  if (hasClientSecret && supportedMethods.includes("client_secret_post")) {
+    return "client_secret_post";
+  }
+  if (supportedMethods.includes("none")) {
+    return "none";
+  }
+  return hasClientSecret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, clientInformation, headers, params) {
+  const { client_id, client_secret } = clientInformation;
+  switch (method) {
+    case "client_secret_basic":
+      applyBasicAuth(client_id, client_secret, headers);
+      return;
+    case "client_secret_post":
+      applyPostAuth(client_id, client_secret, params);
+      return;
+    case "none":
+      applyPublicAuth(client_id, params);
+      return;
+    default:
+      throw new Error(`Unsupported client authentication method: ${method}`);
+  }
+}
+function applyBasicAuth(clientId, clientSecret, headers) {
+  if (!clientSecret) {
+    throw new Error("client_secret_basic authentication requires a client_secret");
+  }
+  const credentials = btoa(`${clientId}:${clientSecret}`);
+  headers.set("Authorization", `Basic ${credentials}`);
+}
+function applyPostAuth(clientId, clientSecret, params) {
+  params.set("client_id", clientId);
+  if (clientSecret) {
+    params.set("client_secret", clientSecret);
+  }
+}
+function applyPublicAuth(clientId, params) {
+  params.set("client_id", clientId);
+}
+async function parseErrorResponse(input) {
+  const statusCode = input instanceof Response ? input.status : undefined;
+  const body = input instanceof Response ? await input.text() : input;
+  try {
+    const result = OAuthErrorResponseSchema.parse(JSON.parse(body));
+    const { error: error45, error_description, error_uri } = result;
+    const errorClass = OAUTH_ERRORS[error45] || ServerError;
+    return new errorClass(error_description || "", error_uri);
+  } catch (error45) {
+    const errorMessage = `${statusCode ? `HTTP ${statusCode}: ` : ""}Invalid OAuth error response: ${error45}. Raw body: ${body}`;
+    return new ServerError(errorMessage);
+  }
+}
+async function auth(provider, options) {
+  try {
+    return await authInternal(provider, options);
+  } catch (error45) {
+    if (error45 instanceof InvalidClientError || error45 instanceof UnauthorizedClientError) {
+      await provider.invalidateCredentials?.("all");
+      return await authInternal(provider, options);
+    } else if (error45 instanceof InvalidGrantError) {
+      await provider.invalidateCredentials?.("tokens");
+      return await authInternal(provider, options);
+    }
+    throw error45;
+  }
+}
+async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {}
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = new URL("/", serverUrl);
+  }
+  const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
+    fetchFn
+  });
+  let clientInformation = await Promise.resolve(provider.clientInformation());
+  if (!clientInformation) {
+    if (authorizationCode !== undefined) {
+      throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+    }
+    const supportsUrlBasedClientId = metadata?.client_id_metadata_document_supported === true;
+    const clientMetadataUrl = provider.clientMetadataUrl;
+    if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) {
+      throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
+    }
+    const shouldUseUrlBasedClientId = supportsUrlBasedClientId && clientMetadataUrl;
+    if (shouldUseUrlBasedClientId) {
+      clientInformation = {
+        client_id: clientMetadataUrl
+      };
+      await provider.saveClientInformation?.(clientInformation);
+    } else {
+      if (!provider.saveClientInformation) {
+        throw new Error("OAuth client information must be saveable for dynamic registration");
+      }
+      const fullInformation = await registerClient(authorizationServerUrl, {
+        metadata,
+        clientMetadata: provider.clientMetadata,
+        fetchFn
+      });
+      await provider.saveClientInformation(fullInformation);
+      clientInformation = fullInformation;
+    }
+  }
+  const nonInteractiveFlow = !provider.redirectUrl;
+  if (authorizationCode !== undefined || nonInteractiveFlow) {
+    const tokens2 = await fetchToken(provider, authorizationServerUrl, {
+      metadata,
+      resource,
+      authorizationCode,
+      fetchFn
+    });
+    await provider.saveTokens(tokens2);
+    return "AUTHORIZED";
+  }
+  const tokens = await provider.tokens();
+  if (tokens?.refresh_token) {
+    try {
+      const newTokens = await refreshAuthorization(authorizationServerUrl, {
+        metadata,
+        clientInformation,
+        refreshToken: tokens.refresh_token,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
+        fetchFn
+      });
+      await provider.saveTokens(newTokens);
+      return "AUTHORIZED";
+    } catch (error45) {
+      if (!(error45 instanceof OAuthError) || error45 instanceof ServerError) {} else {
+        throw error45;
+      }
+    }
+  }
+  const state2 = provider.state ? await provider.state() : undefined;
+  const { authorizationUrl, codeVerifier } = await startAuthorization(authorizationServerUrl, {
+    metadata,
+    clientInformation,
+    state: state2,
+    redirectUrl: provider.redirectUrl,
+    scope: scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope,
+    resource
+  });
+  await provider.saveCodeVerifier(codeVerifier);
+  await provider.redirectToAuthorization(authorizationUrl);
+  return "REDIRECT";
+}
+function isHttpsUrl(value) {
+  if (!value)
+    return false;
+  try {
+    const url2 = new URL(value);
+    return url2.protocol === "https:" && url2.pathname !== "/";
+  } catch {
+    return false;
+  }
+}
+async function selectResourceURL(serverUrl, provider, resourceMetadata) {
+  const defaultResource = resourceUrlFromServerUrl(serverUrl);
+  if (provider.validateResourceURL) {
+    return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
+  }
+  if (!resourceMetadata) {
+    return;
+  }
+  if (!checkResourceAllowed({ requestedResource: defaultResource, configuredResource: resourceMetadata.resource })) {
+    throw new Error(`Protected resource ${resourceMetadata.resource} does not match expected ${defaultResource} (or origin)`);
+  }
+  return new URL(resourceMetadata.resource);
+}
+function extractWWWAuthenticateParams(res) {
+  const authenticateHeader = res.headers.get("WWW-Authenticate");
+  if (!authenticateHeader) {
+    return {};
+  }
+  const [type2, scheme] = authenticateHeader.split(" ");
+  if (type2.toLowerCase() !== "bearer" || !scheme) {
+    return {};
+  }
+  const resourceMetadataMatch = extractFieldFromWwwAuth(res, "resource_metadata") || undefined;
+  let resourceMetadataUrl;
+  if (resourceMetadataMatch) {
+    try {
+      resourceMetadataUrl = new URL(resourceMetadataMatch);
+    } catch {}
+  }
+  const scope = extractFieldFromWwwAuth(res, "scope") || undefined;
+  const error45 = extractFieldFromWwwAuth(res, "error") || undefined;
+  return {
+    resourceMetadataUrl,
+    scope,
+    error: error45
+  };
+}
+function extractFieldFromWwwAuth(response2, fieldName) {
+  const wwwAuthHeader = response2.headers.get("WWW-Authenticate");
+  if (!wwwAuthHeader) {
+    return null;
+  }
+  const pattern = new RegExp(`${fieldName}=(?:"([^"]+)"|([^\\s,]+))`);
+  const match = wwwAuthHeader.match(pattern);
+  if (match) {
+    return match[1] || match[2];
+  }
+  return null;
+}
+async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
+  const response2 = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
+    protocolVersion: opts?.protocolVersion,
+    metadataUrl: opts?.resourceMetadataUrl
+  });
+  if (!response2 || response2.status === 404) {
+    await response2?.body?.cancel();
+    throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
+  }
+  if (!response2.ok) {
+    await response2.body?.cancel();
+    throw new Error(`HTTP ${response2.status} trying to load well-known OAuth protected resource metadata.`);
+  }
+  return OAuthProtectedResourceMetadataSchema.parse(await response2.json());
+}
+async function fetchWithCorsRetry(url2, headers, fetchFn = fetch) {
+  try {
+    return await fetchFn(url2, { headers });
+  } catch (error45) {
+    if (error45 instanceof TypeError) {
+      if (headers) {
+        return fetchWithCorsRetry(url2, undefined, fetchFn);
+      } else {
+        return;
+      }
+    }
+    throw error45;
+  }
+}
+function buildWellKnownPath(wellKnownPrefix, pathname = "", options = {}) {
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  return options.prependPathname ? `${pathname}/.well-known/${wellKnownPrefix}` : `/.well-known/${wellKnownPrefix}${pathname}`;
+}
+async function tryMetadataDiscovery(url2, protocolVersion, fetchFn = fetch) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion
+  };
+  return await fetchWithCorsRetry(url2, headers, fetchFn);
+}
+function shouldAttemptFallback(response2, pathname) {
+  return !response2 || response2.status >= 400 && response2.status < 500 && pathname !== "/";
+}
+async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
+  const issuer = new URL(serverUrl);
+  const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
+  let url2;
+  if (opts?.metadataUrl) {
+    url2 = new URL(opts.metadataUrl);
+  } else {
+    const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
+    url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
+    url2.search = issuer.search;
+  }
+  let response2 = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
+  if (!opts?.metadataUrl && shouldAttemptFallback(response2, issuer.pathname)) {
+    const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
+    response2 = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
+  }
+  return response2;
+}
+function buildDiscoveryUrls(authorizationServerUrl) {
+  const url2 = typeof authorizationServerUrl === "string" ? new URL(authorizationServerUrl) : authorizationServerUrl;
+  const hasPath = url2.pathname !== "/";
+  const urlsToTry = [];
+  if (!hasPath) {
+    urlsToTry.push({
+      url: new URL("/.well-known/oauth-authorization-server", url2.origin),
+      type: "oauth"
+    });
+    urlsToTry.push({
+      url: new URL(`/.well-known/openid-configuration`, url2.origin),
+      type: "oidc"
+    });
+    return urlsToTry;
+  }
+  let pathname = url2.pathname;
+  if (pathname.endsWith("/")) {
+    pathname = pathname.slice(0, -1);
+  }
+  urlsToTry.push({
+    url: new URL(`/.well-known/oauth-authorization-server${pathname}`, url2.origin),
+    type: "oauth"
+  });
+  urlsToTry.push({
+    url: new URL(`/.well-known/openid-configuration${pathname}`, url2.origin),
+    type: "oidc"
+  });
+  urlsToTry.push({
+    url: new URL(`${pathname}/.well-known/openid-configuration`, url2.origin),
+    type: "oidc"
+  });
+  return urlsToTry;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
+  const headers = {
+    "MCP-Protocol-Version": protocolVersion,
+    Accept: "application/json"
+  };
+  const urlsToTry = buildDiscoveryUrls(authorizationServerUrl);
+  for (const { url: endpointUrl, type: type2 } of urlsToTry) {
+    const response2 = await fetchWithCorsRetry(endpointUrl, headers, fetchFn);
+    if (!response2) {
+      continue;
+    }
+    if (!response2.ok) {
+      await response2.body?.cancel();
+      if (response2.status >= 400 && response2.status < 500) {
+        continue;
+      }
+      throw new Error(`HTTP ${response2.status} trying to load ${type2 === "oauth" ? "OAuth" : "OpenID provider"} metadata from ${endpointUrl}`);
+    }
+    if (type2 === "oauth") {
+      return OAuthMetadataSchema.parse(await response2.json());
+    } else {
+      return OpenIdProviderDiscoveryMetadataSchema.parse(await response2.json());
+    }
+  }
+  return;
+}
+async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state: state2, resource }) {
+  let authorizationUrl;
+  if (metadata) {
+    authorizationUrl = new URL(metadata.authorization_endpoint);
+    if (!metadata.response_types_supported.includes(AUTHORIZATION_CODE_RESPONSE_TYPE)) {
+      throw new Error(`Incompatible auth server: does not support response type ${AUTHORIZATION_CODE_RESPONSE_TYPE}`);
+    }
+    if (metadata.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes(AUTHORIZATION_CODE_CHALLENGE_METHOD)) {
+      throw new Error(`Incompatible auth server: does not support code challenge method ${AUTHORIZATION_CODE_CHALLENGE_METHOD}`);
+    }
+  } else {
+    authorizationUrl = new URL("/authorize", authorizationServerUrl);
+  }
+  const challenge = await pkceChallenge();
+  const codeVerifier = challenge.code_verifier;
+  const codeChallenge = challenge.code_challenge;
+  authorizationUrl.searchParams.set("response_type", AUTHORIZATION_CODE_RESPONSE_TYPE);
+  authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+  authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+  authorizationUrl.searchParams.set("code_challenge_method", AUTHORIZATION_CODE_CHALLENGE_METHOD);
+  authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+  if (state2) {
+    authorizationUrl.searchParams.set("state", state2);
+  }
+  if (scope) {
+    authorizationUrl.searchParams.set("scope", scope);
+  }
+  if (scope?.includes("offline_access")) {
+    authorizationUrl.searchParams.append("prompt", "consent");
+  }
+  if (resource) {
+    authorizationUrl.searchParams.set("resource", resource.href);
+  }
+  return { authorizationUrl, codeVerifier };
+}
+function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+  return new URLSearchParams({
+    grant_type: "authorization_code",
+    code: authorizationCode,
+    code_verifier: codeVerifier,
+    redirect_uri: String(redirectUri)
+  });
+}
+async function executeTokenRequest(authorizationServerUrl, { metadata, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+  const tokenUrl = metadata?.token_endpoint ? new URL(metadata.token_endpoint) : new URL("/token", authorizationServerUrl);
+  const headers = new Headers({
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  });
+  if (resource) {
+    tokenRequestParams.set("resource", resource.href);
+  }
+  if (addClientAuthentication) {
+    await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata);
+  } else if (clientInformation) {
+    const supportedMethods = metadata?.token_endpoint_auth_methods_supported ?? [];
+    const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
+    applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams);
+  }
+  const response2 = await (fetchFn ?? fetch)(tokenUrl, {
+    method: "POST",
+    headers,
+    body: tokenRequestParams
+  });
+  if (!response2.ok) {
+    throw await parseErrorResponse(response2);
+  }
+  return OAuthTokensSchema.parse(await response2.json());
+}
+async function refreshAuthorization(authorizationServerUrl, { metadata, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+  const tokenRequestParams = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken
+  });
+  const tokens = await executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation,
+    addClientAuthentication,
+    resource,
+    fetchFn
+  });
+  return { refresh_token: refreshToken, ...tokens };
+}
+async function fetchToken(provider, authorizationServerUrl, { metadata, resource, authorizationCode, fetchFn } = {}) {
+  const scope = provider.clientMetadata.scope;
+  let tokenRequestParams;
+  if (provider.prepareTokenRequest) {
+    tokenRequestParams = await provider.prepareTokenRequest(scope);
+  }
+  if (!tokenRequestParams) {
+    if (!authorizationCode) {
+      throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+    }
+    if (!provider.redirectUrl) {
+      throw new Error("redirectUrl is required for authorization_code flow");
+    }
+    const codeVerifier = await provider.codeVerifier();
+    tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl);
+  }
+  const clientInformation = await provider.clientInformation();
+  return executeTokenRequest(authorizationServerUrl, {
+    metadata,
+    tokenRequestParams,
+    clientInformation: clientInformation ?? undefined,
+    addClientAuthentication: provider.addClientAuthentication,
+    resource,
+    fetchFn
+  });
+}
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, fetchFn }) {
+  let registrationUrl;
+  if (metadata) {
+    if (!metadata.registration_endpoint) {
+      throw new Error("Incompatible auth server: does not support dynamic client registration");
+    }
+    registrationUrl = new URL(metadata.registration_endpoint);
+  } else {
+    registrationUrl = new URL("/register", authorizationServerUrl);
+  }
+  const response2 = await (fetchFn ?? fetch)(registrationUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(clientMetadata)
+  });
+  if (!response2.ok) {
+    throw await parseErrorResponse(response2);
+  }
+  return OAuthClientInformationFullSchema.parse(await response2.json());
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/client/sse.js
+class SseError extends Error {
+  constructor(code, message, event) {
+    super(`SSE error: ${message}`);
+    this.code = code;
+    this.event = event;
+  }
+}
+
+class SSEClientTransport {
+  constructor(url2, opts) {
+    this._url = url2;
+    this._resourceMetadataUrl = undefined;
+    this._scope = undefined;
+    this._eventSourceInit = opts?.eventSourceInit;
+    this._requestInit = opts?.requestInit;
+    this._authProvider = opts?.authProvider;
+    this._fetch = opts?.fetch;
+    this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+  }
+  async _authThenStart() {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    let result;
+    try {
+      result = await auth(this._authProvider, {
+        serverUrl: this._url,
+        resourceMetadataUrl: this._resourceMetadataUrl,
+        scope: this._scope,
+        fetchFn: this._fetchWithInit
+      });
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError;
+    }
+    return await this._startOrAuth();
+  }
+  async _commonHeaders() {
+    const headers = {};
+    if (this._authProvider) {
+      const tokens = await this._authProvider.tokens();
+      if (tokens) {
+        headers["Authorization"] = `Bearer ${tokens.access_token}`;
+      }
+    }
+    if (this._protocolVersion) {
+      headers["mcp-protocol-version"] = this._protocolVersion;
+    }
+    const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+    return new Headers({
+      ...headers,
+      ...extraHeaders
+    });
+  }
+  _startOrAuth() {
+    const fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
+    return new Promise((resolve8, reject) => {
+      this._eventSource = new EventSource(this._url.href, {
+        ...this._eventSourceInit,
+        fetch: async (url2, init) => {
+          const headers = await this._commonHeaders();
+          headers.set("Accept", "text/event-stream");
+          const response2 = await fetchImpl(url2, {
+            ...init,
+            headers
+          });
+          if (response2.status === 401 && response2.headers.has("www-authenticate")) {
+            const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response2);
+            this._resourceMetadataUrl = resourceMetadataUrl;
+            this._scope = scope;
+          }
+          return response2;
+        }
+      });
+      this._abortController = new AbortController;
+      this._eventSource.onerror = (event) => {
+        if (event.code === 401 && this._authProvider) {
+          this._authThenStart().then(resolve8, reject);
+          return;
+        }
+        const error45 = new SseError(event.code, event.message, event);
+        reject(error45);
+        this.onerror?.(error45);
+      };
+      this._eventSource.onopen = () => {};
+      this._eventSource.addEventListener("endpoint", (event) => {
+        const messageEvent = event;
+        try {
+          this._endpoint = new URL(messageEvent.data, this._url);
+          if (this._endpoint.origin !== this._url.origin) {
+            throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
+          }
+        } catch (error45) {
+          reject(error45);
+          this.onerror?.(error45);
+          this.close();
+          return;
+        }
+        resolve8();
+      });
+      this._eventSource.onmessage = (event) => {
+        const messageEvent = event;
+        let message;
+        try {
+          message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
+        } catch (error45) {
+          this.onerror?.(error45);
+          return;
+        }
+        this.onmessage?.(message);
+      };
+    });
+  }
+  async start() {
+    if (this._eventSource) {
+      throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+    }
+    return await this._startOrAuth();
+  }
+  async finishAuth(authorizationCode) {
+    if (!this._authProvider) {
+      throw new UnauthorizedError("No auth provider");
+    }
+    const result = await auth(this._authProvider, {
+      serverUrl: this._url,
+      authorizationCode,
+      resourceMetadataUrl: this._resourceMetadataUrl,
+      scope: this._scope,
+      fetchFn: this._fetchWithInit
+    });
+    if (result !== "AUTHORIZED") {
+      throw new UnauthorizedError("Failed to authorize");
+    }
+  }
+  async close() {
+    this._abortController?.abort();
+    this._eventSource?.close();
+    this.onclose?.();
+  }
+  async send(message) {
+    if (!this._endpoint) {
+      throw new Error("Not connected");
+    }
+    try {
+      const headers = await this._commonHeaders();
+      headers.set("content-type", "application/json");
+      const init = {
+        ...this._requestInit,
+        method: "POST",
+        headers,
+        body: JSON.stringify(message),
+        signal: this._abortController?.signal
+      };
+      const response2 = await (this._fetch ?? fetch)(this._endpoint, init);
+      if (!response2.ok) {
+        const text = await response2.text().catch(() => null);
+        if (response2.status === 401 && this._authProvider) {
+          const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(response2);
+          this._resourceMetadataUrl = resourceMetadataUrl;
+          this._scope = scope;
+          const result = await auth(this._authProvider, {
+            serverUrl: this._url,
+            resourceMetadataUrl: this._resourceMetadataUrl,
+            scope: this._scope,
+            fetchFn: this._fetchWithInit
+          });
+          if (result !== "AUTHORIZED") {
+            throw new UnauthorizedError;
+          }
+          return this.send(message);
+        }
+        throw new Error(`Error POSTing to endpoint (HTTP ${response2.status}): ${text}`);
+      }
+      await response2.body?.cancel();
+    } catch (error45) {
+      this.onerror?.(error45);
+      throw error45;
+    }
+  }
+  setProtocolVersion(version2) {
+    this._protocolVersion = version2;
+  }
+}
+
+// src/features/skill-mcp-manager/env-cleaner.ts
+var EXCLUDED_ENV_PATTERNS = [
+  /^NPM_CONFIG_/i,
+  /^npm_config_/,
+  /^YARN_/,
+  /^PNPM_/,
+  /^NO_UPDATE_NOTIFIER$/
+];
+function createCleanMcpEnvironment(customEnv = {}) {
+  const cleanEnv = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value === undefined)
+      continue;
+    const shouldExclude = EXCLUDED_ENV_PATTERNS.some((pattern) => pattern.test(key));
+    if (!shouldExclude) {
+      cleanEnv[key] = value;
+    }
+  }
+  Object.assign(cleanEnv, customEnv);
+  return cleanEnv;
+}
+
+// src/features/knowledge-provider/mcp-manager.ts
+class KnowledgeMcpManager {
+  clients = new Map;
+  pendingConnections = new Map;
+  serverConfigs = new Map;
+  cleanupRegistered = false;
+  cleanupInterval = null;
+  IDLE_TIMEOUT = 5 * 60 * 1000;
+  registerServer(config3) {
+    this.serverConfigs.set(config3.name, config3);
+  }
+  async unregisterServer(serverName) {
+    this.serverConfigs.delete(serverName);
+    await this.disconnectServer(serverName);
+  }
+  async isServerAvailable(serverName) {
+    const config3 = this.serverConfigs.get(serverName);
+    if (!config3) {
+      return false;
+    }
+    try {
+      const client2 = await this.getOrCreateClient(serverName);
+      return client2 !== null;
+    } catch {
+      return false;
+    }
+  }
+  async invoke(serverName, toolName, args) {
+    const client2 = await this.getOrCreateClient(serverName);
+    if (!client2) {
+      throw new Error(`MCP server "${serverName}" is not available`);
+    }
+    const result = await client2.callTool({ name: toolName, arguments: args });
+    return result.content;
+  }
+  async getOrCreateClient(serverName) {
+    const existing = this.clients.get(serverName);
+    if (existing) {
+      existing.lastUsedAt = Date.now();
+      return existing.client;
+    }
+    const pending = this.pendingConnections.get(serverName);
+    if (pending) {
+      return pending;
+    }
+    const config3 = this.serverConfigs.get(serverName);
+    if (!config3) {
+      return null;
+    }
+    const expandedConfig = expandEnvVarsInObject(config3);
+    const connectionPromise = this.createClient(serverName, expandedConfig);
+    this.pendingConnections.set(serverName, connectionPromise);
+    try {
+      const client2 = await connectionPromise;
+      return client2;
+    } finally {
+      this.pendingConnections.delete(serverName);
+    }
+  }
+  async createClient(serverName, config3) {
+    const transportType = config3.transport ?? "stdio";
+    this.registerProcessCleanup();
+    const client2 = new Client({ name: `knowledge-mcp-${serverName}`, version: "1.0.0" }, { capabilities: {} });
+    let transport;
+    if (transportType === "sse") {
+      transport = await this.createSseTransport(serverName, config3, client2);
+    } else {
+      transport = await this.createStdioTransport(serverName, config3, client2);
+    }
+    this.clients.set(serverName, {
+      client: client2,
+      transport,
+      transportType,
+      serverName,
+      lastUsedAt: Date.now()
+    });
+    this.startCleanupTimer();
+    return client2;
+  }
+  async createStdioTransport(serverName, config3, client2) {
+    if (!config3.command) {
+      throw new Error(`MCP server "${serverName}" is missing required 'command' field for stdio transport.
+
+` + `Example:
+` + `  {
+` + `    "name": "${serverName}",
+` + `    "command": "npx",
+` + `    "args": ["-y", "@some/mcp-server"],
+` + `    "searchTool": "search"
+` + `  }`);
+    }
+    const command = config3.command;
+    const args = config3.args || [];
+    const mergedEnv = createCleanMcpEnvironment(config3.env);
+    const transport = new StdioClientTransport({
+      command,
+      args,
+      env: mergedEnv,
+      stderr: "ignore"
+    });
+    try {
+      await client2.connect(transport);
+    } catch (error45) {
+      try {
+        await transport.close();
+      } catch {}
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      throw new Error(`Failed to connect to MCP server "${serverName}" via stdio.
+
+` + `Command: ${command} ${args.join(" ")}
+` + `Reason: ${errorMessage}
+
+` + `Hints:
+` + `  - Ensure the command is installed and available in PATH
+` + `  - Check if the MCP server package exists
+` + `  - Verify the args are correct for this server`);
+    }
+    return transport;
+  }
+  async createSseTransport(serverName, config3, client2) {
+    if (!config3.url) {
+      throw new Error(`MCP server "${serverName}" is missing required 'url' field for SSE transport.
+
+` + `Example:
+` + `  {
+` + `    "name": "${serverName}",
+` + `    "transport": "sse",
+` + `    "url": "http://localhost:60062/sse",
+` + `    "searchTool": "search"
+` + `  }
+
+` + `Note: SSE servers must be started manually before connecting.`);
+    }
+    const transport = new SSEClientTransport(new URL(config3.url));
+    try {
+      await client2.connect(transport);
+    } catch (error45) {
+      try {
+        await transport.close();
+      } catch {}
+      const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+      throw new Error(`Failed to connect to MCP server "${serverName}" via SSE.
+
+` + `URL: ${config3.url}
+` + `Reason: ${errorMessage}
+
+` + `Hints:
+` + `  - Ensure the MCP server is running at ${config3.url}
+` + `  - SSE servers (like Dust CLI) must be started manually
+` + `  - Check if the port is correct (Dust uses dynamic ports)
+` + `  - Verify the URL ends with /sse if required by the server`);
+    }
+    return transport;
+  }
+  async disconnectServer(serverName) {
+    const managed = this.clients.get(serverName);
+    if (!managed) {
+      return;
+    }
+    this.clients.delete(serverName);
+    try {
+      await managed.client.close();
+    } catch {}
+    try {
+      await managed.transport.close();
+    } catch {}
+  }
+  async disconnectAll() {
+    this.stopCleanupTimer();
+    const clients = Array.from(this.clients.values());
+    this.clients.clear();
+    for (const managed of clients) {
+      try {
+        await managed.client.close();
+      } catch {}
+      try {
+        await managed.transport.close();
+      } catch {}
+    }
+  }
+  registerProcessCleanup() {
+    if (this.cleanupRegistered)
+      return;
+    this.cleanupRegistered = true;
+    const cleanup = async () => {
+      for (const [, managed] of this.clients) {
+        try {
+          await managed.client.close();
+        } catch {}
+        try {
+          await managed.transport.close();
+        } catch {}
+      }
+      this.clients.clear();
+      this.pendingConnections.clear();
+    };
+    process.on("SIGINT", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      await cleanup();
+      process.exit(0);
+    });
+    if (process.platform === "win32") {
+      process.on("SIGBREAK", async () => {
+        await cleanup();
+        process.exit(0);
+      });
+    }
+  }
+  startCleanupTimer() {
+    if (this.cleanupInterval)
+      return;
+    this.cleanupInterval = setInterval(() => {
+      this.cleanupIdleClients();
+    }, 60000);
+    this.cleanupInterval.unref();
+  }
+  stopCleanupTimer() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  async cleanupIdleClients() {
+    const now = Date.now();
+    for (const [serverName, managed] of this.clients) {
+      if (now - managed.lastUsedAt > this.IDLE_TIMEOUT) {
+        this.clients.delete(serverName);
+        try {
+          await managed.client.close();
+        } catch {}
+        try {
+          await managed.transport.close();
+        } catch {}
+      }
+    }
+  }
+  getRegisteredServers() {
+    return Array.from(this.serverConfigs.keys());
+  }
+  getConnectedServers() {
+    return Array.from(this.clients.keys());
+  }
+  isConnected(serverName) {
+    return this.clients.has(serverName);
+  }
+}
+// src/features/background-agent/manager.ts
+import { existsSync as existsSync48, readdirSync as readdirSync17 } from "fs";
+import { join as join61 } from "path";
+var TASK_TTL_MS = 30 * 60 * 1000;
+function getMessageDir11(sessionID) {
+  if (!existsSync48(MESSAGE_STORAGE))
+    return null;
+  const directPath = join61(MESSAGE_STORAGE, sessionID);
+  if (existsSync48(directPath))
+    return directPath;
+  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+    const sessionPath = join61(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync48(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
+
+class BackgroundManager {
+  tasks;
+  notifications;
+  client;
+  directory;
+  pollingInterval;
+  constructor(ctx) {
+    this.tasks = new Map;
+    this.notifications = new Map;
+    this.client = ctx.client;
+    this.directory = ctx.directory;
+  }
+  async launch(input) {
+    if (!input.agent || input.agent.trim() === "") {
+      throw new Error("Agent parameter is required");
+    }
+    const createResult = await this.client.session.create({
+      body: {
+        parentID: input.parentSessionID,
+        title: `Background: ${input.description}`
+      }
+    });
+    if (createResult.error) {
+      throw new Error(`Failed to create background session: ${createResult.error}`);
+    }
+    const sessionID = createResult.data.id;
+    subagentSessions.add(sessionID);
+    const task = {
+      id: `bg_${crypto.randomUUID().slice(0, 8)}`,
+      sessionID,
+      parentSessionID: input.parentSessionID,
+      parentMessageID: input.parentMessageID,
+      description: input.description,
+      prompt: input.prompt,
+      agent: input.agent,
+      status: "running",
+      startedAt: new Date,
+      progress: {
+        toolCalls: 0,
+        lastUpdate: new Date
+      },
+      parentModel: input.parentModel
+    };
+    this.tasks.set(task.id, task);
+    this.startPolling();
+    log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent });
+    this.client.session.promptAsync({
+      path: { id: sessionID },
+      body: {
+        agent: input.agent,
+        tools: {
+          task: false,
+          background_task: false
+        },
+        parts: [{ type: "text", text: input.prompt }]
+      }
+    }).catch((error45) => {
+      log("[background-agent] promptAsync error:", error45);
+      const existingTask = this.findBySession(sessionID);
+      if (existingTask) {
+        existingTask.status = "error";
+        const errorMessage = error45 instanceof Error ? error45.message : String(error45);
+        if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
+          existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`;
+        } else {
+          existingTask.error = errorMessage;
+        }
+        existingTask.completedAt = new Date;
+        this.markForNotification(existingTask);
+        this.notifyParentSession(existingTask);
+      }
+    });
+    return task;
+  }
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  getTasksByParentSession(sessionID) {
+    const result = [];
+    for (const task of this.tasks.values()) {
+      if (task.parentSessionID === sessionID) {
+        result.push(task);
+      }
+    }
+    return result;
+  }
+  getAllDescendantTasks(sessionID) {
+    const result = [];
+    const directChildren = this.getTasksByParentSession(sessionID);
+    for (const child of directChildren) {
+      result.push(child);
+      const descendants = this.getAllDescendantTasks(child.sessionID);
+      result.push(...descendants);
+    }
+    return result;
+  }
+  findBySession(sessionID) {
+    for (const task of this.tasks.values()) {
+      if (task.sessionID === sessionID) {
+        return task;
+      }
+    }
+    return;
   }
-  isToolTask(toolName) {
-    if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+  async checkSessionTodos(sessionID) {
+    try {
+      const response2 = await this.client.session.todo({
+        path: { id: sessionID }
+      });
+      const todos = response2.data ?? response2;
+      if (!todos || todos.length === 0)
+        return false;
+      const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+      return incomplete.length > 0;
+    } catch {
       return false;
     }
-    return this._cachedKnownTaskTools.has(toolName);
   }
-  isToolTaskRequired(toolName) {
-    return this._cachedRequiredTaskTools.has(toolName);
-  }
-  cacheToolMetadata(tools4) {
-    this._cachedToolOutputValidators.clear();
-    this._cachedKnownTaskTools.clear();
-    this._cachedRequiredTaskTools.clear();
-    for (const tool3 of tools4) {
-      if (tool3.outputSchema) {
-        const toolValidator = this._jsonSchemaValidator.getValidator(tool3.outputSchema);
-        this._cachedToolOutputValidators.set(tool3.name, toolValidator);
-      }
-      const taskSupport = tool3.execution?.taskSupport;
-      if (taskSupport === "required" || taskSupport === "optional") {
-        this._cachedKnownTaskTools.add(tool3.name);
+  handleEvent(event) {
+    const props = event.properties;
+    if (event.type === "message.part.updated") {
+      if (!props || typeof props !== "object" || !("sessionID" in props))
+        return;
+      const partInfo = props;
+      const sessionID = partInfo?.sessionID;
+      if (!sessionID)
+        return;
+      const task = this.findBySession(sessionID);
+      if (!task)
+        return;
+      if (partInfo?.type === "tool" || partInfo?.tool) {
+        if (!task.progress) {
+          task.progress = {
+            toolCalls: 0,
+            lastUpdate: new Date
+          };
+        }
+        task.progress.toolCalls += 1;
+        task.progress.lastTool = partInfo.tool;
+        task.progress.lastUpdate = new Date;
       }
-      if (taskSupport === "required") {
-        this._cachedRequiredTaskTools.add(tool3.name);
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== "running")
+        return;
+      this.checkSessionTodos(sessionID).then((hasIncompleteTodos2) => {
+        if (hasIncompleteTodos2) {
+          log("[background-agent] Task has incomplete todos, waiting for todo-continuation:", task.id);
+          return;
+        }
+        task.status = "completed";
+        task.completedAt = new Date;
+        this.markForNotification(task);
+        this.notifyParentSession(task);
+        log("[background-agent] Task completed via session.idle event:", task.id);
+      });
+    }
+    if (event.type === "session.deleted") {
+      const info = props?.info;
+      if (!info || typeof info.id !== "string")
+        return;
+      const sessionID = info.id;
+      const task = this.findBySession(sessionID);
+      if (!task)
+        return;
+      if (task.status === "running") {
+        task.status = "cancelled";
+        task.completedAt = new Date;
+        task.error = "Session deleted";
       }
+      this.tasks.delete(task.id);
+      this.clearNotificationsForTask(task.id);
+      subagentSessions.delete(sessionID);
     }
   }
-  getToolOutputValidator(toolName) {
-    return this._cachedToolOutputValidators.get(toolName);
+  markForNotification(task) {
+    const queue = this.notifications.get(task.parentSessionID) ?? [];
+    queue.push(task);
+    this.notifications.set(task.parentSessionID, queue);
   }
-  async listTools(params, options) {
-    const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
-    this.cacheToolMetadata(result.tools);
-    return result;
+  getPendingNotifications(sessionID) {
+    return this.notifications.get(sessionID) ?? [];
   }
-  _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
-    const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
-    if (!parseResult.success) {
-      throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
-    }
-    if (typeof options.onChanged !== "function") {
-      throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
-    }
-    const { autoRefresh, debounceMs } = parseResult.data;
-    const { onChanged } = options;
-    const refresh = async () => {
-      if (!autoRefresh) {
-        onChanged(null, null);
-        return;
-      }
-      try {
-        const items = await fetcher();
-        onChanged(null, items);
-      } catch (e) {
-        const error45 = e instanceof Error ? e : new Error(String(e));
-        onChanged(error45, null);
-      }
-    };
-    const handler = () => {
-      if (debounceMs) {
-        const existingTimer = this._listChangedDebounceTimers.get(listType);
-        if (existingTimer) {
-          clearTimeout(existingTimer);
-        }
-        const timer = setTimeout(refresh, debounceMs);
-        this._listChangedDebounceTimers.set(listType, timer);
+  clearNotifications(sessionID) {
+    this.notifications.delete(sessionID);
+  }
+  clearNotificationsForTask(taskId) {
+    for (const [sessionID, tasks] of this.notifications.entries()) {
+      const filtered = tasks.filter((t) => t.id !== taskId);
+      if (filtered.length === 0) {
+        this.notifications.delete(sessionID);
       } else {
-        refresh();
+        this.notifications.set(sessionID, filtered);
       }
-    };
-    this.setNotificationHandler(notificationSchema, handler);
-  }
-  async sendRootsListChanged() {
-    return this.notification({ method: "notifications/roots/list_changed" });
+    }
   }
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
-var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import process2 from "process";
-import { PassThrough } from "stream";
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
-class ReadBuffer {
-  append(chunk) {
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  startPolling() {
+    if (this.pollingInterval)
+      return;
+    this.pollingInterval = setInterval(() => {
+      this.pollRunningTasks();
+    }, 2000);
+    this.pollingInterval.unref();
   }
-  readMessage() {
-    if (!this._buffer) {
-      return null;
-    }
-    const index = this._buffer.indexOf(`
-`);
-    if (index === -1) {
-      return null;
+  stopPolling() {
+    if (this.pollingInterval) {
+      clearInterval(this.pollingInterval);
+      this.pollingInterval = undefined;
     }
-    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
-    this._buffer = this._buffer.subarray(index + 1);
-    return deserializeMessage(line);
   }
-  clear() {
-    this._buffer = undefined;
+  cleanup() {
+    this.stopPolling();
+    this.tasks.clear();
+    this.notifications.clear();
   }
-}
-function deserializeMessage(line) {
-  return JSONRPCMessageSchema.parse(JSON.parse(line));
-}
-function serializeMessage(message) {
-  return JSON.stringify(message) + `
-`;
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
-var DEFAULT_INHERITED_ENV_VARS = process2.platform === "win32" ? [
-  "APPDATA",
-  "HOMEDRIVE",
-  "HOMEPATH",
-  "LOCALAPPDATA",
-  "PATH",
-  "PROCESSOR_ARCHITECTURE",
-  "SYSTEMDRIVE",
-  "SYSTEMROOT",
-  "TEMP",
-  "USERNAME",
-  "USERPROFILE",
-  "PROGRAMFILES"
-] : ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"];
-function getDefaultEnvironment() {
-  const env = {};
-  for (const key of DEFAULT_INHERITED_ENV_VARS) {
-    const value = process2.env[key];
-    if (value === undefined) {
-      continue;
+  notifyParentSession(task) {
+    const duration3 = this.formatDuration(task.startedAt, task.completedAt);
+    log("[background-agent] notifyParentSession called for task:", task.id);
+    const tuiClient = this.client;
+    if (tuiClient.tui?.showToast) {
+      tuiClient.tui.showToast({
+        body: {
+          title: "Background Task Completed",
+          message: `Task "${task.description}" finished in ${duration3}.`,
+          variant: "success",
+          duration: 5000
+        }
+      }).catch(() => {});
     }
-    if (value.startsWith("()")) {
-      continue;
+    const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished in ${duration3}. Use background_output with task_id="${task.id}" to get results.`;
+    log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
+    const taskId = task.id;
+    setTimeout(async () => {
+      try {
+        const messageDir = getMessageDir11(task.parentSessionID);
+        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+        const modelContext = task.parentModel ?? prevMessage?.model;
+        const modelField = modelContext?.providerID && modelContext?.modelID ? { providerID: modelContext.providerID, modelID: modelContext.modelID } : undefined;
+        await this.client.session.prompt({
+          path: { id: task.parentSessionID },
+          body: {
+            agent: prevMessage?.agent,
+            model: modelField,
+            parts: [{ type: "text", text: message }]
+          },
+          query: { directory: this.directory }
+        });
+        log("[background-agent] Successfully sent prompt to parent session:", { parentSessionID: task.parentSessionID });
+      } catch (error45) {
+        log("[background-agent] prompt failed:", String(error45));
+      } finally {
+        this.clearNotificationsForTask(taskId);
+        this.tasks.delete(taskId);
+        log("[background-agent] Removed completed task from memory:", taskId);
+      }
+    }, 200);
+  }
+  formatDuration(start, end) {
+    const duration3 = (end ?? new Date).getTime() - start.getTime();
+    const seconds = Math.floor(duration3 / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
     }
-    env[key] = value;
+    return `${seconds}s`;
   }
-  return env;
-}
-
-class StdioClientTransport {
-  constructor(server) {
-    this._readBuffer = new ReadBuffer;
-    this._stderrStream = null;
-    this._serverParams = server;
-    if (server.stderr === "pipe" || server.stderr === "overlapped") {
-      this._stderrStream = new PassThrough;
+  hasRunningTasks() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "running")
+        return true;
     }
+    return false;
   }
-  async start() {
-    if (this._process) {
-      throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+  pruneStaleTasksAndNotifications() {
+    const now = Date.now();
+    for (const [taskId, task] of this.tasks.entries()) {
+      const age = now - task.startedAt.getTime();
+      if (age > TASK_TTL_MS) {
+        log("[background-agent] Pruning stale task:", { taskId, age: Math.round(age / 1000) + "s" });
+        task.status = "error";
+        task.error = "Task timed out after 30 minutes";
+        task.completedAt = new Date;
+        this.clearNotificationsForTask(taskId);
+        this.tasks.delete(taskId);
+        subagentSessions.delete(task.sessionID);
+      }
     }
-    return new Promise((resolve8, reject) => {
-      this._process = import_cross_spawn.default(this._serverParams.command, this._serverParams.args ?? [], {
-        env: {
-          ...getDefaultEnvironment(),
-          ...this._serverParams.env
-        },
-        stdio: ["pipe", "pipe", this._serverParams.stderr ?? "inherit"],
-        shell: false,
-        windowsHide: process2.platform === "win32" && isElectron(),
-        cwd: this._serverParams.cwd
-      });
-      this._process.on("error", (error45) => {
-        reject(error45);
-        this.onerror?.(error45);
-      });
-      this._process.on("spawn", () => {
-        resolve8();
-      });
-      this._process.on("close", (_code) => {
-        this._process = undefined;
-        this.onclose?.();
-      });
-      this._process.stdin?.on("error", (error45) => {
-        this.onerror?.(error45);
-      });
-      this._process.stdout?.on("data", (chunk) => {
-        this._readBuffer.append(chunk);
-        this.processReadBuffer();
-      });
-      this._process.stdout?.on("error", (error45) => {
-        this.onerror?.(error45);
+    for (const [sessionID, notifications] of this.notifications.entries()) {
+      if (notifications.length === 0) {
+        this.notifications.delete(sessionID);
+        continue;
+      }
+      const validNotifications = notifications.filter((task) => {
+        const age = now - task.startedAt.getTime();
+        return age <= TASK_TTL_MS;
       });
-      if (this._stderrStream && this._process.stderr) {
-        this._process.stderr.pipe(this._stderrStream);
+      if (validNotifications.length === 0) {
+        this.notifications.delete(sessionID);
+      } else if (validNotifications.length !== notifications.length) {
+        this.notifications.set(sessionID, validNotifications);
       }
-    });
-  }
-  get stderr() {
-    if (this._stderrStream) {
-      return this._stderrStream;
     }
-    return this._process?.stderr ?? null;
-  }
-  get pid() {
-    return this._process?.pid ?? null;
   }
-  processReadBuffer() {
-    while (true) {
+  async pollRunningTasks() {
+    this.pruneStaleTasksAndNotifications();
+    const statusResult = await this.client.session.status();
+    const allStatuses = statusResult.data ?? {};
+    for (const task of this.tasks.values()) {
+      if (task.status !== "running")
+        continue;
       try {
-        const message = this._readBuffer.readMessage();
-        if (message === null) {
-          break;
+        const sessionStatus = allStatuses[task.sessionID];
+        if (!sessionStatus) {
+          log("[background-agent] Session not found in status:", task.sessionID);
+          continue;
         }
-        this.onmessage?.(message);
-      } catch (error45) {
-        this.onerror?.(error45);
-      }
-    }
-  }
-  async close() {
-    if (this._process) {
-      const processToClose = this._process;
-      this._process = undefined;
-      const closePromise = new Promise((resolve8) => {
-        processToClose.once("close", () => {
-          resolve8();
+        if (sessionStatus.type === "idle") {
+          const hasIncompleteTodos2 = await this.checkSessionTodos(task.sessionID);
+          if (hasIncompleteTodos2) {
+            log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
+            continue;
+          }
+          task.status = "completed";
+          task.completedAt = new Date;
+          this.markForNotification(task);
+          this.notifyParentSession(task);
+          log("[background-agent] Task completed via polling:", task.id);
+          continue;
+        }
+        const messagesResult = await this.client.session.messages({
+          path: { id: task.sessionID }
         });
-      });
-      try {
-        processToClose.stdin?.end();
-      } catch {}
-      await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2000).unref())]);
-      if (processToClose.exitCode === null) {
-        try {
-          processToClose.kill("SIGTERM");
-        } catch {}
-        await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2000).unref())]);
-      }
-      if (processToClose.exitCode === null) {
-        try {
-          processToClose.kill("SIGKILL");
-        } catch {}
+        if (!messagesResult.error && messagesResult.data) {
+          const messages = messagesResult.data;
+          const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
+          let toolCalls = 0;
+          let lastTool;
+          let lastMessage;
+          for (const msg of assistantMsgs) {
+            const parts = msg.parts ?? [];
+            for (const part of parts) {
+              if (part.type === "tool_use" || part.tool) {
+                toolCalls++;
+                lastTool = part.tool || part.name || "unknown";
+              }
+              if (part.type === "text" && part.text) {
+                lastMessage = part.text;
+              }
+            }
+          }
+          if (!task.progress) {
+            task.progress = { toolCalls: 0, lastUpdate: new Date };
+          }
+          task.progress.toolCalls = toolCalls;
+          task.progress.lastTool = lastTool;
+          task.progress.lastUpdate = new Date;
+          if (lastMessage) {
+            task.progress.lastMessage = lastMessage;
+            task.progress.lastMessageAt = new Date;
+          }
+        }
+      } catch (error45) {
+        log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
       }
     }
-    this._readBuffer.clear();
-  }
-  send(message) {
-    return new Promise((resolve8) => {
-      if (!this._process?.stdin) {
-        throw new Error("Not connected");
-      }
-      const json3 = serializeMessage(message);
-      if (this._process.stdin.write(json3)) {
-        resolve8();
-      } else {
-        this._process.stdin.once("drain", resolve8);
-      }
-    });
-  }
-}
-function isElectron() {
-  return "type" in process2;
-}
-
-// src/features/skill-mcp-manager/env-cleaner.ts
-var EXCLUDED_ENV_PATTERNS = [
-  /^NPM_CONFIG_/i,
-  /^npm_config_/,
-  /^YARN_/,
-  /^PNPM_/,
-  /^NO_UPDATE_NOTIFIER$/
-];
-function createCleanMcpEnvironment(customEnv = {}) {
-  const cleanEnv = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value === undefined)
-      continue;
-    const shouldExclude = EXCLUDED_ENV_PATTERNS.some((pattern) => pattern.test(key));
-    if (!shouldExclude) {
-      cleanEnv[key] = value;
+    if (!this.hasRunningTasks()) {
+      this.stopPolling();
     }
   }
-  Object.assign(cleanEnv, customEnv);
-  return cleanEnv;
 }
-
 // src/features/skill-mcp-manager/manager.ts
 class SkillMcpManager {
   clients = new Map;
@@ -47019,6 +49921,21 @@ var Mem0ConfigSchema = exports_external.object({
   autoRehydrate: exports_external.boolean().default(true),
   rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
 });
+var LettaConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  endpoint: exports_external.string().url().optional().describe("Letta server endpoint (default: http://localhost:8283)"),
+  apiKey: exports_external.string().optional().describe("Optional API key for cloud Letta (not needed for self-hosted)"),
+  userId: exports_external.string().optional(),
+  projectId: exports_external.string().optional(),
+  teamId: exports_external.string().optional(),
+  orgId: exports_external.string().optional(),
+  companyId: exports_external.string().optional(),
+  agentPrefix: exports_external.string().optional().describe("Agent name prefix (default: opencode)"),
+  llmModel: exports_external.string().optional().describe("LLM model for agent (e.g., openai/gpt-4.1)"),
+  embeddingModel: exports_external.string().optional().describe("Embedding model for semantic search"),
+  autoRehydrate: exports_external.boolean().default(true),
+  rehydrateLayers: exports_external.array(MemoryLayerSchema).default(["user", "project", "team"])
+});
 var CentralHubConfigSchema = exports_external.object({
   url: exports_external.string().url(),
   branch: exports_external.string().default("main"),
@@ -47058,11 +49975,17 @@ var OpenSpecConfigSchema = exports_external.object({
   ]),
   rootDir: exports_external.string().default(".opencode/openspec")
 });
+var MCPTransportTypeSchema = exports_external.enum(["stdio", "sse"]);
 var MCPKnowledgeProviderConfigSchema = exports_external.object({
   name: exports_external.string(),
-  searchTool: exports_external.string(),
-  getTool: exports_external.string().optional(),
-  config: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+  transport: MCPTransportTypeSchema.optional().describe("Transport type: 'stdio' (default) or 'sse'"),
+  command: exports_external.string().optional().describe("Command to start the MCP server (required for stdio transport)"),
+  args: exports_external.array(exports_external.string()).optional().describe("Arguments for the command (stdio transport)"),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional().describe("Environment variables (stdio transport)"),
+  url: exports_external.string().optional().describe("SSE endpoint URL (required for sse transport, e.g., 'http://localhost:60062/sse')"),
+  searchTool: exports_external.string().describe("MCP tool name for search operations"),
+  getTool: exports_external.string().optional().describe("MCP tool name for get-by-id operations"),
+  config: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe("Additional config passed to MCP tools")
 });
 var NotebookLMProviderConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
@@ -47116,6 +50039,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   skills: SkillsConfigSchema.optional(),
   ralph_loop: RalphLoopConfigSchema.optional(),
   mem0: Mem0ConfigSchema.optional(),
+  letta: LettaConfigSchema.optional(),
   knowledge_repo: KnowledgeRepoConfigSchema.optional(),
   knowledge_provider: KnowledgeProviderConfigSchema.optional(),
   openspec: OpenSpecConfigSchema.optional()
@@ -47152,6 +50076,8 @@ function mergeConfigs(base, override) {
     ...base,
     ...override,
     agents: deepMerge(base.agents, override.agents),
+    mem0: deepMerge(base.mem0, override.mem0),
+    letta: deepMerge(base.letta, override.letta),
     disabled_agents: [
       ...new Set([
         ...base.disabled_agents ?? [],
@@ -52734,6 +55660,62 @@ function createConfigHandler(deps) {
   };
 }
 // src/index.ts
+async function initializeKnowledgeProviderRegistry(pluginConfig, mem0Adapter) {
+  const config3 = pluginConfig.knowledge_provider;
+  const registry2 = new KnowledgeProviderRegistry({
+    defaultLimit: config3.search?.defaultLimit ?? 10,
+    defaultThreshold: config3.search?.defaultThreshold ?? 0.5,
+    mergeStrategy: config3.search?.mergeStrategy ?? "score",
+    providerPriority: config3.search?.providerPriority,
+    deduplicate: config3.search?.deduplicate ?? true
+  });
+  if (config3.providers?.local?.enabled !== false) {
+    const localProvider = new LocalKnowledgeProvider({
+      enabled: true,
+      rootDir: config3.providers?.local?.rootDir
+    });
+    await registry2.register(localProvider);
+  }
+  if (mem0Adapter && config3.providers?.mem0?.enabled !== false) {
+    const mem0Provider = new Mem0KnowledgeProvider({
+      enabled: true,
+      indexKnowledgeRepo: config3.providers?.mem0?.indexKnowledgeRepo ?? false,
+      searchLayers: config3.providers?.mem0?.searchLayers
+    }, {
+      enabled: true,
+      apiKey: pluginConfig.mem0.apiKey,
+      endpoint: pluginConfig.mem0.endpoint,
+      userId: pluginConfig.mem0.userId,
+      sessionId: pluginConfig.mem0.sessionId,
+      projectId: pluginConfig.mem0.projectId,
+      teamId: pluginConfig.mem0.teamId,
+      orgId: pluginConfig.mem0.orgId,
+      companyId: pluginConfig.mem0.companyId,
+      agentId: pluginConfig.mem0.agentId
+    });
+    await registry2.register(mem0Provider);
+  }
+  const hasMcpServers = config3.providers?.mcp?.enabled && config3.providers?.mcp?.servers?.length;
+  const hasNotebookLM = config3.providers?.notebooklm?.enabled;
+  if (hasMcpServers || hasNotebookLM) {
+    const mcpManager = new KnowledgeMcpManager;
+    if (hasMcpServers) {
+      for (const serverConfig of config3.providers.mcp.servers) {
+        mcpManager.registerServer(serverConfig);
+        const mcpProvider = new MCPKnowledgeProvider(serverConfig, mcpManager);
+        await registry2.register(mcpProvider);
+      }
+    }
+    if (hasNotebookLM) {
+      const notebookLMProvider = new NotebookLMKnowledgeProvider({
+        enabled: true,
+        defaultNotebookId: config3.providers.notebooklm.defaultNotebookId
+      }, mcpManager);
+      await registry2.register(notebookLMProvider);
+    }
+  }
+  return registry2;
+}
 var OhMyOpenCodePlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory, ctx);
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
@@ -52751,15 +55733,30 @@ var OhMyOpenCodePlugin = async (ctx) => {
     companyId: pluginConfig.mem0.companyId,
     agentId: pluginConfig.mem0.agentId
   }) : null;
-  const memoryTools = mem0Adapter ? createMemoryTools(mem0Adapter) : {};
+  const lettaAdapter = pluginConfig.letta?.enabled ? new LettaAdapter({
+    enabled: true,
+    endpoint: pluginConfig.letta.endpoint,
+    apiKey: pluginConfig.letta.apiKey,
+    userId: pluginConfig.letta.userId,
+    projectId: pluginConfig.letta.projectId,
+    teamId: pluginConfig.letta.teamId,
+    orgId: pluginConfig.letta.orgId,
+    companyId: pluginConfig.letta.companyId,
+    agentPrefix: pluginConfig.letta.agentPrefix,
+    llmModel: pluginConfig.letta.llmModel,
+    embeddingModel: pluginConfig.letta.embeddingModel
+  }) : null;
+  const memoryAdapter = lettaAdapter ?? mem0Adapter;
+  const memoryTools = memoryAdapter ? createMemoryTools(memoryAdapter) : {};
+  const knowledgeProviderRegistry = pluginConfig.knowledge_provider?.enabled ? await initializeKnowledgeProviderRegistry(pluginConfig, mem0Adapter) : null;
   const knowledgeMonitor = isHookEnabled("knowledge-monitor") && pluginConfig.knowledge_repo?.enabled ? createKnowledgeMonitorHook(ctx.directory, {
     enabled: true,
     checkPreTool: true,
     checkPostTool: false
   }) : null;
-  const memoryRehydration = isHookEnabled("memory-rehydration") && mem0Adapter && pluginConfig.mem0?.autoRehydrate !== false ? createMemoryRehydrationHook(mem0Adapter, {
+  const memoryRehydration = isHookEnabled("memory-rehydration") && memoryAdapter && (pluginConfig.letta?.autoRehydrate !== false || pluginConfig.mem0?.autoRehydrate !== false) ? createMemoryRehydrationHook(memoryAdapter, {
     enabled: true,
-    layers: pluginConfig.mem0?.rehydrateLayers
+    layers: pluginConfig.letta?.rehydrateLayers ?? pluginConfig.mem0?.rehydrateLayers
   }) : null;
   const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }) : null;
@@ -52855,12 +55852,14 @@ var OhMyOpenCodePlugin = async (ctx) => {
     pluginConfig,
     modelCacheState
   });
+  const knowledgeProviderTools = knowledgeProviderRegistry ? createKnowledgeProviderTools(knowledgeProviderRegistry) : {};
   return {
     ...googleAuthHooks ? { auth: googleAuthHooks.auth } : {},
     tool: {
       ...builtinTools,
       ...backgroundTools,
       ...memoryTools,
+      ...knowledgeProviderTools,
       call_omo_agent: callOmoAgent,
       look_at: lookAt,
       skill: skillTool,