openfox 2.0.14 → 2.0.16

package/dist/{chunk-4ZTQO5JP.js → chunk-JO6RF2U2.js}

@@ -31,6 +31,9 @@ import {
   getMaxPerSession,
   getSessionProcessCount
 } from "./chunk-VRGRAQDG.js";
+import {
+  createMcpTools
+} from "./chunk-NWO6GRYE.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
@@ -52,7 +55,7 @@ import {
   createChatMessageUpdatedMessage,
   createChatPathConfirmationMessage,
   createQueueStateMessage
-} from "./chunk-3QB2RMX2.js";
+} from "./chunk-F4PMNP7S.js";
 import {
   AskUserInterrupt,
   askUserTool
@@ -62,6 +65,10 @@ import {
   deleteSetting,
   getSetting
 } from "./chunk-RFNEDBVO.js";
+import {
+  loadGlobalConfig,
+  saveGlobalConfig
+} from "./chunk-SNQT7LNU.js";
 import {
   getGlobalConfigDir
 } from "./chunk-CQGTEGKL.js";
@@ -602,6 +609,182 @@ function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 
+// src/server/utils/encoding.ts
+import { detect } from "jschardet";
+import * as iconv from "iconv-lite";
+function detectEncoding(buffer) {
+  if (buffer.length === 0) {
+    return { encoding: "utf-8", confidence: 1, bomSize: 0 };
+  }
+  const bomSize = detectBOM(buffer);
+  const bomStripped = bomSize > 0 ? buffer.subarray(bomSize) : buffer;
+  if (bomSize > 0) {
+    const bomEncoding = bomEncodingForSize(buffer);
+    return { encoding: bomEncoding, confidence: 1, bomSize };
+  }
+  if (isValidUtf8(bomStripped)) {
+    return { encoding: "utf-8", confidence: 0.95, bomSize: 0 };
+  }
+  const detected = detect(bomStripped);
+  if (detected && detected.encoding && detected.confidence > 0.2) {
+    return { encoding: normalizeEncoding(detected.encoding), confidence: detected.confidence, bomSize: 0 };
+  }
+  return { encoding: "ISO-8859-1", confidence: 0.1, bomSize: 0 };
+}
+function detectBOM(buffer) {
+  if (buffer.length >= 4 && buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 254 && buffer[3] === 255)
+    return 4;
+  if (buffer.length >= 4 && buffer[0] === 255 && buffer[1] === 254 && buffer[2] === 0 && buffer[3] === 0)
+    return 4;
+  if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) return 2;
+  if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) return 2;
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) return 3;
+  return 0;
+}
+function bomEncodingForSize(buffer) {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 254 && buffer[1] === 255) return "utf-16be";
+    if (buffer[0] === 255 && buffer[1] === 254) {
+      if (buffer.length >= 4 && buffer[2] === 0 && buffer[3] === 0) return "utf-32";
+      return "utf-16le";
+    }
+  }
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) return "utf-8";
+  if (buffer.length >= 4 && buffer[0] === 0 && buffer[1] === 0 && buffer[2] === 254 && buffer[3] === 255)
+    return "utf-32be";
+  return "utf-8";
+}
+function isValidUtf8(buffer) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  try {
+    decoder.decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeEncoding(enc) {
+  const lower = enc.toLowerCase().replace(/_/g, "-");
+  const map = {
+    "utf-8": "utf-8",
+    utf8: "utf-8",
+    ascii: "utf-8",
+    "iso-8859-1": "ISO-8859-1",
+    "iso8859-1": "ISO-8859-1",
+    latin1: "ISO-8859-1",
+    "windows-1252": "windows-1252",
+    "shift-jis": "Shift_JIS",
+    shift_jis: "Shift_JIS",
+    "euc-jp": "EUC-JP",
+    "euc-kr": "EUC-KR",
+    gb2312: "GB2312",
+    gb18030: "GB18030",
+    big5: "Big5",
+    "utf-16": "utf-16le",
+    "utf-16le": "utf-16le",
+    "utf-16be": "utf-16be",
+    "utf-32": "utf-32le",
+    "utf-32le": "utf-32le",
+    "utf-32be": "utf-32be",
+    "koi8-r": "KOI8-R",
+    "koi8-u": "KOI8-U"
+  };
+  return map[lower] ?? enc;
+}
+function decodeContent(buffer, encoding) {
+  const bomSize = detectBOM(buffer);
+  const contentBuf = bomSize > 0 ? buffer.subarray(bomSize) : buffer;
+  const normalized = normalizeEncoding(encoding);
+  if (normalized === "utf-8") {
+    return contentBuf.toString("utf-8");
+  }
+  if (normalized === "utf-16le") {
+    return contentBuf.toString("utf-16le");
+  }
+  if (normalized === "utf-16be") {
+    return swapUtf16Endianness(contentBuf).toString("utf-16le");
+  }
+  if (normalized === "utf-32le") {
+    return utf32ToString(contentBuf, true);
+  }
+  if (normalized === "utf-32be") {
+    return utf32ToString(contentBuf, false);
+  }
+  return iconv.decode(contentBuf, normalized);
+}
+function encodeContent(content, encoding, addBom = false) {
+  const normalized = normalizeEncoding(encoding);
+  let encoded;
+  if (normalized === "utf-8") {
+    encoded = Buffer.from(content, "utf-8");
+  } else if (normalized === "utf-16le") {
+    encoded = Buffer.from(content, "utf-16le");
+  } else if (normalized === "utf-16be") {
+    encoded = swapUtf16Endianness(Buffer.from(content, "utf-16le"));
+  } else if (normalized === "utf-32le") {
+    encoded = stringToUtf32(content, true);
+  } else if (normalized === "utf-32be") {
+    encoded = stringToUtf32(content, false);
+  } else {
+    encoded = iconv.encode(content, normalized);
+  }
+  if (addBom) {
+    const bom = bomForEncoding(normalized);
+    if (bom) {
+      encoded = Buffer.concat([bom, encoded]);
+    }
+  }
+  return encoded;
+}
+function bomForEncoding(encoding) {
+  switch (encoding) {
+    case "utf-8":
+      return Buffer.from([239, 187, 191]);
+    case "utf-16le":
+      return Buffer.from([255, 254]);
+    case "utf-16be":
+      return Buffer.from([254, 255]);
+    case "utf-32le":
+      return Buffer.from([255, 254, 0, 0]);
+    case "utf-32be":
+      return Buffer.from([0, 0, 254, 255]);
+    default:
+      return null;
+  }
+}
+function swapUtf16Endianness(buf) {
+  const out = Buffer.alloc(buf.length);
+  for (let i = 0; i + 1 < buf.length; i += 2) {
+    out[i] = buf[i + 1];
+    out[i + 1] = buf[i];
+  }
+  return out;
+}
+function utf32ToString(buffer, littleEndian) {
+  const chars = [];
+  for (let i = 0; i + 3 < buffer.length; i += 4) {
+    const code = littleEndian ? buffer.readUInt32LE(i) : buffer.readUInt32BE(i);
+    if (code > 1114111) continue;
+    chars.push(String.fromCodePoint(code));
+  }
+  return chars.join("");
+}
+function stringToUtf32(str, littleEndian) {
+  const codes = [];
+  for (const ch of str) {
+    codes.push(ch.codePointAt(0));
+  }
+  const buf = Buffer.alloc(codes.length * 4);
+  for (let i = 0; i < codes.length; i++) {
+    if (littleEndian) {
+      buf.writeUInt32LE(codes[i], i * 4);
+    } else {
+      buf.writeUInt32BE(codes[i], i * 4);
+    }
+  }
+  return buf;
+}
+
 // src/server/tools/read.ts
 var IMAGE_MIME_TYPES = {
   ".png": "image/png",
@@ -752,7 +935,8 @@ var readFileTool = createTool(
         }
       });
     }
