openfox 2.0.13 → 2.0.15

package/dist/chunk-PQ56PX7L.js

@@ -0,0 +1,397 @@
+import {
+  buildNonStreamingCreateParams,
+  buildStreamingCreateParams,
+  getBackendCapabilities,
+  getModelProfile,
+  getThinking,
+  mapFinishReason
+} from "./chunk-Z4SWOUWC.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/llm/url-utils.ts
+var VERSION_PREFIX_REGEX = /\/v\d+(\/|$)/;
+function hasVersionPrefix(url) {
+  return VERSION_PREFIX_REGEX.test(url);
+}
+function ensureVersionPrefix(url, defaultVersion = "/v1") {
+  if (hasVersionPrefix(url)) return url;
+  return `${url.replace(/\/+$/, "")}${defaultVersion}`;
+}
+function stripVersionPrefix(url) {
+  return url.replace(/\/v\d+\/?$/, "");
+}
+function buildModelsUrl(baseUrl) {
+  return `${ensureVersionPrefix(baseUrl)}/models`;
+}
+
+// src/server/llm/client.ts
+import OpenAI from "openai";
+
+// src/server/utils/errors.ts
+var OpenFoxError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "OpenFoxError";
+  }
+};
+var SessionNotFoundError = class extends OpenFoxError {
+  constructor(sessionId) {
+    super(`Session not found: ${sessionId}`, "SESSION_NOT_FOUND", { sessionId });
+    this.name = "SessionNotFoundError";
+  }
+};
+var LLMError = class extends OpenFoxError {
+  constructor(message, details) {
+    super(message, "LLM_ERROR", details);
+    this.name = "LLMError";
+  }
+};
+
+// src/server/llm/client.ts
+import { Agent, setGlobalDispatcher } from "undici";
+var agent = new Agent({ allowH2: true });
+setGlobalDispatcher(agent);
+function createLLMClient(config, initialBackend = "unknown") {
+  const baseURL = ensureVersionPrefix(config.llm.baseUrl);
+  const openai = new OpenAI({
+    baseURL,
+    apiKey: config.llm.apiKey ?? "not-needed"
+  });
+  let model = config.llm.model;
+  let profile = getModelProfile(model);
+  let backend = initialBackend;
+  let capabilities = getBackendCapabilities(backend);
+  const reasoningEffort = config.llm.reasoningEffort;
+  const thinkingField = config.llm.thinkingField;
+  const idleTimeout = config.llm.idleTimeout ?? 3e4;
+  return {
+    getModel() {
+      return model;
+    },
+    getProfile() {
+      return profile;
+    },
+    getBackend() {
+      return backend;
+    },
+    setBackend(newBackend) {
+      logger.debug("Setting LLM backend", { from: backend, to: newBackend });
+      backend = newBackend;
+      capabilities = getBackendCapabilities(newBackend);
+    },
+    setModel(newModel) {
+      const newProfile = getModelProfile(newModel);
+      logger.debug("Switching model", {
+        from: model,
+        to: newModel,
+        profile: newProfile.name,
+        temperature: newProfile.temperature
+      });
+      model = newModel;
+      profile = newProfile;
+    },
+    async complete(request) {
+      logger.debug("LLM complete request", {
+        messageCount: request.messages.length,
+        hasTools: !!request.tools?.length,
+        profile: profile.name,
+        reasoningEffort: request.reasoningEffort ?? reasoningEffort
+      });
+      try {
+        const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+        const { params: createParams } = await buildNonStreamingCreateParams({
+          model,
+          request,
+          profile,
+          capabilities,
+          ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
+          ...thinkingField ? { thinkingField } : {}
+        });
+        const response = await openai.chat.completions.create(createParams, {
+          signal: request.signal
+        });
+        const choice = response.choices[0];
+        if (!choice) {
+          throw new LLMError("No completion choice returned");
+        }
+        const message = choice.message;
+        const content = message.content ?? "";
+        const thinkingContent = getThinking(message, thinkingField) ?? "";
+        const toolCalls = message.tool_calls?.map((tc) => ({
+          id: tc.id,
+          name: tc.function.name,
+          arguments: JSON.parse(tc.function.arguments)
+        }));
+        return {
+          id: response.id,
+          content,
+          ...thinkingContent ? { thinkingContent } : {},
+          ...toolCalls && toolCalls.length > 0 ? { toolCalls } : {},
+          finishReason: mapFinishReason(choice.finish_reason),
+          usage: {
+            promptTokens: response.usage?.prompt_tokens ?? 0,
+            completionTokens: response.usage?.completion_tokens ?? 0,
+            totalTokens: response.usage?.total_tokens ?? 0
+          }
+        };
+      } catch (error) {
+        logger.error("LLM complete error", { error: String(error) });
+        throw new LLMError(error instanceof Error ? error.message : "Unknown LLM error", {
+          originalError: error instanceof Error ? error : void 0
+        });
+      }
+    },
+    async *stream(request) {
+      const resolvedEffort = request.reasoningEffort ?? reasoningEffort;
+      logger.debug("LLM stream request", {
+        messageCount: request.messages.length,
+        hasTools: !!request.tools?.length,
+        profile: profile.name,
+        reasoningEffort: resolvedEffort,
+        idleTimeout
+      });
+      try {
+        const createParams = await buildStreamingCreateParams({
+          model,
+          request,
+          profile,
+          capabilities,
+          ...resolvedEffort ? { reasoningEffort: resolvedEffort } : {},
+          ...thinkingField ? { thinkingField } : {}
+        });
+        const { params: streamingParams } = createParams;
+        const stream = await openai.chat.completions.create(streamingParams, {
+          signal: request.signal
+        });
+        let fullContent = "";
+        let fullThinking = "";
+        const toolCalls = /* @__PURE__ */ new Map();
+        let finishReason = "stop";
+        let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        let responseId = "";
+        let lastChunkTime = Date.now();
+        const idleTimeoutController = new AbortController();
+        const idleTimer = setInterval(() => {
+          const idleDuration = Date.now() - lastChunkTime;
+          if (idleDuration > idleTimeout) {
+            logger.warn("LLM stream idle timeout triggered", { idleDuration, idleTimeout });
+            idleTimeoutController.abort();
+          }
+        }, 100);
+        const onAbort = () => clearInterval(idleTimer);
+        request.signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+          for await (const chunk of stream) {
+            if (idleTimeoutController.signal.aborted) {
+              throw new Error(`LLM stream idle timeout: no chunks received for ${idleTimeout}ms`);
+            }
+            lastChunkTime = Date.now();
+            responseId = chunk.id;
+            if (chunk.usage) {
+              usage = {
+                promptTokens: chunk.usage.prompt_tokens,
+                completionTokens: chunk.usage.completion_tokens,
+                totalTokens: chunk.usage.total_tokens
+              };
+            }
+            const choice = chunk.choices[0];
+            if (!choice) continue;
+            if (choice.finish_reason) {
+              finishReason = mapFinishReason(choice.finish_reason);
+            }
+            const delta = choice.delta;
+            const reasoning = getThinking(delta, thinkingField);
+            if (reasoning) {
+              fullThinking += reasoning;
+              yield { type: "thinking_delta", content: reasoning };
+            }
+            if (delta.content) {
+              fullContent += delta.content;
+              yield { type: "text_delta", content: delta.content };
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const existing = toolCalls.get(tc.index);
+                if (!existing) {
+                  toolCalls.set(tc.index, {
+                    id: tc.id ?? "",
+                    name: tc.function?.name ?? "",
+                    arguments: tc.function?.arguments ?? ""
+                  });
+                } else {
+                  if (tc.id) existing.id = tc.id;
+                  if (tc.function?.name) existing.name += tc.function.name;
+                  if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+                }
+                yield {
+                  type: "tool_call_delta",
+                  index: tc.index,
+                  ...tc.id ? { id: tc.id } : {},
+                  ...tc.function?.name ? { name: tc.function.name } : {},
+                  ...tc.function?.arguments ? { arguments: tc.function.arguments } : {}
+                };
+              }
+            }
+          }
+        } finally {
+          clearInterval(idleTimer);
+          request.signal?.removeEventListener("abort", onAbort);
+        }
+        const finalContent = fullContent.trim();
+        const finalThinking = fullThinking.trim();
+        const parsedToolCalls = [];
+        for (const [, tc] of toolCalls) {
+          try {
+            parsedToolCalls.push({
+              id: tc.id,
+              name: tc.name,
+              arguments: JSON.parse(tc.arguments)
+            });
+          } catch (error) {
+            logger.warn("Failed to parse tool call arguments", { name: tc.name, arguments: tc.arguments });
+            parsedToolCalls.push({
+              id: tc.id,
+              name: tc.name,
+              arguments: {},
+              parseError: error instanceof Error ? error.message : "Unknown JSON parse error",
+              rawArguments: tc.arguments
+            });
+          }
+        }
+        yield {
+          type: "done",
+          response: {
+            id: responseId,
+            content: finalContent,
+            ...finalThinking ? { thinkingContent: finalThinking } : {},
+            ...parsedToolCalls.length > 0 ? { toolCalls: parsedToolCalls } : {},
+            finishReason,
+            usage
+          }
+        };
+      } catch (error) {
+        logger.error("LLM stream error", { error });
+        yield {
+          type: "error",
+          error: error instanceof Error ? error.message : "Unknown LLM error"
+        };
+      }
+    }
+  };
+}
+
+// src/server/llm/models.ts
+var modelCache = /* @__PURE__ */ new Map();
+var llmStatus = "unknown";
+var lastActiveUrl = null;
+var CACHE_TTL_MS = 3e4;
+function getCacheKey(url) {
+  return stripVersionPrefix(url);
+}
+async function detectModel(llmBaseUrl, retries = 3, silent = false) {
+  const cacheKey = getCacheKey(llmBaseUrl);
+  const now = Date.now();
+  const cached = modelCache.get(cacheKey);
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    lastActiveUrl = cacheKey;
+    llmStatus = "connected";
+    return cached.model;
+  }
+  const url = buildModelsUrl(llmBaseUrl);
+  for (let attempt = 1; attempt <= retries; attempt++) {
+    try {
+      if (silent) {
+        logger.debug("Fetching models from LLM server", { url, attempt });
+      }
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!response.ok) {
+        if (silent) {
+          logger.debug("Failed to fetch models from LLM server", { status: response.status, attempt });
+        } else {
+          logger.warn("Failed to fetch models from LLM server", { status: response.status, attempt });
+        }
+        if (attempt < retries) {
+          await new Promise((r) => setTimeout(r, 1e3 * attempt));
+          continue;
+        }
+        llmStatus = "disconnected";
+        return cached?.model ?? null;
+      }
+      const data = await response.json();
+      if (data.data && data.data.length > 0) {
+        const modelData = data.data[0];
+        const modelId = modelData.id;
+        modelCache.set(cacheKey, {
+          model: modelId,
+          modelInfo: modelData,
+          timestamp: now
+        });
+        lastActiveUrl = cacheKey;
+        llmStatus = "connected";
+        if (silent) {
+          logger.debug("Detected LLM model", {
+            model: modelId,
+            maxLen: modelData.max_model_len,
+            root: modelData.root
+          });
+        } else {
+          logger.info("Detected LLM model", {
+            model: modelId,
+            maxLen: modelData.max_model_len,
+            root: modelData.root
+          });
+        }
+        return modelId;
+      }
+      if (silent) {
+        logger.debug("LLM server returned empty models list");
+      } else {
+        logger.warn("LLM server returned empty models list");
+      }
+      llmStatus = "disconnected";
+      return null;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      if (silent) {
+        logger.debug("Could not detect model from LLM server", { error: errMsg, attempt });
+      } else {
+        logger.warn("Could not detect model from LLM server", { error: errMsg, attempt });
+      }
+      if (attempt < retries) {
+        await new Promise((r) => setTimeout(r, 1e3 * attempt));
+        continue;
+      }
+    }
+  }
+  llmStatus = "disconnected";
+  return cached?.model ?? null;
+}
+function getLlmStatus() {
+  return llmStatus;
+}
+function clearModelCache(url) {
+  if (url) {
+    modelCache.delete(getCacheKey(url));
+  } else {
+    modelCache.clear();
+  }
+  llmStatus = "unknown";
+}
+
+export {
+  SessionNotFoundError,
+  ensureVersionPrefix,
+  stripVersionPrefix,
+  buildModelsUrl,
+  createLLMClient,
+  detectModel,
+  getLlmStatus,
+  clearModelCache
+};
+//# sourceMappingURL=chunk-PQ56PX7L.js.map

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

