@openclaw/ai 2026.7.2-beta.3 → 2026.7.2-beta.4

package/dist/{openai-responses-shared-CwnGU0KW.mjs → openai-responses-shared-CzCurmY1.mjs}

@@ -1,12 +1,12 @@
-import { n as getAiTransportHost } from "./host-4t713IeR.mjs";
+import { n as getAiTransportHost } from "./host-XYGZcgO8.mjs";
+import { C as isImageWithMediaPayload, T as isRecord, _ as normalizeOptionalString, a as stripSystemPromptCacheBoundary, c as transformMessages, g as normalizeLowercaseStringOrEmpty, x as extractToolResultText, y as describeToolResultMediaPlaceholder } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
 import { n as calculateCost, r as clampThinkingLevel } from "./model-utils-1GiZ2_rr.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { n as parseStreamingJson } from "./json-parse-BvXNt1-7.mjs";
-import { t as sanitizeSurrogates } from "./sanitize-unicode-DT5o51ur.mjs";
-import { D as normalizeLowercaseStringOrEmpty, O as normalizeOptionalString, f as isRecord, i as extractToolResultText, n as describeToolResultMediaPlaceholder, o as isImageWithMediaPayload, t as transformMessages, w as stripSystemPromptCacheBoundary } from "./transform-messages-eb6lxDLB.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-RjWszj8c.mjs";
-import { t as projectOpenAITools } from "./openai-tool-projection-WHf2nuOI.mjs";
 import { t as shortHash } from "./hash-CHgqbJmD.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DP4xEyBY.mjs";
+import { t as projectOpenAITools } from "./openai-tool-projection-ITOU9bG1.mjs";
 import { createHash, randomUUID } from "node:crypto";
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
@@ -1076,6 +1076,66 @@ function resolveResponsesMessageSnapshotCollapse(params) {
 	return { kind: "keep" };
 }
 //#endregion
+//#region packages/ai/src/providers/openai-responses-terminal-usage.ts
+function readCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+* 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.
+*/
+function mapResponsesTerminalUsage(usage) {
+	if (!usage) return;
+	const cacheRead = readCount(usage.input_tokens_details?.cached_tokens);
+	const cacheWrite = readCount(usage.input_tokens_details?.cache_write_tokens);
+	const input = Math.max(0, readCount(usage.input_tokens) - cacheRead - cacheWrite);
+	const output = readCount(usage.output_tokens);
+	const bucketTotal = input + output + cacheRead + cacheWrite;
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: Math.max(bucketTotal, readCount(usage.total_tokens))
+	};
+}
+/** Reasoning tokens are reported by the agent path only; the package path does not track them. */
+function readResponsesReasoningTokens(usage) {
+	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens;
+	return typeof reasoningTokens === "number" && Number.isFinite(reasoningTokens) ? reasoningTokens : void 0;
+}
+function mapResponsesTerminalStopReason(status) {
+	if (!status) return "stop";
+	switch (status) {
+		case "completed": return "stop";
+		case "incomplete": return "length";
+		case "failed":
+		case "cancelled": return "error";
+		case "in_progress":
+		case "queued": return "stop";
+		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
+	}
+}
+/**
+* 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.
+*/
+function resolveResponsesTerminalStopReason(params) {
+	if (params.status === "incomplete" && params.incompleteReason === "content_filter") return {
+		stopReason: "error",
+		errorMessage: "Provider incomplete_reason: content_filter"
+	};
+	const stopReason = mapResponsesTerminalStopReason(params.status);
+	if (stopReason === "stop" && params.hasToolCall) return { stopReason: "toolUse" };
+	return { stopReason };
+}
+//#endregion
 //#region packages/ai/src/providers/openai-responses-tool-call-tracker.ts
 function readIdentityValue(value) {
 	return (typeof value === "string" ? value.trim() : "") || void 0;
@@ -1152,6 +1212,151 @@ function createResponsesToolCallTracker() {
 	};
 }
 //#endregion
