openfox 2.0.12 → 2.0.14

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/cli/dev.js

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

package/dist/cli/index.js

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

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

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

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

@@ -2,8 +2,9 @@ import {
   injectWorkflowKickoffIfNeeded,
   runAgentTurn,
   runChatTurn
-} from "./chunk-EZJUU54W.js";
-import "./chunk-2VDLXCLO.js";
+} from "./chunk-7GJ6XYAF.js";
+import "./chunk-4ZTQO5JP.js";
+import "./chunk-XAMAYRDA.js";
 import {
   TurnMetrics,
   createChatDoneEvent,
@@ -15,7 +16,6 @@ import {
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
-import "./chunk-XAMAYRDA.js";
 import "./chunk-SYG2ENUQ.js";
 import "./chunk-LX66KJPL.js";
 import "./chunk-3QB2RMX2.js";
@@ -37,4 +37,4 @@ export {
   runAgentTurn,
   runChatTurn
 };
-//# sourceMappingURL=orchestrator-WXEZHUVQ.js.map
+//# sourceMappingURL=orchestrator-VP74KOXI.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfox",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "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",
@@ -82,9 +83,9 @@
     "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",

package/dist/{processor-GA5NG3T7.js → processor-CCXZYLX6.js}

@@ -6,12 +6,12 @@ import {
   getSessionMessageCount,
   needsNameGenerationCheck
 } from "./chunk-TIKQWNYK.js";
-import "./chunk-2VDLXCLO.js";
+import "./chunk-4ZTQO5JP.js";
+import "./chunk-XAMAYRDA.js";
 import "./chunk-L7TDUIQY.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
-import "./chunk-XAMAYRDA.js";
 import {
   getEventStore
 } from "./chunk-SYG2ENUQ.js";
@@ -191,7 +191,7 @@ var QueueProcessor = class {
       backend: provider?.backend ?? llmClient.getBackend(),
       model: llmClient.getModel()
     };
-    const { runChatTurn } = await import("./orchestrator-WXEZHUVQ.js");
+    const { runChatTurn } = await import("./orchestrator-VP74KOXI.js");
     const runChatTurnParams = buildRunChatTurnParams({
       sessionManager,
       sessionId,
@@ -239,4 +239,4 @@ var QueueProcessor = class {
 export {
   QueueProcessor
 };
-//# sourceMappingURL=processor-GA5NG3T7.js.map
+//# sourceMappingURL=processor-CCXZYLX6.js.map

package/dist/{protocol-CaLuIetw.d.ts → protocol-BE5dRtYw.d.ts}

@@ -483,6 +483,15 @@ interface Config {
     workdir: string;
     /** Active workflow ID (defaults to "default") */
     activeWorkflowId?: string | undefined;
+    /** MCP server configurations */
+    mcpServers?: Record<string, {
+        transport: 'stdio' | 'http';
+        command?: string;
+        args?: string[];
+        env?: Record<string, string>;
+        url?: string;
+        disabledTools?: string[];
+    }> | undefined;
 }
 interface ElementData {
     tag: string;

package/dist/{provider-QPECLUZ7.js → provider-QUJQLVOM.js}

@@ -5,12 +5,14 @@ import {
   loadGlobalConfig,
   removeProvider,
   saveGlobalConfig
-} from "./chunk-HPCGVAS4.js";
+} from "./chunk-PP6VQXQW.js";
 import "./chunk-CQGTEGKL.js";
 import {
-  detectModel,
   fetchAvailableModelsFromBackend
-} from "./chunk-A52FXWJX.js";
+} from "./chunk-3SGGOBCL.js";
+import {
+  detectModel
+} from "./chunk-PQ56PX7L.js";
 import "./chunk-Z4SWOUWC.js";
 import "./chunk-K44MW7JJ.js";
 
@@ -252,7 +254,7 @@ async function runProviderAdd(mode) {
     isActive: makeActive
   });
   if (makeActive) {
-    const { setDefaultModelSelection } = await import("./config-BU66P4KX.js");
+    const { setDefaultModelSelection } = await import("./config-YFHA5MWV.js");
     newConfig = setDefaultModelSelection(
       newConfig,
       newConfig.providers[newConfig.providers.length - 1].id,
@@ -380,4 +382,4 @@ export {
   runProviderRemove,
   runProviderUse
 };
-//# sourceMappingURL=provider-QPECLUZ7.js.map
+//# sourceMappingURL=provider-QUJQLVOM.js.map

package/dist/{provider-manager-YA2WALTF.js → provider-manager-DETXLDKW.js}

@@ -3,7 +3,8 @@ import {
   fetchAvailableModelsFromBackend,
   fetchModelsWithContext,
   parseDefaultModelSelection
-} from "./chunk-A52FXWJX.js";
+} from "./chunk-3SGGOBCL.js";
+import "./chunk-PQ56PX7L.js";
 import "./chunk-Z4SWOUWC.js";
 import "./chunk-K44MW7JJ.js";
 export {
@@ -12,4 +13,4 @@ export {
   fetchModelsWithContext,
   parseDefaultModelSelection
 };
-//# sourceMappingURL=provider-manager-YA2WALTF.js.map
+//# sourceMappingURL=provider-manager-DETXLDKW.js.map

package/dist/{serve-5BSOEK54.js → serve-GA2UIHHB.js}

@@ -1,15 +1,17 @@
 import {
   VERSION,
   createServer
-} from "./chunk-WF3MA65W.js";
+} from "./chunk-4U45A7B3.js";
+import "./chunk-4W2Z4B5U.js";
 import "./chunk-FWJ6YXGA.js";
-import "./chunk-EZJUU54W.js";
-import "./chunk-2VDLXCLO.js";
+import "./chunk-NWO6GRYE.js";
+import "./chunk-7GJ6XYAF.js";
+import "./chunk-4ZTQO5JP.js";
+import "./chunk-XAMAYRDA.js";
 import "./chunk-L7TDUIQY.js";
 import "./chunk-DL6ZILAF.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
-import "./chunk-XAMAYRDA.js";
 import {
   loadConfig
 } from "./chunk-SYG2ENUQ.js";
@@ -24,13 +26,14 @@ import {
   getActiveProvider,
   getDefaultModel,
   loadGlobalConfig
-} from "./chunk-HPCGVAS4.js";
+} from "./chunk-PP6VQXQW.js";
 import {
   ensureDataDirExists,
   getDatabasePath,
   getGlobalConfigPath
 } from "./chunk-CQGTEGKL.js";
-import "./chunk-A52FXWJX.js";
+import "./chunk-3SGGOBCL.js";
+import "./chunk-PQ56PX7L.js";
 import "./chunk-Z4SWOUWC.js";
 import {
   logger
@@ -167,6 +170,7 @@ async function runServe(options) {
     activeProviderId: globalConfig.activeProviderId,
     activeWorkflowId: globalConfig.activeWorkflowId,
     defaultModelSelection: globalConfig.defaultModelSelection,
+    mcpServers: globalConfig.mcpServers,
     // Workdir precedence: .env override → global config → process.cwd()
     // Normalize: remove trailing slash to prevent double slashes in paths
     workdir: (process.env["OPENFOX_WORKDIR"] ?? globalConfig.workspace?.workdir ?? process.cwd()).replace(/\/$/, "")
@@ -189,4 +193,4 @@ async function runServe(options) {
 export {
   runServe
 };
-//# sourceMappingURL=serve-5BSOEK54.js.map
+//# sourceMappingURL=serve-GA2UIHHB.js.map

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { aO as ToolCall, c as Attachment, R as Diagnostic, an as Provider, ab as ModelConfig, aA as Session, aJ as SessionSummary, aj as Project, aE as SessionMode, aG as SessionPhase, M as Message, J as Criterion, L as CriterionStatus, a8 as MetadataEntry, aw as QueuedMessage, F as ContextState, O as DangerLevel$1, ay as ServerMessage, aL as StatsIdentity, aR as ToolResult, D as Config } from '../protocol-CaLuIetw.js';
+import { aO as ToolCall, c as Attachment, R as Diagnostic, an as Provider, ab as ModelConfig, aA as Session, aJ as SessionSummary, aj as Project, aE as SessionMode, aG as SessionPhase, M as Message, J as Criterion, L as CriterionStatus, a8 as MetadataEntry, aw as QueuedMessage, F as ContextState, O as DangerLevel$1, ay as ServerMessage, aL as StatsIdentity, aR as ToolResult, D as Config } from '../protocol-BE5dRtYw.js';
 import { Server } from 'node:http';
 
 interface LLMMessage {
@@ -478,9 +478,10 @@ declare class SessionManager {
      * Update execution state.
      */
     updateExecutionState(sessionId: string, updates: Record<string, unknown>): void;
-    setCachedPrompt(sessionId: string, systemPrompt: string, hash: string): void;
+    setCachedPrompt(sessionId: string, systemPrompt: string, tools: LLMToolDefinition[], hash: string): void;
     getCachedPrompt(sessionId: string): {
         systemPrompt: string;
+        tools: LLMToolDefinition[];
         hash: string;
     } | undefined;
     setDynamicContextChanged(sessionId: string, changed: boolean): void;

package/dist/server/index.js

@@ -1,15 +1,17 @@
 import {
   createServer,
   createServerHandle
-} from "../chunk-WF3MA65W.js";
+} from "../chunk-4U45A7B3.js";
+import "../chunk-4W2Z4B5U.js";
 import "../chunk-FWJ6YXGA.js";
-import "../chunk-EZJUU54W.js";
-import "../chunk-2VDLXCLO.js";
+import "../chunk-NWO6GRYE.js";
+import "../chunk-7GJ6XYAF.js";
+import "../chunk-4ZTQO5JP.js";
+import "../chunk-XAMAYRDA.js";
 import "../chunk-L7TDUIQY.js";
 import "../chunk-DL6ZILAF.js";
 import "../chunk-PBGOZMVY.js";
 import "../chunk-VRGRAQDG.js";
-import "../chunk-XAMAYRDA.js";
 import "../chunk-SYG2ENUQ.js";
 import "../chunk-LX66KJPL.js";
 import "../chunk-3QB2RMX2.js";
@@ -19,7 +21,8 @@ import "../chunk-FBGWG4N6.js";
 import "../chunk-VUQCQXXJ.js";
 import "../chunk-5BDVM6YI.js";
 import "../chunk-CQGTEGKL.js";
-import "../chunk-A52FXWJX.js";
+import "../chunk-3SGGOBCL.js";
+import "../chunk-PQ56PX7L.js";
 import "../chunk-Z4SWOUWC.js";
 import "../chunk-K44MW7JJ.js";
 export {