@@ -61,9 +61,19 @@ var visionFallbackSchema = z.object({
   model: z.string().default("qwen3.5:0.8b"),
   timeout: z.number().default(120)
 });
+var mcpServerSchema = z.object({
+  transport: z.enum(["stdio", "http"]).default("stdio"),
+  command: z.string().optional(),
+  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 };
 var configSchema = z.object({
   providers: z.array(providerSchema).default([]),
+  mcpServers: z.record(z.string(), mcpServerSchema).optional(),
   defaultModelSelection: z.string().optional(),
   activeProviderId: z.string().optional(),
   activeWorkflowId: z.string().optional(),
@@ -74,6 +84,7 @@ var configSchema = z.object({
   visionFallback: visionFallbackSchema.optional()
 }).transform((data) => ({
   providers: data.providers ?? [],
+  mcpServers: data.mcpServers,
   defaultModelSelection: data.defaultModelSelection,
   activeProviderId: data.activeProviderId,
   activeWorkflowId: data.activeWorkflowId,
@@ -225,6 +236,7 @@ async function saveGlobalConfig(mode, config) {
   const configPath = getGlobalConfigPath(mode);
   const fullConfig = {
     providers: config.providers ?? [],
+    mcpServers: config.mcpServers,
     defaultModelSelection: config.defaultModelSelection,
     activeProviderId: config.activeProviderId,
     activeWorkflowId: config.activeWorkflowId,
@@ -260,6 +272,7 @@ function setDefaultModelSelection(config, providerId, model) {
   const defaultModelSelection = `${providerId}/${model}`;
   return {
     providers: config.providers?.map((p) => ({ ...p, isActive: p.id === providerId })) ?? [],
+    mcpServers: config.mcpServers,
     defaultModelSelection,
     activeProviderId: providerId,
     activeWorkflowId: config.activeWorkflowId,
@@ -287,6 +300,7 @@ function addProvider(config, provider) {
       ...(config.providers ?? []).map((p) => shouldActivate ? { ...p, isActive: false } : p),
       { ...newProvider, isActive: shouldActivate }
     ],
+    mcpServers: config.mcpServers,
     defaultModelSelection: shouldActivate ? `${newProvider.id}/auto` : config.defaultModelSelection,
     activeProviderId: shouldActivate ? newProvider.id : config.activeProviderId,
     activeWorkflowId: config.activeWorkflowId,
@@ -323,6 +337,7 @@ function removeProvider(config, providerId) {
   const newActiveId = wasActive && filtered.length > 0 ? filtered[0].id : wasActive ? void 0 : config.activeProviderId;
   return {
     providers: filtered.map((p) => ({ ...p, isActive: p.id === newActiveId })),
+    mcpServers: config.mcpServers,
     activeProviderId: newActiveId,
     defaultModelSelection: newDefaultModelSelection,
     activeWorkflowId: config.activeWorkflowId,
@@ -343,6 +358,7 @@ function activateProvider(config, providerId) {
   if (!provider) {
     return {
       providers: config.providers ?? [],
+      mcpServers: config.mcpServers,
       defaultModelSelection: config.defaultModelSelection,
       activeProviderId: config.activeProviderId,
       activeWorkflowId: config.activeWorkflowId,
@@ -360,6 +376,7 @@ function activateProvider(config, providerId) {
   }
   return {
     providers: (config.providers ?? []).map((p) => ({ ...p, isActive: p.id === providerId })),
+    mcpServers: config.mcpServers,
     defaultModelSelection: config.defaultModelSelection,
     activeProviderId: providerId,
     activeWorkflowId: config.activeWorkflowId,
@@ -419,4 +436,4 @@ export {
   activateProvider,
   mergeConfigs
 };
-//# sourceMappingURL=chunk-HPCGVAS4.js.map
+//# sourceMappingURL=chunk-SNQT7LNU.js.map

package/dist/{chunk-5BDVM6YI.js → chunk-YD6NDTKF.js}

@@ -26,4 +26,4 @@ export {
   isClientMessage,
   isServerMessage
 };
-//# sourceMappingURL=chunk-5BDVM6YI.js.map
+//# sourceMappingURL=chunk-YD6NDTKF.js.map

package/dist/{chunk-EZJUU54W.js → chunk-Z64KW2HD.js}

@@ -1,17 +1,20 @@
 import {
   PathAccessDeniedError,
   assembleAgentRequest,
+  computeDynamicContextHash,
   createAssemblyResult,
+  createToolRegistry,
   findAgentById,
   getAllInstructions,
   getConversationMessages,
   getEnabledSkillMetadata,
   getSubAgents,
+  getToolFingerprint,
   getToolRegistryForAgent,
   loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-2VDLXCLO.js";
+} from "./chunk-KPKSN362.js";
 import {
   TurnMetrics,
   WORKFLOW_KICKOFF_PROMPT,
@@ -36,16 +39,6 @@ import {
   logger
 } from "./chunk-K44MW7JJ.js";
 
-// src/server/chat/dynamic-context.ts
-import { createHash } from "crypto";
-function computeDynamicContextHash(instructionContent, skills) {
-  const dynamicInputs = JSON.stringify({
-    instructions: instructionContent,
-    skills: skills.map((s) => s.id).sort()
-  });
-  return createHash("sha256").update(dynamicInputs).digest("hex");
-}
-
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
   const { getSetting, SETTINGS_KEYS } = await import("./settings-6XX56F3F.js");
@@ -237,16 +230,30 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
       onMessage: options.onMessage,
       assembleRequest: (input) => {
         const cached = options.sessionManager.getCachedPrompt(options.sessionId);
+        const liveTools = createToolRegistry().definitions;
+        const toolFingerprint = getToolFingerprint(liveTools);
         if (cached) {
-          const currentHash = computeDynamicContextHash(instructionContent ?? "", skills);
+          const currentHash = computeDynamicContextHash(instructionContent ?? "", skills, toolFingerprint);
           if (cached.hash !== currentHash) {
+            logger.debug("assembleRequest: hash mismatch", {
+              sessionId: options.sessionId,
+              cachedHash: cached.hash,
+              currentHash,
+              cachedTools: cached.tools.map((t) => t.function.name),
+              liveTools: liveTools.map((t) => t.function.name)
+            });
             options.sessionManager.setDynamicContextChanged(options.sessionId, true);
+            options.sessionManager.setDebugDump(options.sessionId, {
+              cachedPrompt: cached.systemPrompt.slice(0, 5e3),
+              cachedTools: cached.tools.map((t) => t.function.name),
+              liveTools: liveTools.map((t) => t.function.name)
+            });
           }
           return createAssemblyResult({
             systemPrompt: cached.systemPrompt,
             messages: input.messages,
             injectedFiles: input.injectedFiles,
-            requestTools: input.promptTools,
+            requestTools: cached.tools.length > 0 ? cached.tools : liveTools,
             toolChoice: input.toolChoice
           });
         }
@@ -256,8 +263,8 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
           subAgentDefs,
           modelName: options.llmClient.getModel()
         });
-        const hash = computeDynamicContextHash(instructionContent ?? "", skills);
-        options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, hash);
+        const hash = computeDynamicContextHash(instructionContent ?? "", skills, toolFingerprint);
+        options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, result.tools, hash);
         return result;
       },
       getToolRegistry: () => getToolRegistryForAgent(agentDef),
@@ -309,9 +316,8 @@ function buildSnapshot(sessionManager, sessionId, _lastStats) {
 }
 
 export {
-  computeDynamicContextHash,
   runChatTurn,
   runAgentTurn,
   injectWorkflowKickoffIfNeeded
 };
-//# sourceMappingURL=chunk-EZJUU54W.js.map
+//# sourceMappingURL=chunk-Z64KW2HD.js.map

package/dist/cli/dev.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-FQIT7VIA.js";
+} from "../chunk-3IKRNKPI.js";
 import {
   logger
 } from "../chunk-K44MW7JJ.js";

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-FQIT7VIA.js";
+} from "../chunk-3IKRNKPI.js";
 import {
   logger
 } from "../chunk-K44MW7JJ.js";

package/dist/{config-BU66P4KX.js → config-Z66BQTNX.js}

@@ -13,7 +13,7 @@ import {
   saveGlobalConfig,
   setDefaultModelSelection,
   updateProvider
-} from "./chunk-HPCGVAS4.js";
+} from "./chunk-SNQT7LNU.js";
 import "./chunk-CQGTEGKL.js";
 export {
   activateProvider,
@@ -31,4 +31,4 @@ export {
   setDefaultModelSelection,
   updateProvider
 };
-//# sourceMappingURL=config-BU66P4KX.js.map
+//# sourceMappingURL=config-Z66BQTNX.js.map

package/dist/{orchestrator-WXEZHUVQ.js → orchestrator-KRCVDTZ6.js}

@@ -2,8 +2,9 @@ import {
   injectWorkflowKickoffIfNeeded,
   runAgentTurn,
   runChatTurn
-} from "./chunk-EZJUU54W.js";
-import "./chunk-2VDLXCLO.js";
+} from "./chunk-Z64KW2HD.js";
+import "./chunk-KPKSN362.js";
+import "./chunk-XAMAYRDA.js";
 import {
   TurnMetrics,
   createChatDoneEvent,
@@ -15,14 +16,15 @@ import {
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
-import "./chunk-XAMAYRDA.js";
+import "./chunk-NWO6GRYE.js";
 import "./chunk-SYG2ENUQ.js";
 import "./chunk-LX66KJPL.js";
-import "./chunk-3QB2RMX2.js";
+import "./chunk-F4PMNP7S.js";
 import "./chunk-EU3WWTFH.js";
 import "./chunk-RFNEDBVO.js";
 import "./chunk-FBGWG4N6.js";
-import "./chunk-5BDVM6YI.js";
+import "./chunk-YD6NDTKF.js";
+import "./chunk-SNQT7LNU.js";
 import "./chunk-CQGTEGKL.js";
 import "./chunk-Z4SWOUWC.js";
 import "./chunk-K44MW7JJ.js";
@@ -37,4 +39,4 @@ export {
   runAgentTurn,
   runChatTurn
 };
-//# sourceMappingURL=orchestrator-WXEZHUVQ.js.map
+//# sourceMappingURL=orchestrator-KRCVDTZ6.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfox",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "description": "Local-LLM-first agentic coding assistant",
   "type": "module",
   "bin": {
@@ -60,6 +60,7 @@
   "dependencies": {
     "@clack/prompts": "^1.1.0",
     "@fontsource/jetbrains-mono": "^5.2.8",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",
     "bash-language-server": "^5.6.0",
@@ -79,12 +80,11 @@
     "react-syntax-highlighter": "^16.1.1",
     "remark-gfm": "^4.0.1",
     "shiki": "^4.2.0",
-    "sql-language-server": "^1.7.1",
     "strip-ansi": "^7.2.0",
     "turndown": "^7.2.2",
-    "undici": "^8.5.0",
     "typescript": "^5.8.2",
     "typescript-language-server": "^5.1.3",
+    "undici": "^8.5.0",
     "vite": "^6.1.0",
     "vscode-jsonrpc": "^8.2.1",
     "vscode-langservers-extracted": "^4.10.0",