openfox 2.0.129 → 2.0.130

package/dist/chunk-DQTN4B33.js

@@ -0,0 +1,235 @@
+import {
+  clearMcpOAuthEntry,
+  clearMcpOAuthTokens,
+  readMcpOAuthEntry,
+  saveMcpOAuthClientInformation,
+  saveMcpOAuthCodeVerifier,
+  saveMcpOAuthState,
+  saveMcpOAuthTokens
+} from "./chunk-IJ53Y77N.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+
+// src/server/mcp/oauth-provider.ts
+import { randomBytes } from "crypto";
+import {
+  discoverAuthorizationServerMetadata,
+  discoverOAuthProtectedResourceMetadata
+} from "@modelcontextprotocol/sdk/client/auth.js";
+function persistentStorage(serverName, serverUrl) {
+  return {
+    read: () => readMcpOAuthEntry(serverName, serverUrl),
+    saveClientInformation: (info) => saveMcpOAuthClientInformation(serverName, serverUrl, info),
+    saveTokens: (tokens) => saveMcpOAuthTokens(serverName, serverUrl, tokens),
+    saveCodeVerifier: (verifier) => saveMcpOAuthCodeVerifier(serverName, serverUrl, verifier),
+    saveState: (state) => saveMcpOAuthState(serverName, serverUrl, state),
+    clearTokens: () => clearMcpOAuthTokens(serverName, serverUrl),
+    clearAll: () => clearMcpOAuthEntry(serverName)
+  };
+}
+function memoryStorage() {
+  let entry = {};
+  return {
+    read: async () => entry,
+    saveClientInformation: async (info) => {
+      entry.clientInformation = info;
+    },
+    saveTokens: async (tokens) => {
+      entry.tokens = tokens;
+    },
+    saveCodeVerifier: async (verifier) => {
+      entry.codeVerifier = verifier;
+    },
+    saveState: async (state) => {
+      entry.state = state;
+    },
+    clearTokens: async () => {
+      delete entry.tokens;
+    },
+    clearAll: async () => {
+      entry = {};
+    }
+  };
+}
+var CALLBACK_PATH = "/api/mcp/oauth/callback";
+var serverPort = 10369;
+function setMcpOAuthServerPort(port) {
+  serverPort = port;
+}
+function getMcpOAuthRedirectUri() {
+  const publicUrl = process.env["OPENFOX_PUBLIC_URL"];
+  if (!publicUrl) return `http://127.0.0.1:${serverPort}${CALLBACK_PATH}`;
+  let base;
+  try {
+    base = new URL(publicUrl);
+  } catch {
+    throw new Error("OPENFOX_PUBLIC_URL is not a valid URL");
+  }
+  if (base.protocol !== "http:" && base.protocol !== "https:") {
+    throw new Error("OPENFOX_PUBLIC_URL must be an http or https URL");
+  }
+  base.pathname = `${base.pathname.replace(/\/+$/, "")}${CALLBACK_PATH}`;
+  base.search = "";
+  base.hash = "";
+  return base.toString();
+}
+var McpOAuthProvider = class _McpOAuthProvider {
+  constructor(serverName, serverUrl, redirectUri = getMcpOAuthRedirectUri(), storage = persistentStorage(serverName, serverUrl)) {
+    this.serverName = serverName;
+    this.serverUrl = serverUrl;
+    this.redirectUri = redirectUri;
+    this.storage = storage;
+  }
+  serverName;
+  serverUrl;
+  redirectUri;
+  storage;
+  authorizationUrl = null;
+  /** Kept for log context and for callers that need the identity of the server being probed. */
+  get name() {
+    return this.serverName;
+  }
+  get url() {
+    return this.serverUrl;
+  }
+  get redirectUrl() {
+    return this.redirectUri;
+  }
+  get clientMetadata() {
+    return {
+      client_name: "OpenFox",
+      redirect_uris: [this.redirectUri],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"]
+    };
+  }
+  /** Set once the SDK has built an authorization URL, null while the stored tokens still work. */
+  get pendingAuthorizationUrl() {
+    return this.authorizationUrl;
+  }
+  async state() {
+    const value = randomBytes(32).toString("base64url");
+    await this.storage.saveState(value);
+    return value;
+  }
+  async clientInformation() {
+    const entry = await this.storage.read();
+    return entry?.clientInformation;
+  }
+  async saveClientInformation(clientInformation) {
+    await this.storage.saveClientInformation(clientInformation);
+  }
+  async tokens() {
+    const entry = await this.storage.read();
+    return entry?.tokens;
+  }
+  async saveTokens(tokens) {
+    await this.storage.saveTokens(tokens);
+  }
+  redirectToAuthorization(authorizationUrl) {
+    this.authorizationUrl = authorizationUrl;
+  }
+  async saveCodeVerifier(codeVerifier) {
+    await this.storage.saveCodeVerifier(codeVerifier);
+  }
+  async codeVerifier() {
+    const entry = await this.storage.read();
+    if (!entry?.codeVerifier) {
+      throw new Error("No stored PKCE verifier for this server, start the authorization again");
+    }
+    return entry.codeVerifier;
+  }
+  /** Lets the SDK recover on its own when the server rejects the stored client or grant. */
+  async invalidateCredentials(scope) {
+    if (scope === "discovery") return;
+    if (scope === "all" || scope === "client") {
+      await this.storage.clearAll();
+      return;
+    }
+    await this.storage.clearTokens();
+  }
+  /**
+   * A provider whose reads and writes never reach the store.
+   *
+   * The transport runs one of these on every connection, and a connection happens to receive a 401
+   * exactly when no valid token exists — the same moment an explicit authorization may be pending.
+   * Letting that probe run against the store would overwrite the pending state and verifier with its
+   * own, and the browser callback would then no longer match anything. The probe still gets a full
+   * SDK flow against its private copy, so a 401 during a plain reconnect stays a plain failure.
+   */
+  static forBackgroundProbe(serverName, serverUrl) {
+    return new _McpOAuthProvider(serverName, serverUrl, getMcpOAuthRedirectUri(), memoryStorage());
+  }
+};
+async function buildOAuthProbeUrl(provider) {
+  try {
+    const resource = await discoverOAuthProtectedResourceMetadata(provider.url);
+    const authorizationServerUrl = resource?.authorization_servers?.[0] ?? provider.url;
+    const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl);
+    if (!metadata?.authorization_endpoint) return void 0;
+    const client = await provider.clientInformation();
+    if (!client) return void 0;
+    const url = new URL(metadata.authorization_endpoint);
+    url.searchParams.set("client_id", client.client_id);
+    return url;
+  } catch {
+    return void 0;
+  }
+}
+var STALE_CLIENT_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+function isUnknownClientBody(body) {
+  const lowered = body.toLowerCase();
+  return lowered.includes("unrecognized client") || lowered.includes("unknown client") || lowered.includes("invalid client") || lowered.includes("client not found") || lowered.includes("client_id not found");
+}
+var PROBE_TIMEOUT_MS = 5e3;
+var probeCache = /* @__PURE__ */ new Map();
+var PROBE_TTL_MS = 10 * 60 * 1e3;
+function resetProbeCache() {
+  probeCache.clear();
+}
+async function rejectStaleOAuthClient(provider, fetchImpl = fetch) {
+  const client = await provider.clientInformation();
+  if (!client) return;
+  const cacheKey = `${provider.name}:${provider.url}:${client.client_id}`;
+  const cached = probeCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) {
+    if (cached.result) await provider.invalidateCredentials("client");
+    return;
+  }
+  const authorizationUrl = await buildOAuthProbeUrl(provider);
+  if (!authorizationUrl) return;
+  let response;
+  try {
+    response = await fetchImpl(authorizationUrl, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+    });
+  } catch {
+    return;
+  }
+  const body = await response.text().catch(() => "");
+  let stale = STALE_CLIENT_STATUSES.has(response.status);
+  if (!stale && (response.status === 400 || response.status === 422)) {
+    stale = isUnknownClientBody(body);
+  }
+  probeCache.set(cacheKey, { result: stale, expiresAt: Date.now() + PROBE_TTL_MS });
+  if (stale) {
+    logger.warn("Discarding an OAuth client the authorization server no longer recognizes", {
+      server: provider.name,
+      status: response.status,
+      body: body.slice(0, 200)
+    });
+    await provider.invalidateCredentials("client");
+  }
+}
+
+export {
+  setMcpOAuthServerPort,
+  getMcpOAuthRedirectUri,
+  McpOAuthProvider,
+  buildOAuthProbeUrl,
+  resetProbeCache,
+  rejectStaleOAuthClient
+};
+//# sourceMappingURL=chunk-DQTN4B33.js.map

