@openclaw/ai 2026.9.4 → 2026.9.5

package/dist/openai-responses-terminal-usage-Dl3J6zrf.d.mts

@@ -0,0 +1,47 @@
+import { K as StopReason, a as AssistantMessage, ot as Usage } from "./types-4_uVs5WH.mjs";
+import "./types-DkJfb4W3.mjs";
+import OpenAI from "openai";
+//#region packages/ai/src/providers/openai-responses-terminal-usage.d.ts
+/** A known output ceiling can resume sampling after admitted tools have settled. */
+declare function isResponsesOutputLimitToolCallError(message: Pick<AssistantMessage, "stopReason" | "errorCode" | "diagnostics">): boolean;
+/** Terminal usage payload, modeled structurally so untyped callers can pass raw records. */
+type ResponsesTerminalUsagePayload = {
+  input_tokens?: number | null;
+  output_tokens?: number | null;
+  total_tokens?: number | null;
+  input_tokens_details?: {
+    cached_tokens?: number | null;
+    cache_write_tokens?: number | null;
+  } | null;
+  output_tokens_details?: {
+    reasoning_tokens?: number | null;
+  } | null;
+};
+/**
+ * Split a terminal usage payload into the priced buckets.
+ *
+ * OpenAI includes cache reads and writes in `input_tokens`, so both are subtracted out of the
+ * billable input bucket. `total_tokens` comes from the payload, but never below the sum of the
+ * split buckets: proxies routinely omit it (reporting 0 would understate the turn), and a payload
+ * whose `cached_tokens` exceeds `input_tokens` clamps the input bucket, leaving the reported total
+ * short of what the buckets actually price.
+ */
+declare function mapResponsesTerminalUsage(usage: ResponsesTerminalUsagePayload | undefined | null): Pick<Usage, "input" | "output" | "cacheRead" | "cacheWrite" | "contextUsage" | "totalTokens"> | undefined;
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+declare function readResponsesReasoningTokens(usage: ResponsesTerminalUsagePayload | undefined | null): number | undefined;
+/**
+ * Resolve the terminal stop reason, including the two overrides every Responses path shares: a
+ * content-filtered turn is a provider error rather than a truncated answer, and a turn that
+ * produced tool calls reports `toolUse` instead of a plain stop.
+ */
+declare function resolveResponsesTerminalStopReason(params: {
+  status: OpenAI.Responses.ResponseStatus | undefined;
+  terminalEventType?: "response.completed" | "response.incomplete";
+  incompleteReason?: string;
+  hasToolCall: boolean;
+}): {
+  stopReason: StopReason;
+  errorMessage?: string;
+};
+//#endregion
+export { resolveResponsesTerminalStopReason as a, readResponsesReasoningTokens as i, isResponsesOutputLimitToolCallError as n, mapResponsesTerminalUsage as r, ResponsesTerminalUsagePayload as t };

package/dist/{openai-tool-schema-CzjyYXun.mjs → openai-tool-schema-BO8rwyAD.mjs}