+//#region packages/ai/src/providers/openai-tool-schema-compat.ts
+const OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS = /* @__PURE__ */ new Set([
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"dependencies",
+	"patternProperties",
+	"properties"
+]);
+const OPENAI_NULLABLE_ANNOTATION_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"description",
+	"examples",
+	"format",
+	"title"
+]);
+const OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS = /* @__PURE__ */ new Set([
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"oneOf",
+	"prefixItems",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function normalizeOpenAIStrictCompatSchemaMap(schema) {
+	if (!schema || typeof schema !== "object" || Array.isArray(schema)) return schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(schema)) {
+		const next = normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false });
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	return changed ? normalized : schema;
+}
+function normalizeOpenAIStrictCompatSchemaRecursive(schema, options) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeOpenAIStrictCompatSchemaRecursive(entry, { promoteEmptyObject: false });
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") return schema;
+	const record = schema;
+	let changed = false;
+	let hadNullType = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		if (value === null && OPENAI_NULLABLE_ANNOTATION_KEYS.has(key)) {
+			changed = true;
+			continue;
+		}
+		if (value === null && key === "type") {
+			hadNullType = true;
+			changed = true;
+			continue;
+		}
+		const next = OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaMap(value) : OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS.has(key) ? normalizeOpenAIStrictCompatSchemaRecursive(value, { promoteEmptyObject: false }) : value;
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (Object.keys(normalized).length === 0) {
+		if (!options.promoteEmptyObject) return schema;
+		return {
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false
+		};
+	}
+	const hasObjectShapeHints = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) || Array.isArray(normalized.required);
+	const hasArrayShapeHints = "items" in normalized;
+	if (!("type" in normalized) && hasObjectShapeHints !== hasArrayShapeHints) {
+		normalized.type = hasObjectShapeHints ? "object" : "array";
+		changed = true;
+	} else if (hadNullType && !("type" in normalized)) normalized.type = null;
+	if (normalized.type === "object" && !("properties" in normalized)) {
+		normalized.properties = {};
+		changed = true;
+	}
+	const hasEmptyProperties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) && Object.keys(normalized.properties).length === 0;
+	if (normalized.type === "object" && !Array.isArray(normalized.required) && hasEmptyProperties) {
+		normalized.required = [];
+		changed = true;
+	}
+	if (normalized.type === "object" && hasEmptyProperties && !("additionalProperties" in normalized)) {
+		normalized.additionalProperties = false;
+		changed = true;
+	}
+	return changed ? normalized : schema;
+}
+/** Repairs recoverable OpenAI tool-schema shapes before canonical normalization. */
+function normalizeOpenAIStrictCompatSchema(schema) {
+	return normalizeOpenAIStrictCompatSchemaRecursive(schema, { promoteEmptyObject: true });
+}
+/** Finds schema paths that violate OpenAI strict tool-schema requirements. */
+function findOpenAIStrictSchemaViolations(schema, path, options) {
+	if (Array.isArray(schema)) {
+		if (options?.requireObjectRoot) return [`${path}.type`];
+		return schema.flatMap((item, index) => findOpenAIStrictSchemaViolations(item, `${path}[${index}]`));
+	}
+	if (!schema || typeof schema !== "object") return options?.requireObjectRoot ? [`${path}.type`] : [];
+	const record = schema;
+	const violations = [];
+	for (const key of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) if (key in record) violations.push(`${path}.${key}`);
+	if (Array.isArray(record.type)) violations.push(`${path}.type`);
+	const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0;
+	if (record.type === "object") {
+		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
+		if (!required) violations.push(`${path}.required`);
+		else if (properties) {
+			const requiredSet = new Set(required);
+			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
+		}
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_MAP_KEYS) {
+		const schemaMap = record[key];
+		if (!schemaMap || typeof schemaMap !== "object" || Array.isArray(schemaMap)) continue;
+		for (const [entryKey, value] of Object.entries(schemaMap)) violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}.${entryKey}`));
+	}
+	for (const key of OPENAI_STRICT_COMPAT_SCHEMA_NESTED_KEYS) {
+		const value = record[key];
+		if (value && typeof value === "object") violations.push(...findOpenAIStrictSchemaViolations(value, `${path}.${key}`));
+	}
+	return violations;
+}
+//#endregion
 //#region packages/ai/src/providers/openai-tool-schema.ts
 /**
 * OpenAI strict JSON-schema normalization for tool inventories and request payloads.
@@ -1245,7 +1450,7 @@ function findOpenAIStrictToolProjectionDiagnostics(projection) {
 		...diagnostic.toolName ? { toolName: diagnostic.toolName } : {},
 		violations: [...diagnostic.violations]
 	})), ...projection.tools.flatMap((tool) => {
-		const violations = findStrictOpenAIJsonSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
+		const violations = findOpenAIStrictSchemaViolations(normalizeStrictOpenAIJsonSchema(tool.parameters), `${tool.name}.parameters`);
 		return violations.length > 0 ? [{
 			toolIndex: tool.toolIndex,
 			toolName: tool.name,
@@ -1272,34 +1477,6 @@ function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
 		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
 	});
 }
-function findStrictOpenAIJsonSchemaViolations(schema, path) {
-	if (Array.isArray(schema)) return schema.flatMap((entry, index) => findStrictOpenAIJsonSchemaViolations(entry, `${path}[${index}]`));
-	if (!schema || typeof schema !== "object") return [];
-	const record = schema;
-	const violations = [];
-	for (const key of [
-		"anyOf",
-		"oneOf",
-		"allOf"
-	]) if (key in record) violations.push(`${path}.${key}`);
-	if (Array.isArray(record.type)) violations.push(`${path}.type`);
-	if (record.type === "object") {
-		if (record.additionalProperties !== false) violations.push(`${path}.additionalProperties`);
-		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
-		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : void 0;
-		if (!required) violations.push(`${path}.required`);
-		else {
-			const requiredSet = new Set(required);
-			for (const key of Object.keys(properties)) if (!requiredSet.has(key)) violations.push(`${path}.required.${key}`);
-		}
-	}
-	if (record.properties && typeof record.properties === "object" && !Array.isArray(record.properties)) for (const [key, value] of Object.entries(record.properties)) violations.push(...findStrictOpenAIJsonSchemaViolations(value, `${path}.properties.${key}`));
-	for (const [key, value] of Object.entries(record)) {
-		if (key === "properties") continue;
-		if (value && typeof value === "object") violations.push(...findStrictOpenAIJsonSchemaViolations(value, `${path}.${key}`));
-	}
-	return violations;
-}
 /** Resolves strict mode for the projected tools that will be emitted in the request payload. */
 function resolveOpenAIProjectedToolsStrictToolFlag(projection, strict) {
 	if (strict !== true) return strict === false ? false : void 0;
@@ -1874,35 +2051,29 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 		terminalResponseEvent = "finalized";
 		backfillReasoningSignatures(response.output ?? []);
 		if (response.id) output.responseId = response.id;
-		if (response.usage) {
-			const inputTokenDetails = response.usage.input_tokens_details;
-			const cachedTokens = inputTokenDetails?.cached_tokens || 0;
-			const cacheWriteTokens = inputTokenDetails?.cache_write_tokens || 0;
-			output.usage = {
-				input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
-				output: response.usage.output_tokens || 0,
-				cacheRead: cachedTokens,
-				cacheWrite: cacheWriteTokens,
-				totalTokens: response.usage.total_tokens || 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			};
-		}
+		const mappedUsage = mapResponsesTerminalUsage(response.usage);
+		if (mappedUsage) output.usage = {
+			...mappedUsage,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		};
 		calculateCost(model, output.usage);
 		if (options?.applyServiceTierPricing) {
 			const serviceTier = options.resolveServiceTier ? options.resolveServiceTier(response.service_tier, options.serviceTier) : response.service_tier ?? options.serviceTier;
 			options.applyServiceTierPricing(output.usage, serviceTier);
 		}
-		if (response.status === "incomplete" && response.incomplete_details?.reason === "content_filter") {
-			output.stopReason = "error";
-			output.errorMessage = "Provider incomplete_reason: content_filter";
-		} else output.stopReason = mapStopReason(response.status);
-		if (output.content.some((block) => block.type === "toolCall") && output.stopReason === "stop") output.stopReason = "toolUse";
+		const terminal = resolveResponsesTerminalStopReason({
+			status: response.status,
+			incompleteReason: response.incomplete_details?.reason,
+			hasToolCall: output.content.some((block) => block.type === "toolCall")
+		});
+		output.stopReason = terminal.stopReason;
+		if (terminal.errorMessage) output.errorMessage = terminal.errorMessage;
 	};
 	const guardedStream = withFirstStreamEventTimeout(openaiStream, {
 		provider: model.provider,
@@ -2217,17 +2388,5 @@ async function processResponsesStream(openaiStream, output, stream, model, optio
 	if (streamingToolCalls.hasActive()) throw new Error("Responses stream ended with unresolved tool calls");
 	if (!terminalResponseEvent) throw new Error("OpenAI Responses stream ended before a terminal response event");
 }
-function mapStopReason(status) {
-	if (!status) return "stop";
-	switch (status) {
-		case "completed": return "stop";
-		case "incomplete": return "length";
-		case "failed":
-		case "cancelled": return "error";
-		case "in_progress":
-		case "queued": return "stop";
-		default: throw new Error(`Unhandled stop reason: ${String(status)}`);
-	}
-}
 //#endregion
-export { resolveOpenAISupportedReasoningEfforts as A, isResponsesTextDeltaEventType as C, isOpenAIGpt56Model as D, isOpenAIGpt55Model as E, resolveUnsupportedToolSchemaKeywords as F, shouldOmitEmptyArrayItems as I, stripUnsupportedSchemaKeywords as L, supportsOpenAITemperature as M, extractToolSchemaModelCompat as N, normalizeOpenAIReasoningEffort as O, normalizeToolParameterSchema as P, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as R, isResponsesTextContentPartType as S, isOpenAIGpt54MiniModel as T, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as _, resolveResponsesReasoningEffort as a, isAzureResponsesTextDeltaEvent as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as g, readResponsesToolCallItemIdentity as h, processResponsesStream as i, supportsOpenAIReasoningEffort as j, resolveOpenAIReasoningEffortForModel as k, findOpenAIStrictToolProjectionDiagnostics as l, createResponsesToolCallTracker as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as v, resolveResponsesMessageSnapshotCollapse as w, isAzureResponsesTextDeltaEventType as x, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as y, cleanSchemaForGemini as z };
+export { isOpenAIGpt54MiniModel as A, resolveUnsupportedToolSchemaKeywords as B, OPENAI_RESPONSES_OUTPUT_TEXT_CONTENT_PART_TYPE as C, isResponsesTextContentPartType as D, isAzureResponsesTextDeltaEventType as E, resolveOpenAISupportedReasoningEfforts as F, uniqueStrings as G, stripUnsupportedSchemaKeywords as H, supportsOpenAIReasoningEffort as I, supportsOpenAITemperature as L, isOpenAIGpt56Model as M, normalizeOpenAIReasoningEffort as N, isResponsesTextDeltaEventType as O, resolveOpenAIReasoningEffortForModel as P, extractToolSchemaModelCompat as R, AZURE_RESPONSES_TEXT_DELTA_EVENT_TYPE as S, isAzureResponsesTextDeltaEvent as T, GEMINI_UNSUPPORTED_SCHEMA_KEYWORDS as U, shouldOmitEmptyArrayItems as V, cleanSchemaForGemini as W, readResponsesToolCallItemIdentity as _, resolveResponsesReasoningEffort as a, resolveResponsesTerminalStopReason as b, clearOpenAIToolSchemaCacheForTest as c, normalizeOpenAIStrictToolParameters as d, normalizeStrictOpenAIJsonSchema as f, createResponsesToolCallTracker as g, normalizeOpenAIStrictCompatSchema as h, processResponsesStream as i, isOpenAIGpt55Model as j, resolveResponsesMessageSnapshotCollapse as k, findOpenAIStrictToolProjectionDiagnostics as l, findOpenAIStrictSchemaViolations as m, convertResponsesMessages as n, runResponsesStreamLifecycle as o, resolveOpenAIProjectedToolsStrictToolFlag as p, createResponsesAssistantOutput as r, convertResponsesToolPayload as s, applyCommonResponsesParams as t, isStrictOpenAIJsonSchemaCompatible as u, mapResponsesTerminalUsage as v, OPENAI_RESPONSES_OUTPUT_TEXT_DELTA_EVENT_TYPE as w, AZURE_RESPONSES_TEXT_CONTENT_PART_TYPE as x, readResponsesReasoningTokens as y, normalizeToolParameterSchema as z };

package/dist/{openai-tool-projection-WHf2nuOI.mjs → openai-tool-projection-ITOU9bG1.mjs}

@@ -1,4 +1,4 @@
-import { f as isRecord } from "./transform-messages-eb6lxDLB.mjs";
+import { T as isRecord } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
 import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
 //#region packages/ai/src/providers/openai-prompt-cache.ts
 /** Maximum prompt cache key length accepted by OpenAI-compatible request metadata. */

package/dist/{provider-error-LMfTEkfO.mjs → provider-error-C4VvV_3t.mjs}

@@ -1,3 +1,4 @@
+import { w as truncateUtf16Safe } from "./system-prompt-cache-boundary-CbHeV4_l.mjs";
 //#region packages/ai/src/utils/provider-error.ts
 const MAX_ERROR_BODY_LENGTH = 4e3;
 function stringify(value) {
@@ -25,7 +26,7 @@ function readBody(error) {
 		if (value === void 0 || value === null) continue;
 		if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) continue;
 		const body = (typeof value === "string" ? value : stringify(value)).trim();
-		if (body.length > 0) return body.length <= MAX_ERROR_BODY_LENGTH ? body : `${body.slice(0, MAX_ERROR_BODY_LENGTH)}... [truncated]`;
+		if (body.length > 0) return body.length <= MAX_ERROR_BODY_LENGTH ? body : `${truncateUtf16Safe(body, MAX_ERROR_BODY_LENGTH)}... [truncated]`;
 	}
 }
 function formatProviderError(error) {

package/dist/providers.d.mts

@@ -1,4 +1,4 @@
-import { n as ApiRegistry } from "./api-registry-DXBIXISf.mjs";
+import { n as ApiRegistry } from "./api-registry-BMphkFf1.mjs";
 
 //#region packages/ai/src/providers/register-builtins.d.ts
 /** Source id used for built-in API provider registrations. */

package/dist/providers.mjs

@@ -63,35 +63,35 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-D7SyZQ5v.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-CrUDIBpM.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-zLDfebnN.mjs").then((n) => n.n), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-exO8NFQf.mjs").then((n) => n.n), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-BdrQmDWp.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-D5Ps7Led.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-ClspWt4I.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-BHpmtUKo.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-BkZgyZ3I.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-CbrpVeEv.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-DP63Qt01.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-h0o5yV8Y.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-C_biGbV7.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-Cs62KA7t.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-CvdzF1U7.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-B4SD3U0f.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))

package/dist/{stream-first-event-timeout-RjWszj8c.mjs → stream-first-event-timeout-DP4xEyBY.mjs}

@@ -3,6 +3,40 @@
 function asFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
+/** Returns a finite number only when it satisfies the supplied inclusive/exclusive bounds. */
+function asFiniteNumberInRange(value, range) {
+	const number = asFiniteNumber(value);
+	if (number === void 0) return;
+	if (range.min !== void 0) {
+		if (range.minExclusive ? number <= range.min : number < range.min) return;
+	}
+	if (range.max !== void 0) {
+		if (range.maxExclusive ? number >= range.max : number > range.max) return;
+	}
+	return number;
+}
+function normalizeNumericString(value) {
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+/** Parses only safe integer numbers or base-10 integer strings. */
+function parseStrictInteger(value) {
+	if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
+	if (typeof value !== "string") return;
+	const normalized = normalizeNumericString(value);
+	if (!normalized || !/^[+-]?\d+$/.test(normalized)) return;
+	const parsed = Number(normalized);
+	return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+/** Parses only finite decimal/scientific string tokens, rejecting partial numbers. */
+function parseStrictFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value !== "string") return;
+	const normalized = normalizeNumericString(value);
+	if (!normalized || !/^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:e[+-]?\d+)?$/i.test(normalized)) return;
+	const parsed = Number(normalized);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
 /** Conservative upper bound for Node timer delays. */
 const MAX_TIMER_TIMEOUT_MS = 2147e6;
 /** Clamps finite millisecond values into the Node-safe timer range. */
@@ -18,6 +52,16 @@ function resolveTimerTimeoutMs(valueMs, fallbackMs, minMs = 1) {
 	if (value === void 0) return min;
 	return Math.min(Math.max(Math.floor(value), min), MAX_TIMER_TIMEOUT_MS);
 }
+/** Parses strict positive integer values from numbers or strings. */
+function parseStrictPositiveInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed > 0 ? parsed : void 0;
+}
+/** Parses strict non-negative integer values from numbers or strings. */
+function parseStrictNonNegativeInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
+}
 //#endregion
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
@@ -103,4 +147,4 @@ function withFirstStreamEventTimeout(stream, context) {
 	} };
 }
 //#endregion
-export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, clampTimerTimeoutMs as o, getFirstStreamEventTimeoutHandler as r, resolveTimerTimeoutMs as s, createFirstStreamEventAbortController as t };
+export { withFirstStreamEventTimeout as a, parseStrictFiniteNumber as c, resolveTimerTimeoutMs as d, getFirstStreamEventTimeoutMs as i, parseStrictNonNegativeInteger as l, createFirstStreamEventTimeoutError as n, asFiniteNumberInRange as o, getFirstStreamEventTimeoutHandler as r, clampTimerTimeoutMs as s, createFirstStreamEventAbortController as t, parseStrictPositiveInteger as u };