package/dist/{chunk-RV5G7QQU.js → chunk-DQTXXHD2.js}

@@ -11,11 +11,11 @@ import {
 } from "./chunk-I72ACQ6R.js";
 import {
   getPlatformShell
-} from "./chunk-66MG44TF.js";
+} from "./chunk-6QZVAOSA.js";
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-3DZSHRXE.js";
 
 // src/server/utils/shell.ts
 import { spawn } from "child_process";
@@ -214,4 +214,4 @@ export {
   getSessionProcesses2 as getSessionProcesses,
   getProcessLogs
 };
-//# sourceMappingURL=chunk-RV5G7QQU.js.map
+//# sourceMappingURL=chunk-DQTXXHD2.js.map

package/dist/{chunk-MYNNMV75.js → chunk-DYIDDGMN.js}

@@ -2,45 +2,52 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-OHTBWA7L.js";
+} from "./chunk-35GQEIH2.js";
 import {
   launchWorkflowRun
-} from "./chunk-2COZT3YI.js";
+} from "./chunk-2OMXXCJJ.js";
 import {
   runChatTurn
-} from "./chunk-7RIEI2TE.js";
+} from "./chunk-EVVWDRM5.js";
 import {
   devServerManager
-} from "./chunk-L24A6GZ7.js";
+} from "./chunk-X24XN2M2.js";
 import {
-  applyDynamicContext,
-  computeSessionHash,
-  computeUnifiedDiff
-} from "./chunk-PHP7PLFX.js";
+  gitSpawnEnv
+} from "./chunk-J7GAZGZT.js";
 import {
   appendCompactionPrompt
-} from "./chunk-IJFKJ5D6.js";
+} from "./chunk-VUIXQ6X4.js";
 import {
   hasRecentLLMFailure,
   interruptLLMRetryWait
-} from "./chunk-6LX43YRA.js";
+} from "./chunk-7ET46SNE.js";
 import {
   onProcessEvent
-} from "./chunk-RV5G7QQU.js";
+} from "./chunk-DQTXXHD2.js";
 import {
   killProcessTree
 } from "./chunk-I72ACQ6R.js";
 import {
-  gitSpawnEnv
-} from "./chunk-J7GAZGZT.js";
+  applyDynamicContext,
+  computeSessionHash,
+  computeUnifiedDiff
+} from "./chunk-25DAVVTP.js";
+import {
+  getPendingQuestionsForSession,
+  provideAnswer
+} from "./chunk-JURM3RPZ.js";
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-AYCB32NI.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-JKRMMNUR.js";
+import {
+  getRuntimeConfig
+} from "./chunk-JHA2SPCU.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -55,26 +62,19 @@ import {
   parseClientMessage,
   serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-567L5OJ6.js";
