@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.1

package/lib/{openai-reasoning-fallback-DXsfiSXO.mjs → openai-reasoning-fallback-BdB3RCbj.mjs}

@@ -1,8 +1,8 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { o as readSseJson } from "./src-BcD0_rQR.mjs";
-import { B as OpenAIHttpError, G as fetchWithRetry, W as extractHttpStatusFromError, s as ProviderResponseError } from "./error-C-f_Wnw4.mjs";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/openai-http.ts
+import { o as readSseJson } from "./src-BwW51vA5.mjs";
+import { B as OpenAIHttpError, G as fetchWithRetry, W as extractHttpStatusFromError, s as ProviderResponseError } from "./error-CORgGg5a.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/openai-http.ts
 /**
 * JSON-POST → SSE transport for OpenAI-wire streaming endpoints (chat
 * completions, responses, azure responses). Replaces the `openai` SDK client:
@@ -30,6 +30,26 @@ const DEFAULT_MAX_ATTEMPTS = 6;
 /** Bound the `Error.message` allocation for proxy HTML error pages and the like. */
 const MAX_DETAIL_CHARS = 4096;
 /**
+* LiteLLM (and compatible proxies) shed over-concurrency requests *before* the
+* upstream call with an immediate HTTP 429 marked `rate_limit_type:
+* max_parallel_requests` — as a response header and/or a structured body field.
+* This is an admission failure, not an upstream rate/quota limit: the request
+* never reached a model. Retrying it inside the transport (honoring the proxy's
+* `Retry-After`, up to {@link DEFAULT_MAX_ATTEMPTS} times) duplicates — worse,
+* at 60s per sleep instead of 5s — the concurrency backoff and model fallback
+* that `TurnRecovery` already owns, stalling one turn for up to ~300s
+* (issue #8854). {@link isConcurrencyAdmissionRejection} lets the transport
+* surface it on the first attempt so session recovery runs promptly. Genuine
+* RPM/quota 429s carry no such marker and keep honoring `Retry-After`.
+*/
+const CONCURRENCY_ADMISSION_LIMITER = "max_parallel_requests";
+/** Body form of the marker: `"rate_limit_type": "max_parallel_requests"` (top level or under `error`). */
+const CONCURRENCY_ADMISSION_BODY_PATTERN = /"rate_limit_type"\s*:\s*"max_parallel_requests"/;
+/** `true` for a proxy concurrency-admission 429 that must bypass transport-level retry. */
+function isConcurrencyAdmissionRejection(response, bodyText) {
+	return response.headers.get("rate_limit_type")?.trim() === CONCURRENCY_ADMISSION_LIMITER || CONCURRENCY_ADMISSION_BODY_PATTERN.test(bodyText);
+}
+/**
 * POST a JSON body and stream back decoded SSE events.
 *
 * Throws {@link OpenAIHttpError} on a non-2xx terminal response. Aborts on
@@ -48,6 +68,7 @@ async function postOpenAIStream(init) {
 		signal: init.signal,
 		fetch: init.fetch,
 		maxAttempts: DEFAULT_MAX_ATTEMPTS,
+		shouldRetryResponse: (response, bodyText) => !isConcurrencyAdmissionRejection(response, bodyText),
 		timeout: false
 	});
 	if (!response.ok) throw await captureOpenAIHttpError(response);
@@ -80,7 +101,15 @@ async function captureOpenAIHttpError(response) {
 	return new OpenAIHttpError(message, captured, code);
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-reasoning-fallback.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/openai-reasoning-fallback.ts
+/**
+* Fallback marker: the server rejected the `chat_template_kwargs.reasoning_effort`
+* spelling itself (strict kwargs whitelists — Ninfer-style servers), not the
+* effort value. Apply strips the kwarg and hoists the value onto the top-level
+* `reasoning_effort` field when that spelling is absent.
+* @internal
+*/
+const STRIP_TEMPLATE_KWARG_REASONING_EFFORT = Symbol("strip-template-kwarg-reasoning-effort");
 const ENABLED_REASONING_VALUES = [
 	"minimal",
 	"low",
@@ -134,7 +163,18 @@ function readOpenAIReasoningEffort(params) {
 	if (!isRecord(params)) return void 0;
 	if (typeof params.reasoning_effort === "string") return params.reasoning_effort;
 	const reasoning = params.reasoning;
-	return isRecord(reasoning) && typeof reasoning.effort === "string" ? reasoning.effort : void 0;
+	if (isRecord(reasoning) && typeof reasoning.effort === "string") return reasoning.effort;
+	return readTemplateKwargReasoningEffort(params);
+}
+function readTemplateKwargReasoningEffort(params) {
+	const kwargs = params.chat_template_kwargs;
+	return isRecord(kwargs) && typeof kwargs.reasoning_effort === "string" ? kwargs.reasoning_effort : void 0;
+}
+/** Remove `chat_template_kwargs.reasoning_effort`, dropping the kwargs object when it becomes empty. */
+function deleteTemplateKwargReasoningEffort(kwargs, parent) {
+	delete kwargs.reasoning_effort;
+	for (const key in kwargs) return;
+	delete parent.chat_template_kwargs;
 }
 function deleteReasoningEffort(reasoning, parent) {
 	if (typeof reasoning.effort !== "string") return false;
@@ -146,6 +186,14 @@ function deleteReasoningEffort(reasoning, parent) {
 /** @internal */
 function applyOpenAIReasoningEffortFallback(params, fallback) {
 	if (!isRecord(params)) return false;
+	if (fallback === STRIP_TEMPLATE_KWARG_REASONING_EFFORT) {
+		const kwargs = params.chat_template_kwargs;
+		if (!isRecord(kwargs) || typeof kwargs.reasoning_effort !== "string") return false;
+		const effort = kwargs.reasoning_effort;
+		deleteTemplateKwargReasoningEffort(kwargs, params);
+		if (typeof params.reasoning_effort !== "string") params.reasoning_effort = effort;
+		return true;
+	}
 	let changed = false;
 	if (typeof params.reasoning_effort === "string") {
 		if (fallback === null) delete params.reasoning_effort;
@@ -160,6 +208,12 @@ function applyOpenAIReasoningEffortFallback(params, fallback) {
 			changed = true;
 		}
 	}
+	const kwargs = params.chat_template_kwargs;
+	if (isRecord(kwargs) && typeof kwargs.reasoning_effort === "string") {
+		if (fallback === null) deleteTemplateKwargReasoningEffort(kwargs, params);
+		else kwargs.reasoning_effort = fallback;
+		changed = true;
+	}
 	return changed;
 }
 function capturedStringField(captured, field) {
@@ -182,9 +236,10 @@ function collectMessageParts(error, captured) {
 * Text that identifies a 400 as being about the reasoning-effort field.
 * OpenAI-compatible gateways (cliproxy, …) never name the field — they reject
 * the value alone with `level "none" not supported, valid levels: low, …` — so
-* the allowed-level phrasing counts as a mention too.
+* the allowed-level phrasing counts as a mention too. GitHub Copilot phrases
+* the same rejection with `Supported values are: …`, so value lists count too.
 */
-const REASONING_EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value|(?:valid|supported|allowed) levels?/i;
+const REASONING_EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value|(?:valid|supported|allowed) (?:levels?|values?)/i;
 function mentionsReasoningEffort(error, captured) {
 	const param = capturedStringField(captured, "param");
 	const code = capturedStringField(captured, "code");
@@ -192,17 +247,35 @@ function mentionsReasoningEffort(error, captured) {
 	const message = collectMessageParts(error, captured);
 	return REASONING_EFFORT_FIELD_PATTERN.test(param ?? "") || REASONING_EFFORT_FIELD_PATTERN.test(code ?? "") || REASONING_EFFORT_FIELD_PATTERN.test(type ?? "") || REASONING_EFFORT_FIELD_PATTERN.test(message);
 }
+const EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value/i;
+const ALLOWED_LEVELS_PATTERN = /(?:valid|supported|allowed) levels?/i;
+/** Fielded rejection verdicts in any word order: verdict-first, field-first, or bare mention plus verdict. */
+function messageCarriesEffortVerdict(message) {
+	return /invalid[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message) || /(?:reasoning[_. ]effort|reasoning value)[^\n]*(?:invalid|unsupported|not supported|not permitted|must be|expected|unknown|unexpected|unrecognized)/i.test(message) || /(?:unsupported|not supported|not permitted|unknown|unexpected|unrecognized|extra)[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message);
+}
+function parseEffortRejectionSignal(message, captured, currentEffort) {
+	const namesFieldInMessage = EFFORT_FIELD_PATTERN.test(message);
+	const param = capturedStringField(captured, "param") ?? "";
+	const quoted = `["'\`]${escapeRegExp(currentEffort)}["'\`]`;
+	return {
+		field: namesFieldInMessage || EFFORT_FIELD_PATTERN.test(param) ? "reasoning-effort" : param.trim() !== "" ? "other" : "unknown",
+		namesFieldInMessage,
+		messageVerdict: messageCarriesEffortVerdict(message),
+		listsLevels: ALLOWED_LEVELS_PATTERN.test(message),
+		rejectedMatches: new RegExp(`(?:invalid|unsupported|not supported)[^\\n]*${quoted}`, "i").test(message) || new RegExp(`${quoted}[^\\n]*(?:invalid|unsupported|not supported)`, "i").test(message)
+	};
+}
 function isInvalidReasoningEffortError(error, captured, currentEffort) {
 	const status = extractHttpStatusFromError(error) ?? captured?.status;
 	if (status !== 400 && status !== 422) return false;
 	if (!mentionsReasoningEffort(error, captured)) return false;
 	const message = collectMessageParts(error, captured);
 	if (/reasoning[_ ]content/i.test(message) && !REASONING_EFFORT_FIELD_PATTERN.test(message)) return false;
-	if (/invalid[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message)) return true;
-	if (/(?:reasoning[_. ]effort|reasoning value)[^\n]*(?:invalid|unsupported|not supported|must be|expected)/i.test(message)) return true;
-	if (/(?:unsupported|not supported)[^\n]*(?:reasoning[_. ]effort|reasoning value)/i.test(message)) return true;
-	const quoted = `["'\`]${escapeRegExp(currentEffort)}["'\`]`;
-	return new RegExp(`(?:invalid|unsupported|not supported)[^\\n]*${quoted}`, "i").test(message) || new RegExp(`${quoted}[^\\n]*(?:invalid|unsupported|not supported)`, "i").test(message);
+	const signal = parseEffortRejectionSignal(message, captured, currentEffort);
+	if (signal.field === "other" && !signal.namesFieldInMessage) return false;
+	if (signal.messageVerdict) return true;
+	if (currentEffort.toLowerCase() !== "none" && !signal.namesFieldInMessage && !signal.listsLevels) return false;
+	return signal.rejectedMatches;
 }
 function escapeRegExp(value) {
 	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -266,8 +339,29 @@ function nearestEnabledReasoningFallback(currentEffort, allowed) {
 	}
 	return best;
 }
+/**
+* Text that identifies a rejection of the kwargs spelling itself: the server
+* names `chat_template_kwargs` together with `reasoning_effort` (Ninfer-style
+* strict kwargs whitelists: `chat_template_kwargs.reasoning_effort is not
+* supported`).
+*/
+const TEMPLATE_KWARG_EFFORT_PATTERN = /chat_template_kwargs[^\n]{0,120}reasoning[_. ]effort|reasoning[_. ]effort[^\n]{0,120}chat_template_kwargs/i;
+const FIELD_REJECTION_PATTERN = /invalid|unsupported|not supported|not permitted|unknown|unexpected|unrecognized|rejected|extra input/i;
+function resolveStripTemplateKwargFallback(error, captured, params) {
+	if (!isRecord(params)) return void 0;
+	const effort = readTemplateKwargReasoningEffort(params);
+	if (effort === void 0) return void 0;
+	const status = extractHttpStatusFromError(error) ?? captured?.status;
+	if (status !== 400 && status !== 422) return void 0;
+	const message = collectMessageParts(error, captured);
+	if (!TEMPLATE_KWARG_EFFORT_PATTERN.test(message) || !FIELD_REJECTION_PATTERN.test(message)) return void 0;
+	if (parseAllowedReasoningValues(message, effort) !== void 0) return void 0;
+	return STRIP_TEMPLATE_KWARG_REASONING_EFFORT;
+}
 /** @internal */
 function resolveOpenAIReasoningEffortFallback(error, captured, params, options) {
+	const strip = resolveStripTemplateKwargFallback(error, captured, params);
+	if (strip !== void 0) return strip;
 	const currentEffort = readOpenAIReasoningEffort(params);
 	if (!currentEffort || !KNOWN_REASONING_VALUE[currentEffort.toLowerCase()]) return void 0;
 	if (!isInvalidReasoningEffortError(error, captured, currentEffort)) return void 0;

package/lib/{openai-responses-Mq_-PjvE.mjs → openai-responses-CGQPlIIy.mjs}

@@ -1,21 +1,20 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
 import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
-import { I as $flag, S as debug, T as warn, t as structuredCloneJSON } from "./src-BcD0_rQR.mjs";
-import { A as isTransientStreamParseError, B as OpenAIHttpError, d as callWithCopilotModelRetry, l as finalize, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError, v as AbortError } from "./error-C-f_Wnw4.mjs";
-import { A as NO_STRICT, L as sanitizeSchemaForOpenAIResponses, O as flattenExclusiveRequiredRootUnion, P as normalizeSchemaForMoonshot, a as normalizeSystemPrompts, j as adaptSchemaForStrict, k as toolWireSchema, l as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, s as resolveCacheRetention, t as createOpenAIResponsesHistoryPayload } from "./utils-Cp2Mxf_U.mjs";
-import { $ as isOpenRouterAnthropicModel, Ct as withEmptyCompletionRetry, D as buildResponsesInput, E as buildResponsesDeltaInput, G as getJuiceValue, I as disableStrictToolsForScope, J as getOpenAIStrictToolsScope, K as getOpenAIPromptCacheKey, N as createInitialResponsesAssistantMessage, P as createOpenAIStrictToolsState, Q as isOpenAIResponsesProgressEvent, S as applyResponsesCompatPolicy, T as applyWireModelIdTransform, Y as getOpenRouterResponsesSessionId, Z as isCompiledGrammarTooLargeStrictError, _ as applyOpenAIExtraBody, _t as isForcedToolChoice, ct as resolveOpenAICompatPolicy, dt as resolveOpenAIRequestSetup, et as isStrictToolsDisabledForScope, ft as resolveOpenAIResponsesOutputClamp, g as applyCommonResponsesSamplingParams, k as clearOpenAIStrictToolsState, n as getEnvApiKey, ot as processResponsesStream, pt as shouldRetryWithoutStrictTools, q as getOpenAIResponsesRoutingSessionId, ut as resolveOpenAIOutputTokenParam, v as applyOpenAIGatewayRouting, w as applyVercelResponsesCacheControls, yt as mapToOpenAIResponsesToolChoice } from "./stream-Bjq8wjfr.mjs";
-import { t as createAbortSourceTracker } from "./abort-Cwwm4Err.mjs";
-import { A as semverGte, D as bareModelId, j as hostMatchesUrl, k as parseOpenAIModel } from "./models-DRA2c_8U.mjs";
-import "./identity-HNO1Oe9B.mjs";
-import { t as findStrictToolSchemaViolation } from "./strict-tool-validation-imVLUcbI.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-Dh2guZxS.mjs";
-import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-CYAxUkSD.mjs";
-import { t as notifyProviderResponse } from "./provider-response-C6vcbQyO.mjs";
-import { t as compactGrammarDefinition } from "./grammar-D-NqNUxQ.mjs";
-import { a as getOpenAIReasoningEffortFallback, c as postOpenAIStream, i as createOpenAIReasoningEffortFallbackState, n as clearOpenAIReasoningEffortFallbackState, o as rememberOpenAIReasoningEffortFallback, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-DXsfiSXO.mjs";
+import { C as warn, F as $flag, b as debug, t as structuredCloneJSON } from "./src-BwW51vA5.mjs";
+import { A as isTransientStreamParseError, B as OpenAIHttpError, _ as AbortError, c as finalize, i as isProviderRetryableError, n as StreamTimeoutError, s as ProviderResponseError, t as ConfigurationError } from "./error-CORgGg5a.mjs";
+import { A as toolWireSchema, F as normalizeSchemaForMoonshot, M as adaptSchemaForStrict, c as resolveCacheRetention, j as NO_STRICT, k as flattenExclusiveRequiredRootUnion, o as normalizeSystemPrompts, t as createOpenAIResponsesHistoryPayload, u as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, z as sanitizeSchemaForOpenAIResponses } from "./utils-CUPhpw9A.mjs";
+import { $ as getJuiceValue, A as applyResponsesCompatPolicy, At as withReplaySafeStreamRetry, E as applyOpenAIGatewayRouting, Et as mapToOpenAIResponsesToolChoice, F as buildResponsesInput, H as createOpenAIStrictToolsState, L as clearOpenAIStrictToolsState, M as applyVercelResponsesCacheControls, N as applyWireModelIdTransform, P as buildResponsesDeltaInput, St as shouldRetryWithoutStrictTools, T as applyOpenAIExtraBody, V as createInitialResponsesAssistantMessage, W as disableStrictToolsForScope, _t as resolveOpenAIOutputTokenParam, at as isCompiledGrammarTooLargeStrictError, bt as resolveReasoningSummaryOption, et as getOpenAIPromptCacheKey, ht as resolveOpenAICompatPolicy, n as getEnvApiKey, nt as getOpenAIStrictToolsScope, ot as isOpenAIResponsesProgressEvent, pt as processResponsesStream, rt as getOpenRouterResponsesSessionId, st as isStrictToolsDisabledForScope, tt as getOpenAIResponsesRoutingSessionId, vt as resolveOpenAIRequestSetup, w as applyCommonResponsesSamplingParams, wt as isForcedToolChoice, xt as shouldDropAutoToolChoiceForReasoning, yt as resolveOpenAIResponsesOutputClamp } from "./stream-B_7qN-bA.mjs";
+import { t as createAbortSourceTracker } from "./abort-Caqff3M6.mjs";
+import { i as resolveCopilotRequestIdentity, o as wrapFetchForCopilotFallback } from "./github-copilot-headers-DOh1gt_w.mjs";
+import { t as findStrictToolSchemaViolation } from "./strict-tool-validation-CBTz1dAA.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ulcDenZD.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs } from "./idle-iterator-DlUkEfzW.mjs";
+import { t as notifyProviderResponse } from "./provider-response-SqKSkkUc.mjs";
+import { n as planStableOpenAIEffort, r as compactGrammarDefinition, t as getOpenAIEffortControlState } from "./openai-configuration-update-xMYUjaK_.mjs";
+import { a as getOpenAIReasoningEffortFallback, c as postOpenAIStream, i as createOpenAIReasoningEffortFallbackState, n as clearOpenAIReasoningEffortFallbackState, o as rememberOpenAIReasoningEffortFallback, r as createOpenAIReasoningEffortFallbackKey, s as resolveOpenAIReasoningEffortFallback, t as applyOpenAIReasoningEffortFallback } from "./openai-reasoning-fallback-BdB3RCbj.mjs";
 import { scheduler } from "node:timers/promises";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-responses.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/providers/openai-responses.ts
 var openai_responses_exports = /* @__PURE__ */ __exportAll({
 	buildParams: () => buildParams,
 	convertTools: () => convertTools,
@@ -43,7 +42,7 @@ function isOpenAIResponsesReplayUnsafeEvent(event) {
 	}
 }
 function isRetryableOpenAIResponsesStreamFailure(error) {
-	return isTransientStreamParseError(error) || error instanceof ProviderResponseError && error.kind === "incomplete-stream";
+	return isTransientStreamParseError(error) || error instanceof ProviderResponseError && error.kind === "incomplete-stream" || isProviderRetryableError(error);
 }
 function createOpenAIResponsesProviderSessionState() {
 	const strictToolsState = createOpenAIStrictToolsState();
@@ -53,9 +52,11 @@ function createOpenAIResponsesProviderSessionState() {
 		...reasoningEffortFallbackState,
 		nativeHistoryReplayWarmed: false,
 		chains: /* @__PURE__ */ new Map(),
+		effortControls: /* @__PURE__ */ new Map(),
 		close: () => {
 			state.nativeHistoryReplayWarmed = false;
 			state.chains.clear();
+			state.effortControls.clear();
 			clearOpenAIStrictToolsState(state);
 			clearOpenAIReasoningEffortFallbackState(state);
 		}
@@ -71,10 +72,10 @@ function getOpenAIResponsesProviderSessionState(model, providerSessionState) {
 	providerSessionState.set(key, created);
 	return created;
 }
-function isOpenAIResponsesStatefulEnabled(options, baseUrl) {
+function isOpenAIResponsesStatefulEnabled(options, model) {
 	if (options?.statefulResponses === false) return false;
 	if (options?.statefulResponses === true) return true;
-	return $flag("PI_OPENAI_STATEFUL", !baseUrl || hostMatchesUrl(baseUrl, "openai"));
+	return $flag("PI_OPENAI_STATEFUL", model.compat.officialEndpoint);
 }
 function getOpenAIResponsesChainState(providerSessionState, model, resolvedBaseUrl, sessionId) {
 	const key = `${resolvedBaseUrl ?? model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`;
@@ -149,7 +150,7 @@ function markOpenAIResponsesChainZeroDataRetention(chain, error) {
 	debug("OpenAI responses chaining disabled (Zero Data Retention)", { error: error instanceof Error ? error.message : String(error) });
 }
 function maybeAddOpenRouterAnthropicCacheControl(params, model, cacheRetention) {
-	if (cacheRetention === "none" || !isOpenRouterAnthropicModel(model)) return;
+	if (cacheRetention === "none" || model.compat.cacheControlFormat !== "anthropic") return;
 	if (params.cache_control != null) return;
 	params.cache_control = cacheRetention === "long" ? {
 		type: "ephemeral",
@@ -192,14 +193,14 @@ const streamOpenAIResponsesOnce = (model, context, options) => {
 				extraHeaders: options?.headers,
 				initiatorOverride: options?.initiatorOverride,
 				messages: context.messages,
-				openAISessionId: routingSessionId,
+				sessionId: options?.sessionId ?? routingSessionId,
 				promptCacheSessionId
 			});
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
 			const strictToolsScope = getOpenAIStrictToolsScope(model, baseUrl);
 			const promptCacheBreakpointPolicy = resolveCacheRetention(options?.cacheRetention) !== "none" && options?.promptCache?.mode === "explicit" ? options.promptCache.breakpoint ?? "latest-stable-message" : void 0;
-			if (isOpenAIResponsesStatefulEnabled(options, baseUrl) && routingSessionId && providerSessionState) {
+			if (isOpenAIResponsesStatefulEnabled(options, model) && routingSessionId && providerSessionState) {
 				chainState = getOpenAIResponsesChainState(providerSessionState, model, baseUrl, routingSessionId);
 				if (chainState.canAppend && chainState.lastPromptCacheBreakpointPolicy !== promptCacheBreakpointPolicy) resetOpenAIResponsesChainState(chainState);
 			}
@@ -246,36 +247,28 @@ const streamOpenAIResponsesOnce = (model, context, options) => {
 				body: chained.params
 			};
 			rawRequestDump = activeRawRequestDump;
-			const openResponsesStream = (requestParams) => {
+			const openResponsesStream = async (requestParams) => {
 				activeReasoningEffortFallbackKey = createOpenAIReasoningEffortFallbackKey("responses", resolvedBaseUrl, typeof requestParams.model === "string" ? requestParams.model : model.id);
 				activeRequestParams = requestParams;
-				return callWithCopilotModelRetry(async () => {
-					let requestTimeout;
-					if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
-					try {
-						const headersWithTimeout = { ...headers };
-						if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
-						const { events, response, requestId } = await postOpenAIStream({
-							url: requestUrl,
-							headers: headersWithTimeout,
-							body: requestParams,
-							signal: requestSignal,
-							fetch: options?.fetch,
-							onSseEvent: rawSseObserver
-						});
-						if (requestTimeout !== void 0) {
-							clearTimeout(requestTimeout);
-							requestTimeout = void 0;
-						}
-						await notifyProviderResponse(options, response, model, requestId);
-						return events;
-					} finally {
-						if (requestTimeout !== void 0) clearTimeout(requestTimeout);
-					}
-				}, {
-					provider: model.provider,
-					signal: requestSignal
-				});
+				let requestTimeout;
+				if (requestTimeoutMs !== void 0) requestTimeout = setTimeout(() => abortTracker.abortLocally(firstEventTimeoutAbortError), requestTimeoutMs);
+				try {
+					const headersWithTimeout = { ...headers };
+					if (requestTimeoutMs !== void 0) headersWithTimeout["X-Stainless-Timeout"] = Math.floor(requestTimeoutMs / 1e3).toString();
+					const { events, response, requestId } = await postOpenAIStream({
+						url: requestUrl,
+						headers: headersWithTimeout,
+						body: requestParams,
+						signal: requestSignal,
+						fetch: wrapFetchForCopilotFallback(options?.fetch, model.provider === "github-copilot", resolveCopilotRequestIdentity(options?.headers)),
+						onSseEvent: rawSseObserver
+					});
+					clearTimeout(requestTimeout);
+					await notifyProviderResponse(options, response, model, requestId);
+					return events;
+				} finally {
+					clearTimeout(requestTimeout);
+				}
 			};
 			let strictRetryAvailable = true;
 			let activeStrictToolsApplied = builtParams.strictToolsApplied;
@@ -285,13 +278,13 @@ const streamOpenAIResponsesOnce = (model, context, options) => {
 				while (true) try {
 					openaiStream = await openResponsesStream(chained.params);
 					if (pendingReasoningEffortFallback) {
-						rememberOpenAIReasoningEffortFallback(providerSessionState, pendingReasoningEffortFallback.key, pendingReasoningEffortFallback.fallback);
+						if (!(options?.forceReasoningOff === true || options?.disableReasoning === true)) rememberOpenAIReasoningEffortFallback(providerSessionState, pendingReasoningEffortFallback.key, pendingReasoningEffortFallback.fallback);
 						pendingReasoningEffortFallback = void 0;
 					}
 					break;
 				} catch (error) {
 					const capturedErrorResponse = error instanceof OpenAIHttpError ? error.captured : void 0;
-					const reasoningEffortFallback = activeReasoningEffortFallbackKey && activeRequestParams && !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, activeRequestParams, { explicitDisable: options?.forceReasoningOff === true || options?.disableReasoning === true && options.reasoning === void 0 }) : void 0;
+					const reasoningEffortFallback = activeReasoningEffortFallbackKey && activeRequestParams && !requestSignal.aborted ? resolveOpenAIReasoningEffortFallback(error, capturedErrorResponse, activeRequestParams, { explicitDisable: options?.forceReasoningOff === true || options?.disableReasoning === true }) : void 0;
 					if (reasoningEffortFallback !== void 0 && activeReasoningEffortFallbackKey) {
 						const retryMarker = `${activeReasoningEffortFallbackKey}:${String(reasoningEffortFallback)}`;
 						if (attemptedReasoningEffortFallbacks.has(retryMarker)) throw error;
@@ -306,7 +299,7 @@ const streamOpenAIResponsesOnce = (model, context, options) => {
 						};
 						continue;
 					}
-					const compiledGrammarTooLarge = isOpenRouterAnthropicModel(model) && isCompiledGrammarTooLargeStrictError(error, capturedErrorResponse);
+					const compiledGrammarTooLarge = model.compat.retryWithoutStrictOnGrammarError && isCompiledGrammarTooLargeStrictError(error, capturedErrorResponse);
 					if (strictRetryAvailable && !requestSignal.aborted && (compiledGrammarTooLarge || shouldRetryWithoutStrictTools(error, capturedErrorResponse, {
 						model,
 						strictToolsApplied: activeStrictToolsApplied,
@@ -515,31 +508,11 @@ const streamOpenAIResponsesOnce = (model, context, options) => {
 	return stream;
 };
 /**
-* Public entry: wrap the single-attempt Responses streamer with bounded
-* empty-completion retries — a `response.completed` carrying no content/usage
-* would otherwise stall the agent loop. Shared with the OpenAI-completions and
-* Anthropic providers via `withEmptyCompletionRetry`.
+* Public entry: retry benign empty completions before they reach the agent
+* loop. Transient stream failures are retried inside the attempt so stateful
+* Responses request metadata remains stable.
 */
-const streamOpenAIResponses = (model, context, options) => withEmptyCompletionRetry(model, context, options, streamOpenAIResponsesOnce);
-function isOfficialOpenAIResponsesEndpoint(model) {
-	if (model.provider !== "openai") return false;
-	if (!model.baseUrl) return true;
-	try {
-		return new URL(model.baseUrl).hostname === "api.openai.com";
-	} catch {
-		return false;
-	}
-}
-/**
-* GPT-5.6+ family check for Responses routes. The model id classifies the
-* reasoning family regardless of the provider/host serving it — a cliproxy or
-* other OpenAI-compatible gateway carrying `gpt-5.6-sol` gets the same
-* scaffolding as the official endpoint.
-*/
-function isGpt56PlusResponsesModel(model) {
-	const parsed = parseOpenAIModel(bareModelId(model.requestModelId ?? model.id));
-	return parsed !== null && semverGte(parsed.version, "5.6");
-}
+const streamOpenAIResponses = (model, context, options) => withReplaySafeStreamRetry(model, context, options, streamOpenAIResponsesOnce, { retryEmptyCompletion: true });
 function isResponsesPromptCacheableContentBlock(block) {
 	if (typeof block !== "object" || block === null || !("type" in block)) return false;
 	return block.type === "input_text" || block.type === "input_image" || block.type === "input_file";
@@ -717,7 +690,7 @@ function buildParams(model, context, options, providerSessionState, strictToolsS
 		...options,
 		maxTokens: outputToken?.value
 	}, model);
-	if (options?.textVerbosity && isOfficialOpenAIResponsesEndpoint(model)) params.text = {
+	if (options?.textVerbosity && model.compat.officialEndpoint) params.text = {
 		...params.text,
 		verbosity: options.textVerbosity
 	};
@@ -739,6 +712,7 @@ function buildParams(model, context, options, providerSessionState, strictToolsS
 			}
 		}
 	}
+	if (shouldDropAutoToolChoiceForReasoning(model, model.compat, params.tool_choice, options)) delete params.tool_choice;
 	const reasoningPolicy = resolveOpenAICompatPolicy(model, {
 		endpoint: "responses",
 		reasoning: options?.reasoning,
@@ -749,9 +723,8 @@ function buildParams(model, context, options, providerSessionState, strictToolsS
 		filterReasoningHistory: options?.filterReasoningHistory,
 		omitReasoningEffort: options?.omitReasoningEffort
 	});
-	const reasoningSummary = model.compat.supportsReasoningSummary ? options?.reasoningSummary : options?.reasoning === void 0 ? void 0 : null;
 	applyResponsesCompatPolicy(params, reasoningPolicy, {
-		reasoningSummary,
+		reasoningSummary: resolveReasoningSummaryOption(model, options),
 		forceReasoningOff: options?.forceReasoningOff,
 		mapEffort: (effort) => model.compat.reasoningEffortMap?.[effort] ?? model.thinking?.effortMap?.[effort] ?? effort
 	});
@@ -759,12 +732,13 @@ function buildParams(model, context, options, providerSessionState, strictToolsS
 		...params.reasoning,
 		mode: model.reasoningMode
 	};
+	applyResponsesStableEffort(model, params, messages, options, providerSessionState);
 	if (model.compat.isVercelGatewayHost) applyVercelResponsesCacheControls(params, model.compat, cacheRetention);
 	else applyOpenAIGatewayRouting(params, model.compat);
 	applyOpenAIExtraBody(params, options?.extraBody);
 	applyOpenAIResponsesPromptCachePolicy(params, model, options, statefulCacheBaseline);
 	let trailingScaffoldingItems = 0;
-	if (options?.forceReasoningOff && isGpt56PlusResponsesModel(model)) {
+	if (options?.forceReasoningOff && model.compat.requiresReasoningOffJuiceInstruction) {
 		const effort = options.reasoning ?? "medium";
 		const juice = getJuiceValue(effort);
 		messages.push({
@@ -783,6 +757,26 @@ function buildParams(model, context, options, providerSessionState, strictToolsS
 	};
 }
 /**
+* Keep the request-level effort byte-stable across a conversation and carry
+* later changes as `configuration_update` items (GPT-6 Astra). Requires a
+* routing session id and provider session state to remember the baseline;
+* without them every request stands alone and sends its own effort.
+*/
+function applyResponsesStableEffort(model, params, input, options, providerSessionState) {
+	if (!model.compat.supportsConfigurationUpdate || !providerSessionState) return;
+	const reasoning = params.reasoning;
+	if (!reasoning || !("effort" in reasoning)) return;
+	const effort = reasoning.effort;
+	if (effort === void 0 || effort === null || effort === "none") return;
+	const sessionId = getOpenAIResponsesRoutingSessionId(options);
+	if (!sessionId) return;
+	const state = getOpenAIEffortControlState(providerSessionState.effortControls, `${model.baseUrl ?? ""}\u0000${model.id}\u0000${sessionId}`);
+	params.reasoning = {
+		...reasoning,
+		effort: planStableOpenAIEffort(state, input, effort)
+	};
+}
+/**
 * Whether this model should get the OpenAI custom-tool grammar variant
 * for `apply_patch`. The generated model catalog sets
 * `model.applyPatchToolType` for first-party GPT-5 Responses models; this
@@ -822,7 +816,7 @@ function mapOpenAIResponsesToolChoiceForTools(choice, tools, model) {
 /** @internal Exported for tests. */
 function convertTools(tools, strictMode, model, onQuarantine = (toolName, schemaPath) => warn(`Tool "${toolName}" omitted from the openai-responses request: its parameter schema is invalid for this provider at ${schemaPath} (an enum/const value cannot match its declared type). Other tools are unaffected.`)) {
 	const allowFreeform = supportsFreeformApplyPatch(model);
-	const rejectXaiRootObjectUnion = model.provider === "xai" || model.provider === "xai-oauth";
+	const rejectRootObjectUnion = model.compat.rejectRootObjectUnion;
 	const out = [];
 	for (const tool of tools) {
 		if (tool.native?.type === "computer" && model.supportsComputerUse === true) {
@@ -845,10 +839,10 @@ function convertTools(tools, strictMode, model, onQuarantine = (toolName, schema
 		const strict = !NO_STRICT && strictMode && tool.strict !== false;
 		const baseParameters = toolWireSchema(tool);
 		const sanitized = sanitizeSchemaForOpenAIResponses(baseParameters);
-		const providerParameters = rejectXaiRootObjectUnion ? flattenExclusiveRequiredRootUnion(sanitized) : sanitized;
+		const providerParameters = rejectRootObjectUnion ? flattenExclusiveRequiredRootUnion(sanitized) : sanitized;
 		const responseParameters = model.compat.toolSchemaFlavor === "moonshot-mfjs" ? normalizeSchemaForMoonshot(providerParameters) : providerParameters;
 		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(responseParameters, strict);
-		const violation = findStrictToolSchemaViolation(parameters, "#", { rejectXaiRootObjectUnion });
+		const violation = findStrictToolSchemaViolation(parameters, "#", { rejectRootObjectUnion });
 		if (violation) {
 			onQuarantine(tool.name, violation);
 			continue;

package/lib/{perplexity-XgLF73E7.mjs → perplexity-TBjz3VMB.mjs}

@@ -1,9 +1,9 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-import { D as Cookie, E as $, O as CookieMap, P as $env } from "./src-BcD0_rQR.mjs";
-import { V as ProviderHttpError, _ as OnPromptRequiredError, c as OAuthError, h as LoginCancelledError } from "./error-C-f_Wnw4.mjs";
+import { E as CookieMap, N as $env, T as Cookie, w as $ } from "./src-BwW51vA5.mjs";
+import { V as ProviderHttpError, f as OAuthError, g as OnPromptRequiredError, m as LoginCancelledError } from "./error-CORgGg5a.mjs";
 import * as os from "node:os";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/registry/oauth/perplexity.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/registry/oauth/perplexity.ts
 /**
 * Perplexity login and token refresh.
 *
@@ -156,7 +156,7 @@ async function httpEmailLogin(ctrl) {
 		}),
 		signal: ctrl.signal
 	});
-	const verifyData = await verifyResponse.json();
+	let verifyData = await verifyResponse.json();
 	if (!verifyResponse.ok) {
 		const reason = verifyData.text ?? verifyData.error_code ?? verifyData.status ?? "OTP verification failed";
 		throw new OAuthError(`Perplexity OTP verification failed: ${reason}`, {
@@ -165,11 +165,54 @@ async function httpEmailLogin(ctrl) {
 			status: verifyResponse.status
 		});
 	}
-	if (!verifyData.token) throw new OAuthError("Perplexity OTP verification response missing token", {
-		kind: "validation",
-		provider: "perplexity"
-	});
-	return jwtToCredentials(verifyData.token, trimmedEmail);
+	if (verifyData.status === "totp_challenge_required" && verifyData.challenge_token) {
+		const totp = await ctrl.onPrompt({
+			message: "Enter the code from your authenticator app",
+			placeholder: "123456"
+		});
+		if (ctrl.signal?.aborted) throw new LoginCancelledError();
+		const trimmedTotp = totp.trim();
+		if (!trimmedTotp) throw new OAuthError("Authenticator code is required", {
+			kind: "validation",
+			provider: "perplexity"
+		});
+		ctrl.onProgress?.("Verifying authenticator code...");
+		const totpResponse = await request("https://www.perplexity.ai/api/auth/totp/challenge-verify", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"User-Agent": APP_USER_AGENT,
+				"X-App-ApiVersion": API_VERSION
+			},
+			body: JSON.stringify({
+				token: verifyData.challenge_token,
+				code: trimmedTotp
+			}),
+			signal: ctrl.signal
+		});
+		verifyData = await totpResponse.json();
+		if (!totpResponse.ok) {
+			const reason = verifyData.text ?? verifyData.error_code ?? verifyData.status ?? "TOTP verification failed";
+			throw new OAuthError(`Perplexity authenticator verification failed: ${reason}`, {
+				kind: "validation",
+				provider: "perplexity",
+				status: totpResponse.status
+			});
+		}
+		if (!verifyData.token) verifyData = {
+			token: cookies.get("__Secure-next-auth.session-token") ?? cookies.get("next-auth.session-token") ?? void 0,
+			status: "success"
+		};
+	}
+	const token = verifyData.token ?? verifyData.challenge_token;
+	if (!token || verifyData.error_code || verifyData.status && verifyData.status !== "success") {
+		const reason = verifyData.text ?? verifyData.error_code ?? verifyData.status ?? "missing token";
+		throw new OAuthError(`Perplexity OTP verification response rejected: ${reason}`, {
+			kind: "validation",
+			provider: "perplexity"
+		});
+	}
+	return jwtToCredentials(token, trimmedEmail);
 }
 /**
 * Login to Perplexity.

package/lib/{pkce-BlQikGPu.mjs → pkce-BYjmugmw.mjs}

@@ -1,6 +1,6 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/registry/oauth/pkce.ts
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/registry/oauth/pkce.ts
 /**
 * Generate PKCE code verifier and challenge.
 * Uses Web Crypto API for cross-platform compatibility.