openfox 2.0.129 → 2.0.131

package/dist/{chunk-OHTBWA7L.js → chunk-6SUBBT2M.js}

@@ -1,27 +1,27 @@
+import {
+  getPendingQuestionsForSession
+} from "./chunk-JURM3RPZ.js";
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-FGNJMKDV.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-M5T4RDPJ.js";
 import {
   updateSessionMetadata
-} from "./chunk-AQBRI7TM.js";
+} from "./chunk-KWAHD2JA.js";
+import {
+  getRuntimeConfig
+} from "./chunk-ELYHHEYL.js";
 import {
   createContextStateMessage,
   createSessionStateMessage
-} from "./chunk-567L5OJ6.js";
-import {
-  getPendingQuestionsForSession
-} from "./chunk-JURM3RPZ.js";
-import {
-  getRuntimeConfig
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-P57IBMK4.js";
 import {
   getMaxVisibleItems
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -162,7 +162,7 @@ async function generateSessionNameForSession(sessionId, userMessage, deps, signa
       client = deps.getLLMClient();
       client.setModel(providerConfig.model);
     } else if (providerConfig) {
-      const { createLLMClient } = await import("./client-RZGGDGUA.js");
+      const { createLLMClient } = await import("./client-E6QLHPHD.js");
       client = createLLMClient(
         {
           llm: {
@@ -216,4 +216,4 @@ export {
   needsNameGeneration,
   generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-OHTBWA7L.js.map
+//# sourceMappingURL=chunk-6SUBBT2M.js.map

package/dist/{chunk-6LX43YRA.js → chunk-7ET46SNE.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-J2GP3J3X.js";
 import {
   getModelProfile
-} from "./chunk-7ZMOP5LS.js";
+} from "./chunk-TS5WKTFB.js";
 import {
   getBackendCapabilities
-} from "./chunk-PBFGJFGC.js";
+} from "./chunk-UV6IH6HK.js";
 import {
   buildModelParams
-} from "./chunk-DABWCAXS.js";
+} from "./chunk-EUOWCVU6.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -518,4 +518,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-6LX43YRA.js.map
+//# sourceMappingURL=chunk-7ET46SNE.js.map

package/dist/{chunk-GIJUWPRQ.js → chunk-7JVBDBXE.js}

@@ -1,6 +1,6 @@
 import {
   getPlatformShell
-} from "./chunk-66MG44TF.js";
+} from "./chunk-MGEYAYGU.js";
 
 // src/server/tools/tool-policy.ts
 var ALWAYS_ALLOWED = /* @__PURE__ */ new Set(["step_done"]);
@@ -246,4 +246,4 @@ export {
   buildAgentSmallReminder,
   COMPACTION_PROMPT
 };
-//# sourceMappingURL=chunk-GIJUWPRQ.js.map
+//# sourceMappingURL=chunk-7JVBDBXE.js.map

package/dist/{chunk-MYNNMV75.js → chunk-7LGMQ5KS.js}

@@ -2,45 +2,52 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-OHTBWA7L.js";
+} from "./chunk-6SUBBT2M.js";
 import {
   launchWorkflowRun
-} from "./chunk-2COZT3YI.js";
+} from "./chunk-RQPHGBWI.js";
 import {
   runChatTurn
-} from "./chunk-7RIEI2TE.js";
+} from "./chunk-WCM5ZW5N.js";
 import {
   devServerManager
-} from "./chunk-L24A6GZ7.js";
+} from "./chunk-5AI3LHRQ.js";
 import {
-  applyDynamicContext,
-  computeSessionHash,
-  computeUnifiedDiff
-} from "./chunk-PHP7PLFX.js";
+  gitSpawnEnv
+} from "./chunk-J7GAZGZT.js";
 import {
   appendCompactionPrompt
-} from "./chunk-IJFKJ5D6.js";
+} from "./chunk-ZL4IAFF3.js";
 import {
   hasRecentLLMFailure,
   interruptLLMRetryWait
-} from "./chunk-6LX43YRA.js";
+} from "./chunk-7ET46SNE.js";
 import {
   onProcessEvent
-} from "./chunk-RV5G7QQU.js";
+} from "./chunk-MQMPIXON.js";
 import {
   killProcessTree
 } from "./chunk-I72ACQ6R.js";
 import {
-  gitSpawnEnv
-} from "./chunk-J7GAZGZT.js";
+  applyDynamicContext,
+  computeSessionHash,
+  computeUnifiedDiff
+} from "./chunk-SVALN5KE.js";
+import {
+  getPendingQuestionsForSession,
+  provideAnswer
+} from "./chunk-JURM3RPZ.js";
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-YJD5A375.js";
+} from "./chunk-FGNJMKDV.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-M5T4RDPJ.js";
+import {
+  getRuntimeConfig
+} from "./chunk-ELYHHEYL.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-MGEYAYGU.js";
 import {
   getMaxVisibleItems
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.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-Y555VDLA.js");
+        const allAgents = await import("./registry-CMSSZHDC.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-6BDT5YMT.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-7LGMQ5KS.js.map

package/dist/{chunk-ZIL6VKLU.js → chunk-BKMWZTNO.js}

@@ -5,13 +5,13 @@ import {
 } from "./chunk-OSXPQSLW.js";
 import {
   getProject
-} from "./chunk-3B232XG4.js";
+} from "./chunk-DPFET73G.js";
 import {
   SETTINGS_KEYS,
   deleteSetting,
   getSetting,
   setSetting
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.js";
 
 // src/server/context/instructions.ts
 import { readFile, access } from "fs/promises";
@@ -440,4 +440,4 @@ export {
   deleteSkill,
   deleteProjectSkill
 };
-//# sourceMappingURL=chunk-ZIL6VKLU.js.map
+//# sourceMappingURL=chunk-BKMWZTNO.js.map

package/dist/chunk-BMBOSVRM.js

@@ -0,0 +1,7 @@
+// src/constants.ts
+var VERSION = "2.0.131";
+
+export {
+  VERSION
+};
+//# sourceMappingURL=chunk-BMBOSVRM.js.map

package/dist/{auth-GTGIGX5X.js → chunk-CQGJ5RWB.js}

@@ -1,7 +1,6 @@
 import {
   getAuthConfigPath
 } from "./chunk-CQGTEGKL.js";
-import "./chunk-YLJ4XMA6.js";
 
 // src/cli/auth.ts
 import { readFile, writeFile, mkdir, access } from "fs/promises";
@@ -40,12 +39,13 @@ function hashPassword(password) {
 function verifyPassword(password, hash) {
   return hashPassword(password) === hash;
 }
+
 export {
+  saveAuthConfig,
+  loadAuthConfig,
   authConfigExists,
   encryptPassword,
   hashPassword,
-  loadAuthConfig,
-  saveAuthConfig,
   verifyPassword
 };
-//# sourceMappingURL=auth-GTGIGX5X.js.map
+//# sourceMappingURL=chunk-CQGJ5RWB.js.map

package/dist/{chunk-3B232XG4.js → chunk-DPFET73G.js}

@@ -1,6 +1,6 @@
 import {
   getDatabase
-} from "./chunk-OYBUJIC3.js";
+} from "./chunk-JU757HVI.js";
 
 // src/server/db/projects.ts
 function createProject(name, workdir) {
@@ -144,4 +144,4 @@ export {
   toggleStar,
   getProjectDefaultAgent
 };
-//# sourceMappingURL=chunk-3B232XG4.js.map
+//# sourceMappingURL=chunk-DPFET73G.js.map

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-KBESUA3W.js → chunk-ELYHHEYL.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-OSXPQSLW.js";
 import {
   getProjectDefaultAgent
-} from "./chunk-3B232XG4.js";
+} from "./chunk-DPFET73G.js";
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -352,4 +352,4 @@ export {
   getOverrideAgentIds,
   resolveDefaultAgentId
 };
-//# sourceMappingURL=chunk-KBESUA3W.js.map
+//# sourceMappingURL=chunk-ELYHHEYL.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-YJD5A375.js → chunk-FGNJMKDV.js}

@@ -6,16 +6,16 @@ import {
   foldSessionState,
   spreadOptionalMessageFields,
   trimSnapshotStreamingOutput
-} from "./chunk-ZIYETXOW.js";
+} from "./chunk-M5T4RDPJ.js";
 import {
   updateSessionMessageCount
-} from "./chunk-AQBRI7TM.js";
+} from "./chunk-KWAHD2JA.js";
 import {
   getRuntimeConfig
-} from "./chunk-KBESUA3W.js";
+} from "./chunk-ELYHHEYL.js";
 import {
   SETTINGS_KEYS
-} from "./chunk-N2Q3KYWM.js";
+} from "./chunk-LQKXJPKP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -1465,4 +1465,4 @@ export {
   truncateSessionMessages,
   getRecentUserPromptsForSession
 };
-//# sourceMappingURL=chunk-YJD5A375.js.map
+//# sourceMappingURL=chunk-FGNJMKDV.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