+} from "./chunk-P57IBMK4.js";
 import {
   getPlatformShell
-} from "./chunk-66MG44TF.js";
-import {
-  getPendingQuestionsForSession,
-  provideAnswer
-} from "./chunk-JURM3RPZ.js";
-import {
-  getRuntimeConfig
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-6QZVAOSA.js";
 import {
   getMaxVisibleItems
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-3DZSHRXE.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
 import {
   createServerMessage
-} from "./chunk-ATWOXI52.js";
+} from "./chunk-HCYSGLY2.js";
 
 // src/server/ws/server.ts
 import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
@@ -434,6 +434,20 @@ async function tokenFromPassword(password) {
   });
   return sign;
 }
+async function currentSessionToken() {
+  const auth = getAuthConfig();
+  if (!auth?.encryptedPassword) return null;
+  const privateKey = await loadPrivateKey();
+  try {
+    const password = privateDecrypt(
+      { key: privateKey, padding: 1 },
+      Buffer.from(auth.encryptedPassword, "base64")
+    ).toString();
+    return await tokenFromPassword(password);
+  } catch {
+    return null;
+  }
+}
 async function isValidToken(token) {
   if (!cachedAuth?.encryptedPassword) return false;
   const privateKey = await loadPrivateKey();
@@ -1299,19 +1313,21 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       }
       const session = sessionManager.requireSession(sessionId);
       try {
-        const { buildCachedPrompt } = await import("./dynamic-context-ZVE733UI.js");
-        const allAgents = await import("./registry-Z4GVYFTV.js");
+        const { buildCachedPrompt, computePreviewToolDiff } = await import("./dynamic-context-2VLACYK4.js");
+        const allAgents = await import("./registry-KFFZFIZT.js");
         const agentDef = allAgents.findAgentById(session.mode, await allAgents.loadAllAgentsDefault()) ?? allAgents.findAgentById("planner", await allAgents.loadAllAgentsDefault());
         const modelName = session.providerModel ?? _providerManager?.getCurrentModel();
-        const { systemPrompt: newPrompt, hash: newHash } = await buildCachedPrompt(
-          sessionManager,
-          sessionId,
-          agentDef,
-          modelName
-        );
+        const {
+          systemPrompt: newPrompt,
+          tools: newTools,
+          hash: newHash
+        } = await buildCachedPrompt(sessionManager, sessionId, agentDef, modelName);
         const oldCached = sessionManager.getCachedPrompt(sessionId);
         const oldPrompt = oldCached?.systemPrompt;
         const diff = oldPrompt ? computeUnifiedDiff(oldPrompt, newPrompt) : [];
+        const { getToolRegistryForAgent } = await import("./tools-SSPC3UQZ.js");
+        const unfilteredTools = getToolRegistryForAgent(agentDef).definitions;
+        const toolDiff = computePreviewToolDiff(oldCached?.tools, unfilteredTools, newTools);
         send({
           type: "context.preview",
           payload: {
@@ -1319,7 +1335,8 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
             newPrompt,
             oldHash: oldCached?.hash,
             newHash,
-            diff
+            diff,
+            ...toolDiff.length > 0 ? { toolDiff } : {}
           },
           id: message.id
         });
@@ -1620,8 +1637,9 @@ export {
   hasPassword,
   verifyPassword,
   tokenFromPassword,
+  currentSessionToken,
   isValidToken,
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-MYNNMV75.js.map
+//# sourceMappingURL=chunk-DYIDDGMN.js.map

package/dist/{chunk-DABWCAXS.js → chunk-EUOWCVU6.js}

@@ -589,7 +589,7 @@ function convertTools(tools) {
     }
   }));
 }
