@openclaw/ai 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/openai-tool-projection-OhX64DoP.mjs

@@ -0,0 +1,215 @@
+import { g as isRecord, n as getAiTransportHost } from "./host-Dog2WQiR.mjs";
+import { t as projectRuntimeToolInputSchema } from "./tool-schema-json-projection-BwNu3nDi.mjs";
+//#region packages/ai/src/transports/host-policy.ts
+function buildGuardedModelFetch(model, timeoutMs, options) {
+	const host = getAiTransportHost();
+	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
+	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
+	return host.buildModelFetch(model) ?? globalThis.fetch;
+}
+function resolveProviderEndpoint(baseUrl) {
+	return { endpointClass: getAiTransportHost().resolveProviderEndpointClass(baseUrl) };
+}
+function resolveProviderRequestCapabilities(input) {
+	return getAiTransportHost().resolveProviderRequestCapabilities(input);
+}
+function resolveProviderRequestPolicyConfig(input) {
+	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
+}
+function resolveModelRequestTimeoutMs(model, timeoutMs) {
+	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
+}
+function resolveOpenAIStrictToolSetting(model, options) {
+	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
+}
+function transformTransportMessages(messages, model, normalizeToolCallId, options) {
+	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
+}
+//#endregion
+//#region packages/ai/src/providers/openai-tool-projection.ts
+function unreadableToolDiagnostic(toolIndex) {
+	return {
+		toolIndex,
+		violations: [`tool[${toolIndex}] is unreadable`]
+	};
+}
+/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
+function projectOpenAITools(tools) {
+	let inputToolCount;
+	try {
+		inputToolCount = tools.length;
+	} catch {
+		return {
+			inputToolCount: 0,
+			tools: [],
+			diagnostics: [unreadableToolDiagnostic(0)]
+		};
+	}
+	const projectedTools = [];
+	const diagnostics = [];
+	for (let toolIndex = 0; toolIndex < inputToolCount; toolIndex += 1) {
+		let tool;
+		try {
+			const candidate = tools[toolIndex];
+			if (!candidate) {
+				diagnostics.push(unreadableToolDiagnostic(toolIndex));
+				continue;
+			}
+			tool = candidate;
+		} catch {
+			diagnostics.push(unreadableToolDiagnostic(toolIndex));
+			continue;
+		}
+		let name;
+		try {
+			name = tool.name;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is unreadable`]
+			});
+			continue;
+		}
+		if (typeof name !== "string" || !name) {
+			diagnostics.push({
+				toolIndex,
+				violations: [`tool[${toolIndex}].name is empty`]
+			});
+			continue;
+		}
+		let parameters;
+		try {
+			parameters = tool.parameters;
+		} catch {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: [`${name}.parameters is unreadable`]
+			});
+			continue;
+		}
+		const schemaProjection = projectRuntimeToolInputSchema(parameters ?? {}, `${name}.parameters`);
+		if (!isRecord(schemaProjection.schema) || schemaProjection.violations.length > 0) {
+			diagnostics.push({
+				toolIndex,
+				toolName: name,
+				violations: schemaProjection.violations.length > 0 ? schemaProjection.violations : [`${name}.parameters must be a JSON object schema`]
+			});
+			continue;
+		}
+		let descriptionValue;
+		try {
+			descriptionValue = tool.description;
+		} catch {}
+		const description = typeof descriptionValue === "string" ? descriptionValue : void 0;
+		projectedTools.push({
+			toolIndex,
+			name,
+			...description !== void 0 ? { description } : {},
+			parameters: schemaProjection.schema
+		});
+	}
+	return {
+		inputToolCount,
+		tools: projectedTools,
+		diagnostics
+	};
+}
+function requireProjectedFunction(name, projection, choiceLabel) {
+	if (!projection.tools.some((tool) => tool.name === name)) throw new Error(`${choiceLabel} requested unavailable tool "${name}" after schema conversion`);
+}
+/** Keeps Responses tool choices aligned with surviving function schemas. */
+function reconcileOpenAIResponsesToolChoice(choice, projection) {
+	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
+	if (choice === "required") {
+		if (projection.tools.length === 0) throw new Error("OpenAI Responses tool_choice requires a tool, but no tools survived schema conversion");
+		return choice;
+	}
+	if (choice === "none" || !isRecord(choice)) return choice;
+	const choiceType = choice.type;
+	if (choiceType === "function") {
+		const functionName = choice.name;
+		if (typeof functionName !== "string") return choice;
+		requireProjectedFunction(functionName, projection, "OpenAI Responses tool_choice");
+		return {
+			type: "function",
+			name: functionName
+		};
+	}
+	if (choiceType !== "allowed_tools") return choice;
+	const mode = choice.mode;
+	const tools = choice.tools;
+	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
+	const normalizedAllowedTools = [];
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool.type !== "function") {
+			normalizedAllowedTools.push(tool);
+			continue;
+		}
+		const functionName = tool.name;
+		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
+			type: "function",
+			name: functionName
+		});
+	}
+	if (normalizedAllowedTools.length === 0) {
+		if (mode === "auto") return "none";
+		throw new Error("OpenAI Responses tool_choice requires a tool, but no allowed tools survived schema conversion");
+	}
+	return {
+		type: "allowed_tools",
+		mode,
+		tools: normalizedAllowedTools
+	};
+}
+/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
+function reconcileOpenAICompletionsToolChoice(choice, projection) {
+	if (choice === "auto") return projection.tools.length > 0 ? choice : void 0;
+	if (choice === "required") {
+		if (projection.tools.length === 0) throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no tools survived schema conversion");
+		return choice;
+	}
+	if (choice === "none" || !isRecord(choice)) return choice;
+	const choiceType = choice.type;
+	if (choiceType === "custom") throw new Error("OpenAI Chat Completions custom tool_choice is unsupported because this adapter emits function tools only");
+	if (choiceType === "function") {
+		const functionChoice = choice.function;
+		if (!isRecord(functionChoice)) return choice;
+		const functionName = functionChoice.name;
+		if (typeof functionName !== "string") return choice;
+		requireProjectedFunction(functionName, projection, "OpenAI Chat Completions tool_choice");
+		return {
+			type: "function",
+			function: { name: functionName }
+		};
+	}
+	if (choiceType !== "allowed_tools") return choice;
+	const allowedConfig = choice.allowed_tools;
+	if (!isRecord(allowedConfig)) return choice;
+	const mode = allowedConfig.mode;
+	const tools = allowedConfig.tools;
+	if (mode !== "auto" && mode !== "required" || !Array.isArray(tools)) return choice;
+	const normalizedAllowedTools = [];
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool.type !== "function") continue;
+		const functionChoice = tool.function;
+		const functionName = isRecord(functionChoice) ? functionChoice.name : void 0;
+		if (typeof functionName === "string" && projection.tools.some((projectedTool) => projectedTool.name === functionName)) normalizedAllowedTools.push({
+			type: "function",
+			function: { name: functionName }
+		});
+	}
+	if (normalizedAllowedTools.length === 0) {
+		if (mode === "auto") return "none";
+		throw new Error("OpenAI Chat Completions tool_choice requires a tool, but no allowed tools survived schema conversion");
+	}
+	return {
+		type: "allowed_tools",
+		allowed_tools: {
+			mode,
+			tools: normalizedAllowedTools
+		}
+	};
+}
+//#endregion
+export { resolveModelRequestTimeoutMs as a, resolveProviderRequestCapabilities as c, buildGuardedModelFetch as i, resolveProviderRequestPolicyConfig as l, reconcileOpenAICompletionsToolChoice as n, resolveOpenAIStrictToolSetting as o, reconcileOpenAIResponsesToolChoice as r, resolveProviderEndpoint as s, projectOpenAITools as t, transformTransportMessages as u };

package/dist/{provider-error-apVOZI6G.mjs → provider-error-CAEvRjry.mjs}

@@ -1,4 +1,4 @@
-import { D as truncateUtf16Safe } from "./shared-CdjNZd35.mjs";
+import { o as truncateUtf16Safe } from "./tool-result-text-CTpIRbYd.mjs";
 //#region packages/ai/src/utils/provider-error.ts
 const MAX_ERROR_BODY_LENGTH = 4e3;
 function stringify(value) {

package/dist/provider-options-D8bB3z9b.d.mts

@@ -0,0 +1,144 @@
+import { z as StreamOptions } from "./types-bzp5k29J.mjs";
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+import { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+
+//#region packages/ai/src/providers/openai-reasoning-effort.d.ts
+type OpenAIReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+type OpenAIApiReasoningEffort = OpenAIReasoningEffort | (string & {});
+type OpenAIReasoningModel = {
+  provider?: unknown;
+  id?: unknown;
+  name?: unknown;
+  api?: unknown;
+  baseUrl?: unknown;
+  compat?: unknown;
+};
+/** Return whether a model is the GPT-5.4 mini family. */
+declare function isOpenAIGpt54MiniModel(model: OpenAIReasoningModel): boolean;
+/** Return whether a model is the GPT-5.5 family. */
+declare function isOpenAIGpt55Model(model: OpenAIReasoningModel): boolean;
+/** Return whether a model is the GPT-5.6 family. */
+declare function isOpenAIGpt56Model(model: OpenAIReasoningModel): boolean;
+/** Normalize user-facing reasoning effort names to API effort names. */
+declare function normalizeOpenAIReasoningEffort(effort: string): string;
+/** Resolve the reasoning efforts accepted by a specific OpenAI-compatible model. */
+declare function resolveOpenAISupportedReasoningEfforts(model: OpenAIReasoningModel): readonly OpenAIApiReasoningEffort[];
+/**
+ * Return whether a model accepts the temperature parameter. The GPT-5.6
+ * family rejects it with a 400; catalog compat can override per model.
+ */
+declare function supportsOpenAITemperature(model: OpenAIReasoningModel): boolean;
+/** Return whether a model accepts a requested reasoning effort. */
+declare function supportsOpenAIReasoningEffort(model: OpenAIReasoningModel, effort: string): boolean;
+/** Resolve a requested reasoning effort to the closest value supported by the model. */
+declare function resolveOpenAIReasoningEffortForModel(params: {
+  model: OpenAIReasoningModel;
+  effort: string;
+  fallbackMap?: Record<string, string>;
+}): OpenAIApiReasoningEffort | undefined;
+//#endregion
+//#region packages/ai/src/providers/openai-tool-projection.d.ts
+type OpenAIToolDescriptor = {
+  readonly name?: unknown;
+  readonly description?: unknown;
+  readonly parameters: unknown;
+};
+type OpenAIProjectedTool = {
+  readonly toolIndex: number;
+  readonly name: string;
+  readonly description?: string;
+  readonly parameters: Record<string, unknown>;
+};
+type OpenAIToolProjectionDiagnostic = {
+  readonly toolIndex: number;
+  readonly toolName?: string;
+  readonly violations: readonly string[];
+};
+type OpenAIToolProjection = {
+  readonly inputToolCount: number;
+  readonly tools: readonly OpenAIProjectedTool[];
+  readonly diagnostics: readonly OpenAIToolProjectionDiagnostic[];
+};
+type OpenAIResponsesToolChoice = ResponseCreateParamsStreaming["tool_choice"];
+type OpenAICompletionsSdkToolChoice = OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming["tool_choice"];
+type OpenAICompletionsToolChoice = Exclude<OpenAICompletionsSdkToolChoice, {
+  type: "custom";
+}>;
+/** Snapshots direct/custom tool descriptors before OpenAI payload construction. */
+declare function projectOpenAITools(tools: readonly OpenAIToolDescriptor[]): OpenAIToolProjection;
+/** Keeps Responses tool choices aligned with surviving function schemas. */
+declare function reconcileOpenAIResponsesToolChoice(choice: OpenAIResponsesToolChoice, projection: OpenAIToolProjection): OpenAIResponsesToolChoice | undefined;
+/** Keeps Chat Completions tool choices aligned with surviving function schemas. */
+declare function reconcileOpenAICompletionsToolChoice(choice: OpenAICompletionsSdkToolChoice, projection: OpenAIToolProjection): OpenAICompletionsSdkToolChoice | undefined;
+//#endregion
+//#region packages/ai/src/provider-options.d.ts
+type AnthropicEffort = "low" | "medium" | "high" | "xhigh" | "max";
+type AnthropicThinkingDisplay = "summarized" | "omitted";
+/** Provider options shared by the Anthropic provider and canonical transport. */
+interface AnthropicOptions extends StreamOptions {
+  /**
+   * Enable extended thinking.
+   * For Opus 4.6+ and Sonnet 4.6: uses adaptive thinking (model decides when/how much to think).
+   * For older models: uses budget-based thinking with thinkingBudgetTokens.
+   */
+  thinkingEnabled?: boolean;
+  /**
+   * Token budget for extended thinking (older models only).
+   * Ignored for Opus 4.6+ and Sonnet 4.6, which use adaptive thinking.
+   */
+  thinkingBudgetTokens?: number;
+  /**
+   * Effort level for adaptive thinking (Opus 4.6+ and Sonnet 4.6).
+   * Controls how much thinking Claude allocates:
+   * - "max": Always thinks with no constraints (Opus 4.6 only)
+   * - "xhigh": Highest reasoning level (Opus 4.7+)
+   * - "high": Always thinks, deep reasoning (default)
+   * - "medium": Moderate thinking, may skip for simple queries
+   * - "low": Minimal thinking, skips for simple tasks
+   * Ignored for older models.
+   */
+  effort?: AnthropicEffort;
+  /**
+   * Controls how thinking content is returned in API responses.
+   * - "summarized": Thinking blocks contain summarized thinking text (default here).
+   * - "omitted": Thinking blocks return an empty thinking field; the encrypted
+   *   signature still travels back for multi-turn continuity. Use for faster
+   *   time-to-first-text-token when your UI does not surface thinking.
+   *
+   * Note: Anthropic's API default for Claude Opus 4.7+ and Claude Mythos Preview
+   * is "omitted". We default to "summarized" here to keep behavior consistent
+   * with older Claude 4 models. Set this explicitly to "omitted" to opt in.
+   */
+  thinkingDisplay?: AnthropicThinkingDisplay;
+  interleavedThinking?: boolean;
+  toolChoice?: "auto" | "any" | "none" | {
+    type: "tool";
+    name: string;
+  };
+  /**
+   * Pre-built Anthropic client instance. When provided, skips internal client
+   * construction entirely. Use this to inject alternative SDK clients such as
+   * `AnthropicVertex` that shares the same messaging API.
+   */
+  client?: Anthropic;
+}
+/** Options shared by the OpenAI Responses and Completions transports. */
+type BaseOpenAIStreamOptions = StreamOptions & {
+  topP?: number;
+  authProfileId?: string;
+  firstEventTimeoutMs?: number;
+  onFirstEventTimeout?: (reason: Error) => void;
+  openclawCodeModeToolSurface?: boolean;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
+  seed?: number;
+};
+/** Superset retained under the provider's published compatibility type name. */
+type OpenAICompletionsOptions = BaseOpenAIStreamOptions & {
+  toolChoice?: OpenAICompletionsToolChoice;
+  reasoning?: OpenAIReasoningEffort;
+  reasoningEffort?: OpenAIReasoningEffort;
+};
+//#endregion
+export { resolveOpenAIReasoningEffortForModel as _, OpenAICompletionsOptions as a, supportsOpenAITemperature as b, projectOpenAITools as c, OpenAIApiReasoningEffort as d, OpenAIReasoningEffort as f, normalizeOpenAIReasoningEffort as g, isOpenAIGpt56Model as h, BaseOpenAIStreamOptions as i, reconcileOpenAICompletionsToolChoice as l, isOpenAIGpt55Model as m, AnthropicOptions as n, OpenAICompletionsToolChoice as o, isOpenAIGpt54MiniModel as p, AnthropicThinkingDisplay as r, OpenAIToolProjection as s, AnthropicEffort as t, reconcileOpenAIResponsesToolChoice as u, resolveOpenAISupportedReasoningEfforts as v, supportsOpenAIReasoningEffort as y };

package/dist/providers.mjs

@@ -64,35 +64,35 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-CQVj3le6.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-CH4UUnZr.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-CiSutyu0.mjs").then((n) => n.n), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-DsOxhOD1.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-CKV-TOQj.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-CWmpvWYh.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-D3PD6PE-.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-BT7A3sLu.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-DIYgsqFM.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-CImcwB83.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-CedIj0hk.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-B84Ibtrd.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-f-A8xrae.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-CtSg0iTS.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-D3yMVXIY.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-31f1uS9L.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))

package/dist/{stream-first-event-timeout-C3OgBjIk.mjs → reasoning-tag-text-partitioner-CGDyLWUR.mjs}

@@ -1,5 +1,4 @@
 import { r as __exportAll } from "./env-api-keys-DrgeBuva.mjs";
-import { n as clampTimerTimeoutMs } from "./number-coercion-DvG7SNMg.mjs";
 //#region node_modules/mdast-util-to-string/lib/index.js
 /**
 * @typedef {import('mdast').Nodes} Nodes
@@ -12207,88 +12206,4 @@ function createReasoningTagTextPartitioner() {
 	};
 }
 //#endregion
-//#region packages/ai/src/utils/stream-first-event-timeout.ts
-function getFirstStreamEventTimeoutMs(options) {
-	return options?.firstEventTimeoutMs;
-}
-function getFirstStreamEventTimeoutHandler(options) {
-	return options?.onFirstEventTimeout;
-}
-function formatOptionalField(name, value) {
-	return value ? ` ${name}=${value}` : "";
-}
-function createFirstStreamEventTimeoutError(context) {
-	const stage = context.stage ? `${context.stage} ` : "";
-	const details = [
-		formatOptionalField("provider", context.provider),
-		formatOptionalField("api", context.api),
-		formatOptionalField("model", context.model)
-	].join("");
-	return /* @__PURE__ */ new Error(`${stage}HTTP stream opened but did not deliver a first SSE event within ${context.timeoutMs}ms after streaming headers (first-event timeout).${details}` + (context.hint ? ` ${context.hint}` : ""));
-}
-function createFirstStreamEventAbortController(parentSignal) {
-	const controller = new AbortController();
-	const abortFromParent = () => {
-		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
-	};
-	if (parentSignal?.aborted) abortFromParent();
-	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
-	return {
-		signal: controller.signal,
-		abort(reason) {
-			if (!controller.signal.aborted) controller.abort(reason);
-		},
-		dispose() {
-			parentSignal?.removeEventListener("abort", abortFromParent);
-		}
-	};
-}
-function withFirstStreamEventTimeout(stream, context) {
-	const timeoutMs = clampTimerTimeoutMs(context.timeoutMs);
-	if (timeoutMs === void 0 || context.timeoutMs <= 0) return stream;
-	const timeoutContext = {
-		...context,
-		timeoutMs
-	};
-	return { async *[Symbol.asyncIterator]() {
-		const iterator = stream[Symbol.asyncIterator]();
-		let timer;
-		let completed = false;
-		const clear = () => {
-			if (timer) {
-				clearTimeout(timer);
-				timer = void 0;
-			}
-		};
-		try {
-			const first = await new Promise((resolve, reject) => {
-				timer = setTimeout(() => {
-					const timeoutError = createFirstStreamEventTimeoutError(timeoutContext);
-					timeoutContext.onTimeout?.(timeoutError);
-					timeoutContext.abort?.(timeoutError);
-					reject(timeoutError);
-				}, timeoutMs);
-				timer.unref?.();
-				iterator.next().then(resolve, reject);
-			}).finally(clear);
-			if (first.done) {
-				completed = true;
-				return;
-			}
-			yield first.value;
-			for (;;) {
-				const next = await iterator.next();
-				if (next.done) {
-					completed = true;
-					return;
-				}
-				yield next.value;
-			}
-		} finally {
-			clear();
-			if (!completed) iterator.return?.().catch(() => void 0);
-		}
-	} };
-}
-//#endregion
-export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, createReasoningTagTextPartitioner as o, getFirstStreamEventTimeoutHandler as r, createFirstStreamEventAbortController as t };
+export { createReasoningTagTextPartitioner as t };

package/dist/simple-options-9lhRrN73.mjs

@@ -0,0 +1,50 @@
+//#region packages/ai/src/providers/simple-options.ts
+function buildBaseOptions(model, options, apiKey) {
+	const firstEventOptions = options;
+	return {
+		temperature: options?.temperature,
+		maxTokens: options?.maxTokens,
+		stop: options?.stop,
+		signal: options?.signal,
+		apiKey: apiKey || options?.apiKey,
+		transport: options?.transport,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		promptCacheKey: options?.promptCacheKey,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
+		timeoutMs: options?.timeoutMs,
+		firstEventTimeoutMs: firstEventOptions?.firstEventTimeoutMs,
+		onFirstEventTimeout: firstEventOptions?.onFirstEventTimeout,
+		maxRetries: options?.maxRetries,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata
+	};
+}
+function clampMaxTokensToModel(model, requestedMaxTokens) {
+	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens));
+}
+function clampReasoning(effort) {
+	return effort === "xhigh" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		max: 32768,
+		...customBudgets
+	};
+	const minOutputTokens = 1024;
+	let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
+	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+//#endregion
+export { clampReasoning as i, buildBaseOptions as n, clampMaxTokensToModel as r, adjustMaxTokensForThinking as t };

package/dist/stream-first-event-timeout-BBys9hSb.mjs

@@ -0,0 +1,86 @@
+import { n as clampTimerTimeoutMs } from "./number-coercion-DvG7SNMg.mjs";
+//#region packages/ai/src/utils/stream-first-event-timeout.ts
+function getFirstStreamEventTimeoutMs(options) {
+	return options?.firstEventTimeoutMs;
+}
+function getFirstStreamEventTimeoutHandler(options) {
+	return options?.onFirstEventTimeout;
+}
+function formatOptionalField(name, value) {
+	return value ? ` ${name}=${value}` : "";
+}
+function createFirstStreamEventTimeoutError(context) {
+	const stage = context.stage ? `${context.stage} ` : "";
+	const details = [
+		formatOptionalField("provider", context.provider),
+		formatOptionalField("api", context.api),
+		formatOptionalField("model", context.model)
+	].join("");
+	return /* @__PURE__ */ new Error(`${stage}HTTP stream opened but did not deliver a first SSE event within ${context.timeoutMs}ms after streaming headers (first-event timeout).${details}` + (context.hint ? ` ${context.hint}` : ""));
+}
+function createFirstStreamEventAbortController(parentSignal) {
+	const controller = new AbortController();
+	const abortFromParent = () => {
+		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
+	};
+	if (parentSignal?.aborted) abortFromParent();
+	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+	return {
+		signal: controller.signal,
+		abort(reason) {
+			if (!controller.signal.aborted) controller.abort(reason);
+		},
+		dispose() {
+			parentSignal?.removeEventListener("abort", abortFromParent);
+		}
+	};
+}
+function withFirstStreamEventTimeout(stream, context) {
+	const timeoutMs = clampTimerTimeoutMs(context.timeoutMs);
+	if (timeoutMs === void 0 || context.timeoutMs <= 0) return stream;
+	const timeoutContext = {
+		...context,
+		timeoutMs
+	};
+	return { async *[Symbol.asyncIterator]() {
+		const iterator = stream[Symbol.asyncIterator]();
+		let timer;
+		let completed = false;
+		const clear = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+		};
+		try {
+			const first = await new Promise((resolve, reject) => {
+				timer = setTimeout(() => {
+					const timeoutError = createFirstStreamEventTimeoutError(timeoutContext);
+					timeoutContext.onTimeout?.(timeoutError);
+					timeoutContext.abort?.(timeoutError);
+					reject(timeoutError);
+				}, timeoutMs);
+				timer.unref?.();
+				iterator.next().then(resolve, reject);
+			}).finally(clear);
+			if (first.done) {
+				completed = true;
+				return;
+			}
+			yield first.value;
+			for (;;) {
+				const next = await iterator.next();
+				if (next.done) {
+					completed = true;
+					return;
+				}
+				yield next.value;
+			}
+		} finally {
+			clear();
+			if (!completed) iterator.return?.().catch(() => void 0);
+		}
+	} };
+}
+//#endregion
+export { withFirstStreamEventTimeout as a, getFirstStreamEventTimeoutMs as i, createFirstStreamEventTimeoutError as n, getFirstStreamEventTimeoutHandler as r, createFirstStreamEventAbortController as t };