@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.3

package/lib/openai-reasoning-fallback-DGVVLgd1.mjs

@@ -0,0 +1,286 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { o as readSseJson } from "./src-DTid0g4K.mjs";
+import { B as OpenAIHttpError, G as fetchWithRetry, W as extractHttpStatusFromError, s as ProviderResponseError } from "./error-B3bevhrs.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
+/**
+* JSON-POST → SSE transport for OpenAI-wire streaming endpoints (chat
+* completions, responses, azure responses). Replaces the `openai` SDK client:
+*
+* - Retries: `fetchWithRetry` (Retry-After/quota-hint aware; 5xx/408/429 and
+*   transient network errors). Default 6 total attempts — parity with the
+*   SDK's former `maxRetries: 5`.
+* - SSE decode: `readSseJson` (spec-compliant framing, `[DONE]`-aware).
+*   `onSseEvent` observers now receive real wire frames instead of events
+*   re-synthesized from decoded SDK objects.
+* - Errors: {@link OpenAIHttpError} exposes `status`/`headers`/`code`
+*   structurally (ProviderHttpError contract — `extractHttpStatusFromError`,
+*   retry-after extraction, copilot transient classification) and carries the
+*   captured response body for the strict-tools fallback and the responses
+*   chain-state detectors, which regex over `error.message`.
+*/
+/**
+* Total attempts (initial + retries). Parity with the removed SDK clients'
+* `maxRetries: 5`, i.e. 6 requests. Callers arming a first-event watchdog
+* stay bounded: the watchdog aborts the request `signal`, which
+* `fetchWithRetry` races on every attempt and every backoff sleep, so
+* transient 408/429/5xx retries can never extend the caller's deadline.
+*/
+const DEFAULT_MAX_ATTEMPTS = 6;
+/** Bound the `Error.message` allocation for proxy HTML error pages and the like. */
+const MAX_DETAIL_CHARS = 4096;
+/**
+* POST a JSON body and stream back decoded SSE events.
+*
+* Throws {@link OpenAIHttpError} on a non-2xx terminal response. Aborts on
+* `signal` propagate from `fetchWithRetry`/`readSseJson`; callers own the
+* watchdog timers and abort-reason bookkeeping.
+*/
+async function postOpenAIStream(init) {
+	const response = await fetchWithRetry(init.url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "text/event-stream",
+			...init.headers
+		},
+		body: JSON.stringify(init.body),
+		signal: init.signal,
+		fetch: init.fetch,
+		maxAttempts: DEFAULT_MAX_ATTEMPTS,
+		timeout: false
+	});
+	if (!response.ok) throw await captureOpenAIHttpError(response);
+	if (!response.body) throw new ProviderResponseError(`OpenAI stream response has no body (status ${response.status})`, { kind: "envelope" });
+	return {
+		events: readSseJson(response.body, init.signal, init.onSseEvent),
+		response,
+		requestId: response.headers.get("x-request-id")
+	};
+}
+/** Decode a non-2xx response into an {@link OpenAIHttpError} without consuming it twice. */
+async function captureOpenAIHttpError(response) {
+	let bodyText;
+	let bodyJson;
+	try {
+		bodyText = await response.text();
+		if (bodyText.trim().length > 0) try {
+			bodyJson = JSON.parse(bodyText);
+		} catch {}
+		else bodyText = void 0;
+	} catch {}
+	const captured = {
+		status: response.status,
+		headers: response.headers,
+		bodyText,
+		bodyJson
+	};
+	const { detail, code } = OpenAIHttpError.parseEnvelope(bodyJson, bodyText);
+	const message = detail ? `${response.status} ${detail.length > MAX_DETAIL_CHARS ? detail.slice(0, MAX_DETAIL_CHARS) : detail}` : `${response.status} status code (no body)`;
+	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
+const ENABLED_REASONING_VALUES = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+const KNOWN_REASONING_VALUE = {
+	none: true,
+	minimal: true,
+	low: true,
+	medium: true,
+	high: true,
+	xhigh: true,
+	max: true
+};
+const REASONING_VALUE_RANK = {
+	minimal: 0,
+	low: 1,
+	medium: 2,
+	high: 3,
+	xhigh: 4,
+	max: 5
+};
+/** @internal */
+function createOpenAIReasoningEffortFallbackState() {
+	return { reasoningEffortFallbacks: /* @__PURE__ */ new Map() };
+}
+/** @internal */
+function clearOpenAIReasoningEffortFallbackState(state) {
+	state.reasoningEffortFallbacks.clear();
+}
+/** @internal */
+function getOpenAIReasoningEffortFallback(state, key) {
+	return state?.reasoningEffortFallbacks.get(key);
+}
+/** @internal */
+function rememberOpenAIReasoningEffortFallback(state, key, fallback) {
+	state?.reasoningEffortFallbacks.set(key, fallback);
+}
+/** @internal */
+function createOpenAIReasoningEffortFallbackKey(endpoint, baseUrl, wireModelId) {
+	return `${endpoint}:${baseUrl ?? ""}:${wireModelId ?? ""}`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** @internal */
+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;
+}
+function deleteReasoningEffort(reasoning, parent) {
+	if (typeof reasoning.effort !== "string") return false;
+	delete reasoning.effort;
+	for (const key in reasoning) if (key !== "effort") return true;
+	delete parent.reasoning;
+	return true;
+}
+/** @internal */
+function applyOpenAIReasoningEffortFallback(params, fallback) {
+	if (!isRecord(params)) return false;
+	let changed = false;
+	if (typeof params.reasoning_effort === "string") {
+		if (fallback === null) delete params.reasoning_effort;
+		else params.reasoning_effort = fallback;
+		changed = true;
+	}
+	const reasoning = params.reasoning;
+	if (isRecord(reasoning) && typeof reasoning.effort === "string") {
+		if (fallback === null) changed = deleteReasoningEffort(reasoning, params) || changed;
+		else {
+			reasoning.effort = fallback;
+			changed = true;
+		}
+	}
+	return changed;
+}
+function capturedStringField(captured, field) {
+	const body = isRecord(captured?.bodyJson) ? captured.bodyJson : void 0;
+	const error = isRecord(body?.error) ? body.error : void 0;
+	if (typeof error?.[field] === "string") return error[field];
+	return typeof body?.[field] === "string" ? body[field] : void 0;
+}
+function collectMessageParts(error, captured) {
+	return [
+		error instanceof Error ? error.message : void 0,
+		capturedStringField(captured, "message"),
+		capturedStringField(captured, "param"),
+		capturedStringField(captured, "code"),
+		capturedStringField(captured, "type"),
+		captured?.bodyText
+	].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n");
+}
+/**
+* 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.
+*/
+const REASONING_EFFORT_FIELD_PATTERN = /reasoning[_. ]effort|reasoning value|(?:valid|supported|allowed) levels?/i;
+function mentionsReasoningEffort(error, captured) {
+	const param = capturedStringField(captured, "param");
+	const code = capturedStringField(captured, "code");
+	const type = capturedStringField(captured, "type");
+	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);
+}
+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);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseKnownReasoningValues(text) {
+	const values = /* @__PURE__ */ new Set();
+	const quotedPattern = /["'`](none|minimal|low|medium|high|xhigh|max)["'`]/gi;
+	let quotedMatch = quotedPattern.exec(text);
+	while (quotedMatch !== null) {
+		values.add(quotedMatch[1].toLowerCase());
+		quotedMatch = quotedPattern.exec(text);
+	}
+	const allowedMatch = /(?:must be|one of|allowed values?|supported values?(?: are)?|expected|(?:valid|supported|allowed) levels?(?: are)?)[^.\n]+/i.exec(text);
+	if (allowedMatch) {
+		const allowedText = allowedMatch[0];
+		const barePattern = /\b(none|minimal|low|medium|high|xhigh|max)\b/gi;
+		let bareMatch = barePattern.exec(allowedText);
+		while (bareMatch !== null) {
+			values.add(bareMatch[1].toLowerCase());
+			bareMatch = barePattern.exec(allowedText);
+		}
+	}
+	return values;
+}
+function parseAllowedReasoningValues(message, currentEffort) {
+	const values = parseKnownReasoningValues(message);
+	const hasAllowedCue = /must be|one of|allowed values?|supported values?|expected|(?:valid|supported|allowed) levels?/i.test(message);
+	values.delete(currentEffort.toLowerCase());
+	if (!hasAllowedCue && values.size === 0) return void 0;
+	return values;
+}
+function orderedEnabledAllowedValues(allowed) {
+	return ENABLED_REASONING_VALUES.filter((value) => allowed.has(value));
+}
+function lowestEnabledAllowedValue(allowed) {
+	for (const value of ENABLED_REASONING_VALUES) if (allowed.has(value)) return value;
+}
+function nearestEnabledReasoningFallback(currentEffort, allowed) {
+	const current = currentEffort.toLowerCase();
+	const allowedEnabled = orderedEnabledAllowedValues(allowed);
+	if (allowedEnabled.length === 0) return void 0;
+	if (current === "minimal" && allowedEnabled.includes("low")) return "low";
+	if (current === "xhigh" && allowedEnabled.includes("max")) return "max";
+	if (current === "xhigh" && allowedEnabled.includes("high")) return "high";
+	if (current === "max" && allowedEnabled.includes("xhigh")) return "xhigh";
+	const currentRank = REASONING_VALUE_RANK[current];
+	if (currentRank === void 0) return void 0;
+	let best;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	let bestRank = Number.NEGATIVE_INFINITY;
+	for (const candidate of allowedEnabled) {
+		if (candidate === current) continue;
+		const candidateRank = REASONING_VALUE_RANK[candidate];
+		if (candidateRank === void 0) continue;
+		const distance = Math.abs(candidateRank - currentRank);
+		if (distance < bestDistance || distance === bestDistance && candidateRank > bestRank) {
+			best = candidate;
+			bestDistance = distance;
+			bestRank = candidateRank;
+		}
+	}
+	return best;
+}
+/** @internal */
+function resolveOpenAIReasoningEffortFallback(error, captured, params, options) {
+	const currentEffort = readOpenAIReasoningEffort(params);
+	if (!currentEffort || !KNOWN_REASONING_VALUE[currentEffort.toLowerCase()]) return void 0;
+	if (!isInvalidReasoningEffortError(error, captured, currentEffort)) return void 0;
+	const allowed = parseAllowedReasoningValues(collectMessageParts(error, captured), currentEffort);
+	const normalizedCurrent = currentEffort.toLowerCase();
+	if (allowed === void 0) return null;
+	if (options?.explicitDisable) {
+		if (normalizedCurrent !== "none" && allowed.has("none")) return "none";
+		const fallback = lowestEnabledAllowedValue(allowed);
+		return fallback && fallback !== normalizedCurrent ? fallback : null;
+	}
+	if (normalizedCurrent === "none") return null;
+	return nearestEnabledReasoningFallback(normalizedCurrent, allowed) ?? null;
+}
+//#endregion
+export { getOpenAIReasoningEffortFallback as a, postOpenAIStream as c, createOpenAIReasoningEffortFallbackState as i, clearOpenAIReasoningEffortFallbackState as n, rememberOpenAIReasoningEffortFallback as o, createOpenAIReasoningEffortFallbackKey as r, resolveOpenAIReasoningEffortFallback as s, applyOpenAIReasoningEffortFallback as t };