@@ -1,6 +1,6 @@
 import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
 import { o as isRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { r as uniqueValues, t as normalizeStringEntries } from "./string-normalization-CmLIasuf.mjs";
+import { i as uniqueValues, t as normalizeStringEntries } from "./string-normalization-J9ZiLfGO.mjs";
 //#region packages/ai/src/providers/clean-for-gemini.ts
 const GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 	"patternProperties",
@@ -272,9 +272,7 @@ function flattenUnionFallback(obj, variants) {
 	return merged;
 }
 function cleanSchemaForGemini(schema) {
-	if (!schema || typeof schema !== "object") return schema;
-	if (Array.isArray(schema)) return schema.map(cleanSchemaForGemini);
-	return cleanSchemaForGeminiWithDefs(schema, extendSchemaDefs$1(void 0, schema), void 0);
+	return cleanSchemaForGeminiWithDefs(schema, void 0, void 0);
 }
 //#endregion
 //#region packages/ai/src/providers/clean-for-llamacpp-gbnf.ts
@@ -420,6 +418,58 @@ function stripUnsupportedSchemaKeywords(schema, unsupportedKeywords) {
 	return cleaned;
 }
 //#endregion
+//#region packages/ai/src/providers/tool-schema-normalization-cache.ts
+let preparedSchemas;
+/** Only synchronous conversion owns these fresh projections; no facts survive its return. */
+function withPreparedToolSchemaNormalization(schemas, convert) {
+	const previous = preparedSchemas;
+	preparedSchemas = schemas;
+	try {
+		return convert();
+	} finally {
+		preparedSchemas = previous;
+	}
+}
+function createBoundedSchemaCache(maxEntries) {
+	const schemas = /* @__PURE__ */ new WeakMap();
+	return {
+		get(source, key) {
+			return schemas.get(source)?.find((entry) => entry.key === key)?.value;
+		},
+		remember(source, key, value) {
+			const entries = schemas.get(source) ?? [];
+			schemas.set(source, [{
+				key,
+				value
+			}, ...entries.filter((entry) => entry.key !== key)].slice(0, maxEntries));
+			return value;
+		}
+	};
+}
+/** Prepared variants cannot evict direct callers' identity-preserving cache entries. */
+function createToolSchemaNormalizationCache(maxEntries) {
+	const directCache = createBoundedSchemaCache(maxEntries);
+	const preparedCache = createBoundedSchemaCache(maxEntries);
+	return {
+		get(source, key) {
+			const prepared = preparedSchemas?.get(source);
+			if (!prepared) return directCache.get(source, key);
+			const entry = preparedCache.get(prepared.source, key);
+			return entry?.inputJson === prepared.inputJson ? JSON.parse(entry.outputJson) : void 0;
+		},
+		remember(source, key, value) {
+			const prepared = preparedSchemas?.get(source);
+			if (!prepared) return directCache.remember(source, key, value);
+			const outputJson = JSON.stringify(value);
+			if (outputJson !== void 0) preparedCache.remember(prepared.source, key, {
+				inputJson: prepared.inputJson,
+				outputJson
+			});
+			return value;
+		}
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/agent-tools-parameter-schema.ts
 /**
 * Normalizes model-facing tool parameter schemas across provider quirks.
@@ -444,8 +494,7 @@ function resolveUnsupportedToolSchemaKeywords(modelOrCompat) {
 function shouldOmitEmptyArrayItems(modelOrCompat) {
 	return extractToolSchemaModelCompat(modelOrCompat)?.omitEmptyArrayItems === true;
 }
-const MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const toolParameterSchemaCache = /* @__PURE__ */ new WeakMap();
+const toolParameterSchemaCache = createToolSchemaNormalizationCache(8);
 function resolveToolParameterSchemaCacheKey(options) {
 	const normalizedProvider = normalizeLowercaseStringOrEmpty(options?.modelProvider);
 	const normalizedModelId = normalizeLowercaseStringOrEmpty(options?.modelId);
@@ -460,17 +509,6 @@ function resolveToolParameterSchemaCacheKey(options) {
 		omitEmptyArrayItems
 	]);
 }
-function getCachedToolParameterSchema(schema, key) {
-	return toolParameterSchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberCachedToolParameterSchema(schema, key, value) {
-	const entries = toolParameterSchemaCache.get(schema) ?? [];
-	toolParameterSchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_TOOL_PARAMETER_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
 function isGeminiModelId(modelId) {
 	return /(?:^|[/:])gemini(?:$|[-/:.])/.test(modelId);
 }
@@ -570,7 +608,8 @@ function normalizeArraySchemaItems(schema, mode) {
 		}
 		let next = value;
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			const entries = Object.entries(value).map(([entryKey, entry]) => [entryKey, normalizeArraySchemaItems(entry, mode)]);
+			const entries = Object.entries(value);
+			for (const entry of entries) entry[1] = normalizeArraySchemaItems(entry[1], mode);
 			if (entries.some(([entryKey, entry]) => entry !== value[entryKey])) next = Object.fromEntries(entries);
 		} else if (SCHEMA_OBJECT_KEYS.has(key) || SCHEMA_ARRAY_KEYS.has(key)) {
 			const valueMode = SCHEMA_OBJECT_KEYS.has(key) || Array.isArray(value) ? mode : "add";
@@ -699,7 +738,9 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 			continue;
 		}
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
-			setOwnSchemaProperty(result, key, Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => [entryKey, inlineLocalSchemaRefsWithDefs(entryValue, nextDefs, refStack, state, rootDocument)])));
+			const entries = Object.entries(value);
+			for (const entry of entries) entry[1] = inlineLocalSchemaRefsWithDefs(entry[1], nextDefs, refStack, state, rootDocument);
+			setOwnSchemaProperty(result, key, Object.fromEntries(entries));
 			continue;
 		}
 		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