-async function buildChatCompletionCreateParams(model, request, profile, capabilities, reasoningEffort, isStreaming, thinkingField, sendReasoningInMessages) {
+async function buildChatCompletionCreateParams(model, request, profile, capabilities, reasoningEffort, isStreaming, thinkingField, sendReasoningInMessages, apiProtocol) {
   const userVisionOverride = request.modelSettings?.supportsVision;
   const modelSupportsVision = userVisionOverride ?? profile.supportsVision ?? false;
   const convertedMessages = await convertMessages(
@@ -608,7 +608,7 @@ async function buildChatCompletionCreateParams(model, request, profile, capabili
     ...request.tools?.length ? { tools: convertTools(request.tools) } : {},
     ...request.toolChoice ? { tool_choice: request.toolChoice } : {},
     temperature,
-    max_tokens: maxTokens,
+    ...capabilities.usesMaxCompletionTokens ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
     ...topP !== void 0 && { top_p: topP },
     stream: isStreaming,
     ...isStreaming ? { stream_options: { include_usage: true } } : {}
@@ -621,7 +621,10 @@ async function buildChatCompletionCreateParams(model, request, profile, capabili
     ;
     params["num_ctx"] = request.modelSettings.numCtx;
   }
-  const resolvedEffort = reasoningEffort ?? request.reasoningEffort;
+  let resolvedEffort = reasoningEffort ?? request.reasoningEffort;
+  if (request.tools?.length && apiProtocol !== "responses" && profile.apiProtocol === "responses") {
+    resolvedEffort = "none";
+  }
   const queryParams = request.modelSettings?.queryParams;
   const hasQueryParams = queryParams && Object.keys(queryParams).length > 0;
   const hasExplicitModelSettings = hasQueryParams || !!request.modelSettings?.chatTemplateKwargs;
@@ -686,7 +689,16 @@ async function buildChatCompletionCreateParams(model, request, profile, capabili
   return { params, modelParams };
 }
 async function buildCreateParamsFromInput(input, isStreaming) {
-  const { model, request, profile, capabilities, reasoningEffort, thinkingField, sendReasoningInMessages } = input;
+  const {
+    model,
+    request,
+    profile,
+    capabilities,
+    reasoningEffort,
+    thinkingField,
+    sendReasoningInMessages,
+    apiProtocol
+  } = input;
   return buildChatCompletionCreateParams(
     model,
     request,
@@ -695,7 +707,8 @@ async function buildCreateParamsFromInput(input, isStreaming) {
     reasoningEffort,
     isStreaming,
     thinkingField,
-    sendReasoningInMessages
+    sendReasoningInMessages,
+    apiProtocol
   );
 }
 var buildNonStreamingCreateParams = (input) => buildCreateParamsFromInput(input, false);
@@ -735,4 +748,4 @@ export {
   buildStreamingCreateParams,
   mapFinishReason
 };
-//# sourceMappingURL=chunk-DABWCAXS.js.map
+//# sourceMappingURL=chunk-EUOWCVU6.js.map

package/dist/{chunk-7RIEI2TE.js → chunk-EVVWDRM5.js}

@@ -4,42 +4,45 @@ import {
   getToolRegistryForAgent,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-L24A6GZ7.js";
+} from "./chunk-X24XN2M2.js";
+import {
+  TurnMetrics,
+  createChatDoneEvent,
+  createMessageStartEvent
+} from "./chunk-7ET46SNE.js";
 import {
   buildCachedPrompt,
+  checkToolChangesAndInject,
   computeDynamicContextHash,
   getToolFingerprint
-} from "./chunk-PHP7PLFX.js";
+} from "./chunk-25DAVVTP.js";
 import {
   getAllInstructions,
   getEnabledSkillMetadata
-} from "./chunk-ZIL6VKLU.js";
-import {
-  TurnMetrics,
-  createChatDoneEvent,
-  createMessageStartEvent
-} from "./chunk-6LX43YRA.js";
+} from "./chunk-64N4CZFT.js";
 import {
   buildAgentReminder,
-  buildAgentSmallReminder
-} from "./chunk-GIJUWPRQ.js";
+  buildAgentSmallReminder,
+  buildTopLevelSystemPrompt
+} from "./chunk-CGCEAKG5.js";
 import {
   PathAccessDeniedError
-} from "./chunk-26WS7AH6.js";
+} from "./chunk-VJNA5AOB.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-AYCB32NI.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-JKRMMNUR.js";
 import {
   findAgentById,
   getRuntimeConfig,
+  getSubAgents,
   loadAllAgentsDefault,
   resolveDefaultAgentId
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-JHA2SPCU.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -49,7 +52,7 @@ import {
 
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
-  const { getSetting, SETTINGS_KEYS } = await import("./settings-VOWWO4VG.js");
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-LMAMF2X7.js");
   const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
   if (!raw) {
     const oldXmlProtection = getSetting("llm.disableXmlProtection");
@@ -244,6 +247,27 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
   const runtimeConfig = getRuntimeConfig();
   const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
   const skills = await getEnabledSkillMetadata(configDir, options.sessionManager.getProjectWorkdir(options.sessionId));
+  if (!options.warmup) {
+    const modelName = agentLlmClient.getModel();
+    await checkToolChangesAndInject(
+      options.sessionManager,
+      options.sessionId,
+      agentDef,
+      {
+        modelName,
+        instructionContent: instructionContent ?? "",
+        skills,
+        buildNewSystemPrompt: () => buildTopLevelSystemPrompt(
+          session.workdir,
+          instructionContent || void 0,
+          skills,
+          getSubAgents(allAgents),
+          modelName
+        )
+      },
+      append
+    );
+  }
   return runTopLevelAgentLoop(
     {
       mode: agentId,
@@ -291,6 +315,7 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
           agentLlmClient.getModel()
         );
         options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, result.tools, result.hash);
+        options.sessionManager.setAnnouncedPromptHash(options.sessionId, result.promptHash);
         return createAssemblyResult({
           systemPrompt: result.systemPrompt,
           messages: input.messages,
@@ -302,6 +327,10 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
       getToolRegistry: () => getToolRegistryForAgent(agentDef, options.sessionId),
       getConversationMessages: buildGetConversationMessages(options.sessionId, resolveAgentClient, append),
       injectAgentReminder: () => injectAgentReminder(options.sessionId, agentDef),
+      rebuildCachedContext: async () => {
+        const { applyDynamicContext } = await import("./dynamic-context-2VLACYK4.js");
+        await applyDynamicContext(options.sessionManager, options.sessionId, agentLlmClient.getModel());
+      },
       ...options.initialCompacting ? { initialCompacting: true } : {},
       ...callbacks?.injectKickoff ? { injectKickoff: callbacks.injectKickoff } : {},
       ...callbacks?.onToolExecuted ? { onToolExecuted: callbacks.onToolExecuted } : {},
@@ -329,4 +358,4 @@ export {
   runChatTurn,
   runAgentTurn
 };
-//# sourceMappingURL=chunk-7RIEI2TE.js.map
+//# sourceMappingURL=chunk-EVVWDRM5.js.map

package/dist/{chunk-ATWOXI52.js → chunk-HCYSGLY2.js}

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

package/dist/{chunk-KBESUA3W.js → chunk-JHA2SPCU.js}

@@ -7,7 +7,7 @@ import {
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-3DZSHRXE.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -352,4 +352,4 @@ export {
   getOverrideAgentIds,
   resolveDefaultAgentId
 };
-//# sourceMappingURL=chunk-KBESUA3W.js.map
+//# sourceMappingURL=chunk-JHA2SPCU.js.map

package/dist/{chunk-ZIYETXOW.js → chunk-JKRMMNUR.js}

@@ -1,9 +1,9 @@
+import {
+  resolveDefaultAgentId
+} from "./chunk-JHA2SPCU.js";
 import {
   normalizeAskOptions
 } from "./chunk-LCLH6ZUL.js";
-import {
-  resolveDefaultAgentId
-} from "./chunk-KBESUA3W.js";
 
 // src/server/events/apply-events.ts
 function markComplete(msg, reason) {
@@ -965,4 +965,4 @@ export {
   buildSnapshot,
   buildSnapshotFromSessionState
 };
-//# sourceMappingURL=chunk-ZIYETXOW.js.map
+//# sourceMappingURL=chunk-JKRMMNUR.js.map