openfox 2.0.13 → 2.0.15

package/dist/{chunk-3QB2RMX2.js → chunk-F4PMNP7S.js}

@@ -1,7 +1,7 @@
 import {
   createServerMessage,
   isClientMessage
-} from "./chunk-5BDVM6YI.js";
+} from "./chunk-YD6NDTKF.js";
 
 // src/server/ws/protocol.ts
 function enrichMessagesWithToolResults(messages) {
@@ -339,4 +339,4 @@ export {
   createQueueStateMessage,
   storedEventToServerMessage
 };
-//# sourceMappingURL=chunk-3QB2RMX2.js.map
+//# sourceMappingURL=chunk-F4PMNP7S.js.map

package/dist/{chunk-TIKQWNYK.js → chunk-J7KOV4ST.js}

@@ -9,7 +9,7 @@ import {
 import {
   createContextStateMessage,
   createSessionStateMessage
-} from "./chunk-3QB2RMX2.js";
+} from "./chunk-F4PMNP7S.js";
 import {
   getPendingQuestionsForSession
 } from "./chunk-EU3WWTFH.js";
@@ -154,4 +154,4 @@ export {
   needsNameGenerationCheck,
   applyGeneratedSessionName
 };
-//# sourceMappingURL=chunk-TIKQWNYK.js.map
+//# sourceMappingURL=chunk-J7KOV4ST.js.map

package/dist/{chunk-2VDLXCLO.js → chunk-KPKSN362.js}

@@ -1,3 +1,6 @@
+import {
+  getProject
+} from "./chunk-XAMAYRDA.js";
 import {
   COMPACTION_PROMPT,
   TurnMetrics,
@@ -29,8 +32,8 @@ import {
   getSessionProcessCount
 } from "./chunk-VRGRAQDG.js";
 import {
-  getProject
-} from "./chunk-XAMAYRDA.js";
+  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";
@@ -806,6 +813,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(
@@ -849,6 +864,7 @@ var writeFileTool = createTool(
     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) {
@@ -1102,6 +1118,7 @@ Make sure whitespace and indentation match exactly.`
       if (context.lspManager) {
         diagnostics = await context.lspManager.notifyFileChange(fullPath, newContent);
         output += formatDiagnosticsForLLM(diagnostics);
+        output = appendLspInstallHint(output, context.lspManager, fullPath);
       }
       const newHash = await computeFileHash(fullPath);
       if (newHash) {
@@ -2266,7 +2283,7 @@ ${CONTINUE_PROMPT}` : CONTINUE_PROMPT;
       systemPrompt: assembledRequest.systemPrompt,
       llmClient,
       messages: assembledRequest.messages,
-      tools: toolRegistry.definitions,
+      tools: assembledRequest.tools,
       toolChoice: "auto",
       signal,
       ...config.retryPatterns ? { retryPatterns: config.retryPatterns } : {},
@@ -2575,7 +2592,8 @@ function createAssemblyResult(input) {
   const messagesForLLM = input.messages.filter((m) => m.source !== "runtime");
   return {
     systemPrompt: input.systemPrompt,
-    messages: messagesForLLM.map((message) => messageToMinimal(message))
+    messages: messagesForLLM.map((message) => messageToMinimal(message)),
+    tools: input.requestTools
   };
 }
 function buildAssemblyInput(systemPrompt, baseInput) {
@@ -2676,10 +2694,10 @@ async function describeImageFromDataUrl(dataUrl, visionModel, options) {
 import { createHash as createHash2 } from "crypto";
 async function loadVisionModelFromGlobalConfig() {
   try {
-    const { loadGlobalConfig, getVisionFallback } = await import("./config-BU66P4KX.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 };
@@ -3131,7 +3149,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-THXBQJ7A.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-WEE4XDTL.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3918,6 +3936,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-WEE4XDTL.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-WEE4XDTL.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 = {};
@@ -4056,24 +4306,29 @@ function createRegistryFromTools(tools, allowedTools, toolPermissions) {
     }
   };
 }
+var mcpToolsOverride = [];
+function setMcpTools(tools) {
+  mcpToolsOverride = tools;
+}
 function getAllToolsMap() {
-  return new Map([
-    ...[
-      readFileTool,
-      writeFileTool,
-      editFileTool,
-      runCommandTool,
-      askUserTool,
-      sessionMetadataTool,
-      callSubAgentTool,
-      loadSkillTool,
-      returnValueTool,
-      webFetchTool,
-      devServerTool,
-      stepDoneTool,
-      backgroundProcessTool
-    ].map((t) => [t.name, t])
-  ]);
+  const builtInTools = [
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    runCommandTool,
+    askUserTool,
+    sessionMetadataTool,
+    callSubAgentTool,
+    loadSkillTool,
+    returnValueTool,
+    webFetchTool,
+    devServerTool,
+    stepDoneTool,
+    backgroundProcessTool,
+    mcpConfigTool
+  ].map((t) => [t.name, t]);
+  const mcpEntries = mcpToolsOverride.map((t) => [t.name, t]);
+  return new Map([...builtInTools, ...mcpEntries]);
 }
 function createPermissionErrorMessage(toolName, allowedTools) {
   if (allowedTools.length === 0) {
@@ -4178,12 +4433,19 @@ export {
   executeSubAgent,
   devServerManager,
   stepDoneTool,
+  computeDynamicContextHash,
+  getToolFingerprint,
+  applyDynamicContext,
+  setMcpManagerForTools,
+  setMcpConfigMode,
+  setNotifyMcpServersChanged,
   parseToolPermissions,
   getToolPermissions,
   validateToolAction,
   createRegistryFromTools,
+  setMcpTools,
   getToolRegistryForSubAgent,
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-2VDLXCLO.js.map
+//# sourceMappingURL=chunk-KPKSN362.js.map

package/dist/chunk-NWO6GRYE.js

@@ -0,0 +1,39 @@
+// src/server/mcp/tool-adapter.ts
+function createMcpTools(mcpManager) {
+  const tools = [];
+  for (const server of mcpManager.getAllServers()) {
+    for (const mcpTool of server.tools) {
+      if (!mcpTool.enabled) continue;
+      const prefixedName = `${server.name}_${mcpTool.name}`;
+      const definition = {
+        type: "function",
+        function: {
+          name: prefixedName,
+          description: mcpTool.description ?? "",
+          parameters: mcpTool.inputSchema
+        }
+      };
+      tools.push({
+        name: prefixedName,
+        definition,
+        execute: async (args, _context) => {
+          const start = Date.now();
+          const result = await mcpManager.callTool(server.name, mcpTool.name, args);
+          return {
+            success: result.success,
+            ...result.output ? { output: result.output } : {},
+            ...result.error ? { error: result.error } : {},
+            durationMs: Date.now() - start,
+            truncated: false
+          };
+        }
+      });
+    }
+  }
+  return tools;
+}
+
+export {
+  createMcpTools
+};
+//# sourceMappingURL=chunk-NWO6GRYE.js.map