@@ -722,7 +763,8 @@ function inlineLocalSchemaRefsWithDefs(schema, defs, refStack, state, rootDocume
 /** Inline local $ref pointers so providers receive self-contained tool schemas. */
 function inlineLocalToolSchemaRefs(schema) {
 	if (!schema || typeof schema !== "object") return schema;
-	return inlineLocalSchemaRefsWithDefs(schema, extendSchemaDefs(void 0, schema), void 0, { unresolvedLocalRefs: false }, schema);
+	const schemaRecord = schema;
+	return inlineLocalSchemaRefsWithDefs(schema, Array.isArray(schema) ? extendSchemaDefs(void 0, schemaRecord) : void 0, void 0, { unresolvedLocalRefs: false }, schema);
 }
 const OPENAPI_SCHEMA_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
 	"discriminator",
@@ -774,46 +816,40 @@ function normalizeOpenApiSchemaKeywords(schema) {
 	if (!isRecord(schema)) return schema;
 	let changed = false;
 	const nullable = schema.nullable === true;
-	const normalized = {};
-	for (const [key, value] of Object.entries(schema)) {
+	const entries = Object.entries(schema);
+	let normalized;
+	for (const [key, value] of entries) {
 		if (key === "nullable" || OPENAPI_SCHEMA_ANNOTATION_KEYS.has(key)) {
+			normalized ??= Object.fromEntries(entries);
+			delete normalized[key];
 			changed = true;
 			continue;
 		}
-		if (SCHEMA_LITERAL_KEYS.has(key)) {
-			normalized[key] = value;
-			continue;
-		}
+		if (SCHEMA_LITERAL_KEYS.has(key) || key === "components") continue;
+		let next = value;
 		if (SCHEMA_MAP_KEYS.has(key) && isRecord(value)) {
 			let mapChanged = false;
-			const next = Object.fromEntries(Object.entries(value).map(([entryKey, entryValue]) => {
-				const nextEntry = normalizeOpenApiSchemaKeywords(entryValue);
-				mapChanged ||= nextEntry !== entryValue;
-				return [entryKey, nextEntry];
-			}));
-			normalized[key] = mapChanged ? next : value;
-			changed ||= mapChanged;
+			const mapEntries = Object.entries(value);
+			for (const entry of mapEntries) {
+				const nextEntry = normalizeOpenApiSchemaKeywords(entry[1]);
+				mapChanged ||= nextEntry !== entry[1];
+				entry[1] = nextEntry;
+			}
+			next = mapChanged ? Object.fromEntries(mapEntries) : value;
+		} else if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) next = normalizeOpenApiSchemaKeywords(value);
+		else if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
+			const nextEntries = value.map(normalizeOpenApiSchemaKeywords);
+			(normalized ??= Object.fromEntries(entries))[key] = nextEntries;
+			changed ||= nextEntries.some((entry, index) => entry !== value[index]);
 			continue;
 		}
-		if (key === "components") {
-			normalized[key] = value;
-			continue;
-		}
-		if (SCHEMA_OBJECT_KEYS.has(key) && isRecord(value)) {
-			const next = normalizeOpenApiSchemaKeywords(value);
-			normalized[key] = next;
-			changed ||= next !== value;
-			continue;
-		}
-		if (SCHEMA_ARRAY_KEYS.has(key) && Array.isArray(value)) {
-			const next = value.map(normalizeOpenApiSchemaKeywords);
-			normalized[key] = next;
-			changed ||= next.some((entry, index) => entry !== value[index]);
-			continue;
+		if (next !== value) {
+			(normalized ??= Object.fromEntries(entries))[key] = next;
+			changed = true;
 		}
-		setOwnSchemaProperty(normalized, key, value);
 	}
 	if (nullable) {
+		normalized ??= Object.fromEntries(entries);
 		if (hasOpenApiComposition(normalized)) return wrapNullableComposedSchema(normalized);
 		if ("type" in normalized) {
 			const nextType = appendNullSchemaType(normalized.type);
@@ -821,7 +857,7 @@ function normalizeOpenApiSchemaKeywords(schema) {
 		}
 		if (Array.isArray(normalized.enum) && !normalized.enum.includes(null)) normalized.enum = [...normalized.enum, null];
 	}
-	return changed || nullable ? normalized : schema;
+	return changed || nullable ? normalized ?? schema : schema;
 }
 function normalizeToolParameterSchemaUncached(schema, options) {
 	const inlinedSchema = normalizeOpenApiSchemaKeywords(inlineLocalToolSchemaRefs(schema));
@@ -897,9 +933,9 @@ function normalizeToolParameterSchemaUncached(schema, options) {
 function normalizeToolParameterSchema(schema, options) {
 	if (!schema || typeof schema !== "object") return normalizeToolParameterSchemaUncached(schema, options);
 	const cacheKey = resolveToolParameterSchemaCacheKey(options);
-	const cached = getCachedToolParameterSchema(schema, cacheKey);
+	const cached = toolParameterSchemaCache.get(schema, cacheKey);
 	if (cached) return cached;
-	return rememberCachedToolParameterSchema(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
+	return toolParameterSchemaCache.remember(schema, cacheKey, normalizeToolParameterSchemaUncached(schema, options));
 }
 //#endregion
 //#region packages/ai/src/providers/openai-tool-schema-compat.ts
@@ -1048,8 +1084,7 @@ function findOpenAIStrictSchemaViolations(schema, path, options) {
 *
 * Caches normalized object inputs by provider compatibility so repeated inventory builds preserve identity.
 */
-const MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA = 8;
-const strictOpenAISchemaCache = /* @__PURE__ */ new WeakMap();
+const strictOpenAISchemaCache = createToolSchemaNormalizationCache(8);
 function resolveToolSchemaModelCompat(compat) {
 	if (!compat) return;
 	const unsupportedToolSchemaKeywords = Array.isArray(compat.unsupportedToolSchemaKeywords) ? compat.unsupportedToolSchemaKeywords.filter((keyword) => typeof keyword === "string") : [];
@@ -1063,25 +1098,14 @@ function resolveStrictOpenAISchemaCacheKey(modelCompat) {
 	const compat = resolveToolSchemaModelCompat(modelCompat);
 	return JSON.stringify([[...compat?.unsupportedToolSchemaKeywords ?? []].toSorted(), shouldOmitEmptyArrayItems(compat)]);
 }
-function readCachedStrictOpenAISchema(schema, key) {
-	return strictOpenAISchemaCache.get(schema)?.find((entry) => entry.key === key)?.value;
-}
-function rememberStrictOpenAISchema(schema, key, value) {
-	const entries = strictOpenAISchemaCache.get(schema) ?? [];
-	strictOpenAISchemaCache.set(schema, [{
-		key,
-		value
-	}, ...entries.filter((entry) => entry.key !== key)].slice(0, MAX_STRICT_SCHEMA_CACHE_ENTRIES_PER_SCHEMA));
-	return value;
-}
 /** Normalizes a tool parameter schema into the OpenAI strict JSON-schema subset. */
 function normalizeStrictOpenAIJsonSchema(schema, modelCompat) {
 	const schemaInput = schema ?? {};
 	if (!schemaInput || typeof schemaInput !== "object") return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0);
 	const cacheKey = resolveStrictOpenAISchemaCacheKey(modelCompat);
-	const cached = readCachedStrictOpenAISchema(schemaInput, cacheKey);
+	const cached = strictOpenAISchemaCache.get(schemaInput, cacheKey);
 	if (cached !== void 0) return cached;
-	return rememberStrictOpenAISchema(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
+	return strictOpenAISchemaCache.remember(schemaInput, cacheKey, normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schemaInput, { modelCompat: resolveToolSchemaModelCompat(modelCompat) }), 0));
 }
 function normalizeStrictOpenAIJsonSchemaRecursive(schema, depth) {
 	if (Array.isArray(schema)) {
@@ -1164,4 +1188,4 @@ function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	return projection.tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
 }
 //#endregion
-export { cleanSchemaForGemini as _, resolveOpenAIProjectedToolsStrictToolFlag as a, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, stripUnsupportedSchemaKeywords as f, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as g, findLlamacppGbnfSchemaViolations as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, cleanSchemaForLlamacppGbnf as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u };
+export { GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as _, resolveOpenAIProjectedToolsStrictToolFlag as a, extractToolSchemaModelCompat as c, shouldOmitEmptyArrayItems as d, withPreparedToolSchemaNormalization as f, findLlamacppGbnfSchemaViolations as g, cleanSchemaForLlamacppGbnf as h, normalizeStrictOpenAIJsonSchema as i, normalizeToolParameterSchema as l, LLAMACPP_GBNF_MAX_REPETITION_THRESHOLD as m, isStrictOpenAIJsonSchemaCompatible as n, findOpenAIStrictSchemaViolations as o, stripUnsupportedSchemaKeywords as p, normalizeOpenAIStrictToolParameters as r, normalizeOpenAIStrictCompatSchema as s, findOpenAIStrictToolProjectionDiagnostics as t, resolveUnsupportedToolSchemaKeywords as u, cleanSchemaForGemini as v };

package/dist/{openai-transport-params-9aPuV5YY.mjs → openai-transport-params-DQeuAvBl.mjs}

@@ -1,18 +1,20 @@
 import { a as normalizeOptionalString, n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { A as applyProviderReportedUsageCost, j as calculateCost, n as getAiTransportHost } from "./host-B8YfDGd4.mjs";
 import { o as isRecord, r as asOptionalObjectRecord } from "./record-coerce-DwRYMj3t.mjs";
-import { l as usesNativeOpenAICodexResponsesBackend, n as clampOpenAIPromptCacheKey, s as resolveOpenAICompletionsCompat } from "./openai-prompt-cache-Bds-n_9Q.mjs";
-import { i as isCodeModeModelVisibleToolName } from "./transport-utils-zrYjICLZ.mjs";
-import { n as resolveModelRequestTimeoutMs, o as resolveProviderRequestPolicyConfig } from "./host-policy-Zcg_cNz8.mjs";
-import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-ClptDdAO.mjs";
-import { O as headersToRecord, p as notifyProviderHttpResponse, v as transportAbortError } from "./transport-stream-shared-zHll9BxO.mjs";
+import { a as resolveOpenAIModelReasoningEfforts, d as MODEL_CATALOG_THINKING_LEVELS, i as normalizeOpenAIReasoningEffort, l as supportsOpenAIReasoningEffort, o as resolveOpenAIReasoningEffortForModel, p as resolveOpenAIThinkingApi, s as resolveOpenAIReasoningEffortMapping } from "./openai-reasoning-effort-NlFZmfEu.mjs";
+import { A as applyProviderReportedUsageCost, M as clampThinkingLevel, j as calculateCost, n as getAiTransportHost } from "./host-B4MeUNBc.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-1wfaIszn.mjs";
+import { i as isCodeModeModelVisibleToolName } from "./transport-utils-1cyq5Y7x.mjs";
+import { i as resolveOpenAICompletionsCompat, o as usesNativeOpenAICodexResponsesBackend } from "./openai-completions-compat-CkwdxTZx.mjs";
+import { n as resolveModelRequestTimeoutMs, o as resolveProviderRequestPolicyConfig } from "./host-policy-DUnXSx0I.mjs";
+import { n as projectRuntimeToolInputSchema, t as prepareRuntimeToolInputSchema } from "./tool-schema-json-projection-CD9c_fK8.mjs";
+import { O as headersToRecord, p as notifyProviderHttpResponse, v as transportAbortError } from "./transport-stream-shared-D-6FQSHm.mjs";
 import { n as resolveOpencodeSessionHeaders } from "./session-affinity-Bcunsn4I.mjs";
-import { i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DDOHA62Y.mjs";
-import { a as resolveOpenAIProjectedToolsStrictToolFlag, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-CzjyYXun.mjs";
-import { createHash } from "node:crypto";
+import { a as resolveOpenAIProjectedToolsStrictToolFlag, t as findOpenAIStrictToolProjectionDiagnostics } from "./openai-tool-schema-BO8rwyAD.mjs";
+import { i as OPENAI_RESPONSES_APIS } from "./openai-responses-contracts-DWrfMODE.mjs";
+import { hash } from "node:crypto";
 //#region packages/normalization-core/src/node-crypto.ts
 function sha256Hex(input) {
-	return createHash("sha256").update(input).digest("hex");
+	return hash("sha256", input, "hex");
 }
 function sha256HexPrefixCore(input, length) {
 	return sha256Hex(input).slice(0, length);
@@ -29,6 +31,16 @@ function redactIdentifier(value, opts) {
 /** Shared options, usage shape, cache identity, ordering, and stream scheduling for OpenAI APIs. */
 const MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS = 12;
 const MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS = 64;
+const OPENAI_RESPONSE_MODEL_HEADER_NAMES = /* @__PURE__ */ new Set(["openai-model", "x-openai-model"]);
+const OPENAI_RESPONSE_MODEL_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"response.created",
+	"response.in_progress",
+	"response.completed",
+	"response.done",
+	"response.incomplete",
+	"response.failed"
+]);
+const OPENAI_DATED_MODEL_SUFFIX = /-(?:\d{8}|\d{4}-\d{2}-\d{2})$/;
 const GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP = "skip_thought_signature_validator";
 const log = {
 	debug(message, data) {
@@ -44,6 +56,69 @@ const log = {
 		getAiTransportHost().logWarn("openai-transport", message, data);
 	}
 };
+const OPENAI_RESPONSE_MODEL_CONFLICT = "Conflicting OpenAI response model attestations";
+function splitOpenAIResponseModelHeader(value) {
+	return value ? value.split(",").map((part) => part.trim()).filter(Boolean) : [];
+}
+function readOpenAIResponseModelHeaders(headers) {
+	return [...OPENAI_RESPONSE_MODEL_HEADER_NAMES].flatMap((name) => splitOpenAIResponseModelHeader(headers.get(name)));
+}
+function readOpenAIResponseModelHeaderRecord(headers) {
+	if (!isRecord(headers)) return [];
+	return Object.entries(headers).filter(([name]) => OPENAI_RESPONSE_MODEL_HEADER_NAMES.has(name.toLowerCase())).flatMap(([, value]) => typeof value === "string" ? splitOpenAIResponseModelHeader(value) : []);
+}
+function readOpenAIResponseModelEvent(event) {
+	if (!isRecord(event)) return [];
+	const response = isRecord(event.response) ? event.response : void 0;
+	return [
+		...OPENAI_RESPONSE_MODEL_EVENT_TYPES.has(String(event.type)) && typeof response?.model === "string" && response.model.trim() ? [response.model.trim()] : [],
+		...readOpenAIResponseModelHeaderRecord(response?.headers),
+		...readOpenAIResponseModelHeaderRecord(event.headers)
+	];
+}
+function reconcileOpenAIResponseModels(current, observed) {
+	if (!current || current === observed) return observed;
+	const currentBase = current.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	const observedBase = observed.replace(OPENAI_DATED_MODEL_SUFFIX, "");
+	if (currentBase !== observedBase) return;
+	if (currentBase === current && observedBase !== observed) return observed;
+	if (observedBase === observed && currentBase !== current) return current;
+}
+function createResponseModelTracker(enabled = true) {
+	let responseModel;
+	const observe = (models) => {
+		for (const model of models) {
+			const reconciled = reconcileOpenAIResponseModels(responseModel, model);
+			if (!reconciled) throw new Error(OPENAI_RESPONSE_MODEL_CONFLICT);
+			responseModel = reconciled;
+		}
+	};
+	const begin = (headers) => {
+		responseModel = void 0;
+		if (enabled && headers) observe(readOpenAIResponseModelHeaders(headers));
+	};
+	const observeEvent = (event) => {
+		if (enabled) observe(readOpenAIResponseModelEvent(event));
+		return responseModel;
+	};
+	const resolve = () => responseModel;
+	return {
+		begin,
+		observeEvent,
+		resolve,
+		track(response, stream) {
+			if (!enabled) return stream;
+			return (async function* () {
+				begin(response?.headers);
+				for await (const event of stream) {
+					observeEvent(event);
+					yield event;
+				}
+			})();
+		},
+		terminalOptions: enabled ? { resolveResponseModel: resolve } : {}
+	};
+}
 function resolveOpenAIClientBaseUrl(model, baseUrl = model.baseUrl) {
 	if (baseUrl?.trim()) return baseUrl;
 	if (model.provider.trim().toLowerCase() === "openai") return;
@@ -192,14 +267,13 @@ function createModelStreamCooperativeScheduler(signal) {
 	return { async afterEvent() {
 		throwIfModelStreamAborted(signal);
 		eventsSinceYield += 1;
-		const now = Date.now();
-		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && now - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
+		if (eventsSinceYield < MODEL_STREAM_COOPERATIVE_YIELD_MAX_EVENTS && Date.now() - lastYieldedAt < MODEL_STREAM_COOPERATIVE_YIELD_INTERVAL_MS) return;
 		eventsSinceYield = 0;
-		lastYieldedAt = now;
 		await new Promise((resolve) => {
 			setTimeout(resolve, 0);
 		});
 		throwIfModelStreamAborted(signal);
+		lastYieldedAt = Date.now();
 	} };
 }
 function resolvePromptCacheKey(options, cacheRetention) {
@@ -262,6 +336,45 @@ function readOpenAICompletionsContentPartDeltas(content) {
 	return [];
 }
 //#endregion
+//#region packages/ai/src/transports/openai-reasoning-compat.ts
+/** Explicit model reasoning-effort compatibility metadata. */
+function readCompatReasoningEffortMap(compat) {
+	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
+	if (!rawMap) return {};
+	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[1] === "string"));
+}
+/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
+function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
+	return {
+		...fallbackMap,
+		...readCompatReasoningEffortMap(model.compat)
+	};
+}
+//#endregion
+//#region packages/ai/src/providers/openai-request-reasoning.ts
+/** Preserve explicit off until the selected route maps it to its native value. */
+function resolveOpenAISimpleReasoningEffort(model, reasoning) {
+	return reasoning === void 0 ? void 0 : clampThinkingLevel(model, reasoning);
+}
+function resolveOpenAIRequestReasoning(model, reasoning) {
+	const requested = normalizeOpenAIReasoningEffort(reasoning ?? "off");
+	const modelLevel = MODEL_CATALOG_THINKING_LEVELS.find((candidate) => candidate === requested);
+	const modelMapped = modelLevel ? model.thinkingLevelMap?.[modelLevel] : void 0;
+	const mapped = modelMapped === null ? null : resolveOpenAIReasoningEffortMapping(requested, resolveOpenAIReasoningEffortMap(model)) ?? modelMapped;
+	const intent = mapped !== void 0 ? mapped?.trim() : reasoning === void 0 ? void 0 : requested;
+	const normalizedIntent = normalizeOpenAIReasoningEffort(intent ?? "off");
+	const supported = resolveOpenAIModelReasoningEfforts(model);
+	const effort = !model.reasoning || supported?.length === 0 || intent === void 0 ? void 0 : supported === void 0 ? mapped !== void 0 ? intent : requested === "off" ? "none" : requested : resolveOpenAIReasoningEffortForModel({
+		model,
+		effort: requested,
+		fallbackMap: { [requested]: intent }
+	});
+	return {
+		effort: effort === "none" && resolveOpenAIThinkingApi(model.api) === "openai-chatgpt-responses" && !supportsOpenAIReasoningEffort({ compat: model.compat }, "none") ? void 0 : effort,
+		thinkingEnabled: intent === void 0 ? void 0 : model.reasoning && normalizedIntent !== "off" && normalizedIntent !== "none"
+	};
+}
+//#endregion
 //#region packages/ai/src/providers/openai-tool-projection.ts
 function unreadableToolDiagnostic(toolIndex) {
 	return {
@@ -271,6 +384,17 @@ function unreadableToolDiagnostic(toolIndex) {
 }
 /** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
 function projectOpenAITools(tools) {
+	return projectOpenAIToolDescriptors(tools);
+}
+/** Package-private facts are consumed before the projection or payload can escape. */
+function prepareOpenAITools(tools) {
+	const schemas = /* @__PURE__ */ new Map();
+	return {
+		projection: projectOpenAIToolDescriptors(tools, schemas),
+		schemas
+	};
+}
+function projectOpenAIToolDescriptors(tools, schemas) {
 	let inputToolCount;
 	try {
 		inputToolCount = tools.length;
@@ -324,7 +448,8 @@ function projectOpenAITools(tools) {
 			});
 			continue;
 		}
-		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
+		const prepared = schemas ? prepareRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`) : void 0;
+		const schemaProjection = prepared?.projection ?? projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
 		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
 			diagnostics.push({
 				toolIndex,
@@ -333,6 +458,7 @@ function projectOpenAITools(tools) {
 			});
 			continue;
 		}
+		if (prepared?.normalization) schemas?.set(schemaProjection.schema, prepared.normalization);
 		let descriptionValue;
 		try {
 			descriptionValue = tool.description;
@@ -448,36 +574,10 @@ function reconcileOpenAICompletionsToolChoice(choice, projection) {
 	};
 }
 //#endregion
-//#region packages/ai/src/transports/openai-reasoning-compat.ts
-/**
-* OpenAI reasoning-effort compatibility helpers.
-*
-* Keeps provider metadata and built-in model exceptions on one path before request payloads are built.
-*/
-const OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS = /* @__PURE__ */ new Set(["gpt-5.1-codex-mini"]);
-function readCompatReasoningEffortMap(compat) {
-	const rawMap = asOptionalObjectRecord(asOptionalObjectRecord(compat)?.reasoningEffortMap);
-	if (!rawMap) return {};
-	return Object.fromEntries(Object.entries(rawMap).filter((entry) => typeof entry[0] === "string" && typeof entry[1] === "string"));
-}
-/** Resolves the reasoning effort remap for an OpenAI-compatible model. */
-function resolveOpenAIReasoningEffortMap(model, fallbackMap = {}) {
-	const provider = normalizeLowercaseStringOrEmpty(model.provider ?? "");
-	const id = normalizeLowercaseStringOrEmpty(model.id ?? "");
-	const builtinMap = provider === "openai" && OPENAI_MEDIUM_ONLY_REASONING_MODEL_IDS.has(id) ? {
-		minimal: "medium",
-		low: "medium"
-	} : {};
-	return {
-		...fallbackMap,
-		...builtinMap,
-		...readCompatReasoningEffortMap(model.compat)
-	};
-}
-//#endregion
 //#region packages/ai/src/transports/openai-transport-params.ts
 const MAX_OPENAI_STRICT_TOOL_DOWNGRADE_DIAGNOSTIC_KEYS = 256;
 const loggedOpenAIStrictToolDowngradeDiagnosticKeys = /* @__PURE__ */ new Set();
+const OPENAI_COMPLETIONS_APIS = /* @__PURE__ */ new Set(["openai-completions", "openclaw-openai-completions-transport"]);
 function readToolPayloadField(record, field) {
 	try {
 		return Object.hasOwn(record, field) ? record[field] : void 0;
@@ -616,6 +716,19 @@ function resolveOpenAIStrictToolFlagWithDiagnostics(projection, strictSetting, c
 function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, sessionId, cacheRetention) {
 	const providerHeaders = { ...model.headers };
 	if (model.provider === "github-copilot") Object.assign(providerHeaders, getAiTransportHost().buildCopilotDynamicHeaders(context.messages));
+	if (OPENAI_COMPLETIONS_APIS.has(model.api) && sessionId && cacheRetention !== "none") {
+		const { sessionAffinity } = resolveOpenAICompletionsCompat(model);
+		if (sessionAffinity !== "none") {
+			const affinityValue = clampOpenAIPromptCacheKey(sessionId) ?? sessionId;
+			const affinityHeaders = sessionAffinity === "openrouter" ? ["x-session-id"] : [
+				"session_id",
+				"x-client-request-id",
+				"x-session-affinity"
+			];
+			const configuredHeaders = new Set(Object.keys(providerHeaders).map((key) => key.toLowerCase()));
+			for (const name of affinityHeaders) if (!configuredHeaders.has(name)) providerHeaders[name] = affinityValue;
+		}
+	}
 	const callerHeaders = {
 		...optionHeaders,
 		...turnHeaders
@@ -637,18 +750,15 @@ function buildOpenAIClientHeaders(model, context, optionHeaders, turnHeaders, se
 		headers: resolvedHeaders
 	}) ?? resolvedHeaders;
 }
-function resolveOpenAISdkTimeoutMs(model, timeoutMs) {
-	return resolveModelRequestTimeoutMs(model, timeoutMs);
-}
 function buildOpenAISdkClientOptions(model) {
-	const timeout = resolveOpenAISdkTimeoutMs(model);
+	const timeout = resolveModelRequestTimeoutMs(model);
 	return {
 		...timeout === void 0 ? {} : { timeout },
 		maxRetries: 0
 	};
 }
 function buildOpenAISdkRequestOptions(model, signal, options) {
-	const timeout = resolveOpenAISdkTimeoutMs(model, options?.timeoutMs);
+	const timeout = resolveModelRequestTimeoutMs(model, options?.timeoutMs);
 	const headers = options?.stream === true && usesNativeOpenAICodexResponsesBackend(model) ? { Accept: "text/event-stream" } : void 0;
 	if (timeout === void 0 && !signal && !headers) return;
 	return {
@@ -672,4 +782,4 @@ function getCompat(model) {
 	};
 }
 //#endregion
-export { readOpenAICompletionsContentDeltas as C, throwIfModelStreamAborted as D, resolvePromptCacheKey as E, redactIdentifier as O, parseOpenAICompletionsUsage as S, resolveOpenAIClientBaseUrl as T, createOpenAIProviderAcceptanceHook as _, enforceCodeModeResponsesToolSurface as a, log as b, readCodeModePayloadToolName as c, resolveOpenAIReasoningEffortMap as d, projectOpenAITools as f, createModelStreamCooperativeScheduler as g, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as h, buildOpenAISdkRequestOptions as i, sha256Hex as k, resolveCodeModeResponsesVisibleToolNames as l, reconcileOpenAIResponsesToolChoice as m, buildOpenAIClientHeaders as n, filterCodeModePayloadTools as o, reconcileOpenAICompletionsToolChoice as p, buildOpenAISdkClientOptions as r, getCompat as s, assertCodeModeResponsesToolSurface as t, resolveOpenAIStrictToolFlagWithDiagnostics as u, createOpenAIResponseHook as v, readOpenAICompletionsReasoningBatch as w, measureUtf8AppendBytes as x, isOpenAICompletionsThinkingEnabled as y };
+export { resolvePromptCacheKey as A, isOpenAICompletionsThinkingEnabled as C, readOpenAICompletionsContentDeltas as D, parseOpenAICompletionsUsage as E, redactIdentifier as M, sha256Hex as N, readOpenAICompletionsReasoningBatch as O, createResponseModelTracker as S, measureUtf8AppendBytes as T, resolveOpenAIReasoningEffortMap as _, enforceCodeModeResponsesToolSurface as a, createOpenAIProviderAcceptanceHook as b, readCodeModePayloadToolName as c, prepareOpenAITools as d, projectOpenAITools as f, resolveOpenAISimpleReasoningEffort as g, resolveOpenAIRequestReasoning as h, buildOpenAISdkRequestOptions as i, throwIfModelStreamAborted as j, resolveOpenAIClientBaseUrl as k, resolveCodeModeResponsesVisibleToolNames as l, reconcileOpenAIResponsesToolChoice as m, buildOpenAIClientHeaders as n, filterCodeModePayloadTools as o, reconcileOpenAICompletionsToolChoice as p, buildOpenAISdkClientOptions as r, getCompat as s, assertCodeModeResponsesToolSurface as t, resolveOpenAIStrictToolFlagWithDiagnostics as u, GEMINI_THOUGHT_SIGNATURE_VALIDATOR_SKIP as v, log as w, createOpenAIResponseHook as x, createModelStreamCooperativeScheduler as y };

package/dist/{positive-integer-41zhOdcV.mjs → positive-integer-DtjCkbue.mjs}

@@ -1,4 +1,4 @@
-import { o as parseStrictPositiveInteger } from "./base64-D-su8YVo.mjs";
+import { o as parseStrictPositiveInteger } from "./base64-BQOzsvUH.mjs";
 //#region packages/ai/src/transports/positive-integer.ts
 function parsePositiveInteger(value) {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);