-    const content = rawBuffer.toString("utf-8");
+    const { encoding, confidence } = detectEncoding(rawBuffer);
+    const content = decodeContent(rawBuffer, encoding);
     const lines = content.split("\n");
     const totalLines = lines.length;
     const startLine = Math.max(1, offset);
@@ -774,7 +958,13 @@ var readFileTool = createTool(
     if (contentHash2) {
       context.sessionManager.recordFileRead(context.sessionId, fullPath, contentHash2);
     }
-    return helpers.success(output, truncated);
+    return helpers.success(output, truncated, {
+      metadata: {
+        encoding,
+        confidence: Math.round(confidence * 100) / 100,
+        lineCount: totalLines
+      }
+    });
   }
 );
 
@@ -806,6 +996,14 @@ function formatDiagnosticsForLLM(diagnostics) {
   }
   return output;
 }
+function appendLspInstallHint(output, lspManager, path) {
+  if (!lspManager) return output;
+  const hint = lspManager.getInstallHint(path);
+  if (!hint) return output;
+  return output + `
+
+\u26A0\uFE0F Language server not installed. To enable diagnostics: \`${hint}\``;
+}
 
 // src/server/tools/write.ts
 var writeFileTool = createTool(
@@ -825,6 +1023,10 @@ var writeFileTool = createTool(
           content: {
             type: "string",
             description: "Content to write to the file"
+          },
+          encoding: {
+            type: "string",
+            description: 'Optional file encoding (e.g. "ISO-8859-1", "windows-1252", "utf-16"). Defaults to "utf-8". Use the encoding reported by read_file to match project conventions.'
           }
         },
         required: ["path", "content"]
@@ -841,14 +1043,17 @@ var writeFileTool = createTool(
     }
     const dir = dirname(fullPath);
     await mkdir(dir, { recursive: true });
-    await writeFile(fullPath, args.content, "utf-8");
+    const encoding = args.encoding ?? "utf-8";
+    const encoded = encodeContent(args.content, encoding);
+    await writeFile(fullPath, encoded);
     const lineCount = args.content.split("\n").length;
-    const byteCount = Buffer.byteLength(args.content, "utf-8");
+    const byteCount = encoded.length;
     let output = `Successfully wrote ${lineCount} lines (${byteCount} bytes) to ${args.path}`;
     let diagnostics = [];
     if (context.lspManager) {
       diagnostics = await context.lspManager.notifyFileChange(fullPath, args.content);
       output += formatDiagnosticsForLLM(diagnostics);
+      output = appendLspInstallHint(output, context.lspManager, fullPath);
     }
     const newHash = await computeFileHash(fullPath);
     if (newHash) {
@@ -1029,12 +1234,14 @@ var editFileTool = createTool(
       if (!validation.valid) {
         return helpers.error(validation.error?.message ?? "File validation failed");
       }
-      let content;
+      let rawBuffer;
       try {
-        content = await readFile3(fullPath, "utf-8");
+        rawBuffer = await readFile3(fullPath);
       } catch {
         return helpers.error(`File not found: ${args.path}`);
       }
+      const { encoding, bomSize } = detectEncoding(rawBuffer);
+      const content = decodeContent(rawBuffer, encoding);
       const fileLineEnding = detectLineEnding(content);
       const normalizedContent = normalizeToLF(content);
       const normalizedOldString = normalizeToLF(args.old_string);
@@ -1092,16 +1299,18 @@ Make sure whitespace and indentation match exactly.`
         }
         replacedContent = normalizedContent.slice(0, index) + normalizedNewString + normalizedContent.slice(index + normalizedOldString.length);
       }
-      const newContent = replacedContent.replace(
+      const restoredContent = replacedContent.replace(
         /\n/g,
         fileLineEnding === "crlf" ? "\r\n" : fileLineEnding === "cr" ? "\r" : "\n"
       );
-      await writeFile2(fullPath, newContent, "utf-8");
+      const encoded = encodeContent(restoredContent, encoding, bomSize > 0);
+      await writeFile2(fullPath, encoded);
       let output = `Successfully replaced ${replaceAll ? occurrences : 1} occurrence(s) in ${args.path}`;
       let diagnostics = [];
       if (context.lspManager) {
-        diagnostics = await context.lspManager.notifyFileChange(fullPath, newContent);
+        diagnostics = await context.lspManager.notifyFileChange(fullPath, restoredContent);
         output += formatDiagnosticsForLLM(diagnostics);
+        output = appendLspInstallHint(output, context.lspManager, fullPath);
       }
       const newHash = await computeFileHash(fullPath);
       if (newHash) {
@@ -2677,10 +2886,10 @@ async function describeImageFromDataUrl(dataUrl, visionModel, options) {
 import { createHash as createHash2 } from "crypto";
 async function loadVisionModelFromGlobalConfig() {
   try {
-    const { loadGlobalConfig, getVisionFallback } = await import("./config-YFHA5MWV.js");
+    const { loadGlobalConfig: loadGlobalConfig2, getVisionFallback } = await import("./config-Z66BQTNX.js");
     const runtimeConfig = getRuntimeConfig();
     const mode = runtimeConfig.mode ?? "production";
-    const globalConfig = await loadGlobalConfig(mode);
+    const globalConfig = await loadGlobalConfig2(mode);
     const fallback = getVisionFallback(globalConfig);
     if (fallback?.enabled && fallback.model) {
       return { baseUrl: fallback.url, model: fallback.model, timeout: fallback.timeout * 1e3 };
@@ -3132,7 +3341,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-DUC54GEH.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-Y7ZGLK7A.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3919,6 +4128,238 @@ These processes run independently of agent turns and persist across session comp
   }
 );
 
+// src/server/chat/dynamic-context.ts
+import { createHash as createHash3 } from "crypto";
+function computeDynamicContextHash(instructionContent, skills, toolFingerprint) {
+  const dynamicInputs = JSON.stringify({
+    instructions: instructionContent,
+    skills: skills.map((s) => s.id).sort(),
+    ...toolFingerprint ? { tools: toolFingerprint } : {}
+  });
+  return createHash3("sha256").update(dynamicInputs).digest("hex");
+}
+function getToolFingerprint(tools) {
+  return tools.map((t) => `${t.function.name}:${JSON.stringify(t.function.parameters)}`).sort().join("|");
+}
+async function computeContextHash(sessionManager, sessionId) {
+  const session = sessionManager.requireSession(sessionId);
+  const { content: instructionContent } = await getAllInstructions(session.workdir, session.projectId);
+  const runtimeConfig = getRuntimeConfig();
+  const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
+  const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
+  const { createToolRegistry: createToolRegistry2 } = await import("./tools-Y7ZGLK7A.js");
+  const allTools = createToolRegistry2().definitions;
+  const toolFingerprint = getToolFingerprint(allTools);
+  const hash = computeDynamicContextHash(instructionContent, skills, toolFingerprint);
+  return { hash, instructionContent, skills, allTools };
+}
+async function applyDynamicContext(sessionManager, sessionId) {
+  const { hash, instructionContent, skills, allTools } = await computeContextHash(sessionManager, sessionId);
+  const allAgents = await loadAllAgentsDefault();
+  const subAgentDefs = getSubAgents(allAgents);
+  const systemPrompt = buildTopLevelSystemPrompt(
+    sessionManager.requireSession(sessionId).workdir,
+    instructionContent || void 0,
+    skills,
+    subAgentDefs
+  );
+  sessionManager.setCachedPrompt(sessionId, systemPrompt, allTools, hash);
+  sessionManager.setDynamicContextChanged(sessionId, false);
+  sessionManager.clearDebugDump(sessionId);
+  logger.debug("applyDynamicContext done", { sessionId, hash, toolCount: allTools.length });
+}
+
+// src/server/tools/mcp-config.ts
+var mcpManagerForTools = null;
+var mcpConfigMode = "production";
+var mcpNotifyChanged = null;
+function setMcpManagerForTools(manager) {
+  mcpManagerForTools = manager;
+}
+function setMcpConfigMode(mode) {
+  mcpConfigMode = mode;
+}
+function setNotifyMcpServersChanged(fn) {
+  mcpNotifyChanged = fn;
+}
+var mcpConfigTool = createTool(
+  "mcp_config",
+  {
+    type: "function",
+    function: {
+      name: "mcp_config",
+      description: "Configure MCP servers (Model Context Protocol). Actions: list (show all servers and tools), add (add a server), remove (delete a server), toggle-tool (enable/disable a tool). Use this when the user asks to add, remove, or configure MCP servers or tools.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "add", "remove", "toggle-tool"],
+            description: "Action: list (show servers), add (add new server), remove (delete a server), toggle-tool (enable/disable a tool)"
+          },
+          name: {
+            type: "string",
+            description: "Server name (required for: add, remove, toggle-tool)"
+          },
+          transport: {
+            type: "string",
+            enum: ["stdio", "http"],
+            description: "Transport type (for add). Default: stdio"
+          },
+          command: {
+            type: "string",
+            description: 'Command for stdio transport (e.g. "npx")'
+          },
+          args: {
+            type: "array",
+            items: { type: "string" },
+            description: "Command arguments for stdio transport"
+          },
+          env: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Environment variables for stdio transport"
+          },
+          url: {
+            type: "string",
+            description: 'Server URL for HTTP transport (e.g. "https://mcp.example.com/mcp")'
+          },
+          headers: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: 'HTTP headers for HTTP transport (e.g. {"Authorization": "Bearer xxx"})'
+          },
+          toolName: {
+            type: "string",
+            description: "Tool name to toggle (required for: toggle-tool)"
+          },
+          enabled: {
+            type: "boolean",
+            description: "Whether the tool should be enabled (required for: toggle-tool)"
+          }
+        },
+        required: ["action"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const actionError = validateActionWithPermission(
+      args.action,
+      ["list", "add", "remove", "toggle-tool"],
+      "mcp_config",
+      context.permittedActions
+    );
+    if (actionError) return actionError;
+    if (!mcpManagerForTools) {
+      return helpers.error("MCP manager not available");
+    }
+    async function persistAndRebuild(updater) {
+      const globalConfig = await loadGlobalConfig(mcpConfigMode);
+      const mcpServers = { ...globalConfig.mcpServers ?? {} };
+      const updated = updater(mcpServers);
+      await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated });
+    }
+    async function rebuildTools() {
+      const { setMcpTools: setMcpTools2 } = await import("./tools-Y7ZGLK7A.js");
+      const mcpTools = createMcpTools(mcpManagerForTools);
+      setMcpTools2(mcpTools);
+    }
+    if (args.action === "list") {
+      const servers = mcpManagerForTools.getAllServers();
+      if (servers.length === 0) {
+        return helpers.success("No MCP servers configured.");
+      }
+      const lines = [];
+      for (const server of servers) {
+        const connStr = server.status === "connected" ? "\u25CF" : server.status === "error" ? "\u2717" : "\u25CB";
+        const cmdStr = server.config.command ? `${server.config.command} ${(server.config.args ?? []).join(" ")}` : server.config.url ?? "";
+        lines.push(
+          `${connStr} ${server.name} (${server.config.transport}) \u2014 ${server.status}${server.error ? `: ${server.error}` : ""}`
+        );
+        lines.push(`  ${cmdStr}`);
+        lines.push(`  ${server.tools.length} tools, ~${server.estimatedTokens} tokens`);
+        const enabledTools = server.tools.filter((t) => t.enabled);
+        const disabledTools = server.tools.filter((t) => !t.enabled);
+        if (enabledTools.length > 0) {
+          lines.push(`  Enabled: ${enabledTools.map((t) => t.name).join(", ")}`);
+        }
+        if (disabledTools.length > 0) {
+          lines.push(`  Disabled: ${disabledTools.map((t) => t.name).join(", ")}`);
+        }
+      }
+      return helpers.success(lines.join("\n"));
+    }
+    if (args.action === "add") {
+      if (!args.name) return helpers.error("Missing required field: name");
+      if (args.transport === "http") {
+        if (!args.url) return helpers.error("url is required for http transport");
+      } else if (!args.command) {
+        return helpers.error("command is required for stdio transport");
+      }
+      const serverCfg = {
+        transport: args.transport ?? "stdio",
+        ...args.command ? { command: args.command } : {},
+        ...args.args && args.args.length > 0 ? { args: args.args } : {},
+        ...args.env && Object.keys(args.env).length > 0 ? { env: args.env } : {},
+        ...args.url ? { url: args.url } : {},
+        ...args.headers && Object.keys(args.headers).length > 0 ? { headers: args.headers } : {}
+      };
+      await persistAndRebuild((mcpServers) => {
+        mcpServers[args.name] = serverCfg;
+        return mcpServers;
+      });
+      await mcpManagerForTools.addServer(args.name, serverCfg);
+      await rebuildTools();
+      await applyDynamicContext(context.sessionManager, context.sessionId);
+      mcpNotifyChanged?.(context.sessionId);
+      const server = mcpManagerForTools.getServer(args.name);
+      const toolCount = server?.tools.length ?? 0;
+      return helpers.success(`Added MCP server "${args.name}" (${toolCount} tools discovered).`);
+    }
+    if (args.action === "remove") {
+      if (!args.name) return helpers.error("Missing required field: name");
+      await persistAndRebuild((mcpServers) => {
+        delete mcpServers[args.name];
+        return mcpServers;
+      });
+      mcpManagerForTools.removeServer(args.name);
+      await rebuildTools();
+      await applyDynamicContext(context.sessionManager, context.sessionId);
+      mcpNotifyChanged?.(context.sessionId);
+      return helpers.success(`Removed MCP server "${args.name}".`);
+    }
+    if (args.action === "toggle-tool") {
+      if (!args.name) return helpers.error("Missing required field: name");
+      if (!args.toolName) return helpers.error("Missing required field: toolName");
+      if (args.enabled === void 0) return helpers.error("Missing required field: enabled");
+      const server = mcpManagerForTools.getServer(args.name);
+      const currentDisabled = (server?.tools ?? []).filter((t) => !t.enabled).map((t) => t.name);
+      const afterDisabled = args.enabled ? currentDisabled.filter((n) => n !== args.toolName) : [...currentDisabled, args.toolName];
+      await persistAndRebuild((mcpServers) => {
+        const cfg = mcpServers[args.name];
+        if (cfg) {
+          const updated = { ...cfg };
+          if (afterDisabled.length > 0) {
+            updated.disabledTools = afterDisabled;
+          } else {
+            delete updated.disabledTools;
+          }
+          mcpServers[args.name] = updated;
+        }
+        return mcpServers;
+      });
+      await mcpManagerForTools.setToolEnabled(args.name, args.toolName, args.enabled);
+      await rebuildTools();
+      await applyDynamicContext(context.sessionManager, context.sessionId);
+      mcpNotifyChanged?.(context.sessionId);
+      return helpers.success(
+        `Tool "${args.toolName}" ${args.enabled ? "enabled" : "disabled"} on server "${args.name}".`
+      );
+    }
+    return helpers.error("Unexpected error");
+  }
+);
+
 // src/server/tools/index.ts
 function parseToolPermissions(allowedTools) {
   const result = {};
@@ -4075,7 +4516,8 @@ function getAllToolsMap() {
     webFetchTool,
     devServerTool,
     stepDoneTool,
-    backgroundProcessTool
+    backgroundProcessTool,
+    mcpConfigTool
   ].map((t) => [t.name, t]);
   const mcpEntries = mcpToolsOverride.map((t) => [t.name, t]);
   return new Map([...builtInTools, ...mcpEntries]);
@@ -4183,6 +4625,12 @@ export {
   executeSubAgent,
   devServerManager,
   stepDoneTool,
+  computeDynamicContextHash,
+  getToolFingerprint,
+  applyDynamicContext,
+  setMcpManagerForTools,
+  setMcpConfigMode,
+  setNotifyMcpServersChanged,
   parseToolPermissions,
   getToolPermissions,
   validateToolAction,
@@ -4192,4 +4640,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-4ZTQO5JP.js.map
+//# sourceMappingURL=chunk-JO6RF2U2.js.map

package/dist/{chunk-LNEBVOH6.js → chunk-OUK5IW26.js}

@@ -33,7 +33,7 @@ Options:
 }
 async function runNetworkSetup(mode) {
   const { loadAuthConfig, saveAuthConfig, encryptPassword } = await import("./auth-56SIRACI.js");
-  const { saveGlobalConfig } = await import("./config-YFHA5MWV.js");
+  const { saveGlobalConfig } = await import("./config-Z66BQTNX.js");
   const { getAuthKeyPath } = await import("./paths-X46PPOI2.js");
   const existingAuth = await loadAuthConfig(mode);
   if (existingAuth) {
@@ -94,7 +94,7 @@ async function runNetworkSetup(mode) {
   console.log("\u2713 Configuration saved!\n");
 }
 async function runConfig(mode) {
-  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-YFHA5MWV.js");
+  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-Z66BQTNX.js");
   const { getGlobalConfigPath } = await import("./paths-X46PPOI2.js");
   const config = await loadGlobalConfig(mode);
   const configPath = getGlobalConfigPath(mode);
@@ -152,7 +152,7 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-QUJQLVOM.js");
+      const { runProviderCommand } = await import("./provider-YBTRC77Y.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
@@ -191,12 +191,12 @@ async function runCli(options) {
       break;
     }
     default: {
-      const { configFileExists } = await import("./config-YFHA5MWV.js");
+      const { configFileExists } = await import("./config-Z66BQTNX.js");
       const configExists = await configFileExists(mode);
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-GA2UIHHB.js");
+      const { runServe } = await import("./serve-HZXJXK6T.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -208,4 +208,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-LNEBVOH6.js.map
+//# sourceMappingURL=chunk-OUK5IW26.js.map

package/dist/{chunk-PP6VQXQW.js → chunk-SNQT7LNU.js}

@@ -67,6 +67,7 @@ var mcpServerSchema = z.object({
   args: z.array(z.string()).optional(),
   env: z.record(z.string(), z.string()).optional(),
   url: z.string().optional(),
+  headers: z.record(z.string(), z.string()).optional(),
   disabledTools: z.array(z.string()).optional()
 });
 var defaultVisionFallback = { enabled: false, url: "http://localhost:11434", model: "qwen3.5:0.8b", timeout: 120 };
@@ -435,4 +436,4 @@ export {
   activateProvider,
   mergeConfigs
 };
-//# sourceMappingURL=chunk-PP6VQXQW.js.map
+//# sourceMappingURL=chunk-SNQT7LNU.js.map