@warlock.js/ai-openai 5.30.0 → 5.31.0

package/cjs/index.cjs

@@ -31,6 +31,121 @@ openai = __toESM(openai, 1);
 let _warlock_js_ai = require("@warlock.js/ai");
 let _warlock_js_logger = require("@warlock.js/logger");
 
+//#region ../../packages/ai-openai/src/known-pricing.ts
+/**
+* Built-in OpenAI API list prices, USD per 1,000,000 tokens, keyed by
+* exact model id. `cachedInput` is the cached-input rate. None of these
+* models charges for cache writes.
+*
+* Source: https://developers.openai.com/api/docs/pricing (the target of
+* platform.openai.com/docs/pricing), Standard tier, fetched 2026-10-17.
+*
+* Applied only when the SDK's provider label is `"openai"`, and only on
+* an exact id match — dated snapshots can carry other prices. Left out on
+* purpose, so pass `pricing` yourself for them:
+*
+* - Models priced by prompt length (a higher rate above 272K input
+*   tokens): the gpt-6 / gpt-5.6 / gpt-5.5 / gpt-5.4 families and the
+*   `-pro` models. A flat `ModelPricing` cannot express the tiers.
+* - Promotional, Batch, Flex and Priority pricing, and the regional
+*   (data-residency) uplift.
+*/
+const OPENAI_MODEL_PRICING = {
+	"gpt-5.4-mini": {
+		input: .75,
+		output: 4.5,
+		cachedInput: .075
+	},
+	"gpt-5.4-nano": {
+		input: .2,
+		output: 1.25,
+		cachedInput: .02
+	},
+	"gpt-5.2": {
+		input: 1.75,
+		output: 14,
+		cachedInput: .175
+	},
+	"gpt-5.1": {
+		input: 1.25,
+		output: 10,
+		cachedInput: .125
+	},
+	"gpt-5": {
+		input: 1.25,
+		output: 10,
+		cachedInput: .125
+	},
+	"gpt-5-mini": {
+		input: .25,
+		output: 2,
+		cachedInput: .025
+	},
+	"gpt-5-nano": {
+		input: .05,
+		output: .4,
+		cachedInput: .005
+	},
+	"gpt-4.1": {
+		input: 2,
+		output: 8,
+		cachedInput: .5
+	},
+	"gpt-4.1-mini": {
+		input: .4,
+		output: 1.6,
+		cachedInput: .1
+	},
+	"gpt-4.1-nano": {
+		input: .1,
+		output: .4,
+		cachedInput: .025
+	},
+	"gpt-4o": {
+		input: 2.5,
+		output: 10,
+		cachedInput: 1.25
+	},
+	"gpt-4o-mini": {
+		input: .15,
+		output: .6,
+		cachedInput: .075
+	},
+	o3: {
+		input: 2,
+		output: 8,
+		cachedInput: .5
+	},
+	"o4-mini": {
+		input: 1.1,
+		output: 4.4,
+		cachedInput: .275
+	},
+	"o3-mini": {
+		input: 1.1,
+		output: 4.4,
+		cachedInput: .55
+	},
+	o1: {
+		input: 15,
+		output: 60,
+		cachedInput: 7.5
+	}
+};
+/**
+* Look up the built-in list price for an OpenAI model id (exact match).
+* Returns `undefined` for unknown ids, so cost stays unknown rather than
+* wrong.
+*
+* @example
+* openAIPricingFor("gpt-4o-mini"); // { input: 0.15, output: 0.6, cachedInput: 0.075 }
+* openAIPricingFor("gpt-5.5"); // undefined — priced by prompt length
+*/
+function openAIPricingFor(modelName) {
+	return OPENAI_MODEL_PRICING[modelName];
+}
+
+//#endregion
 //#region ../../packages/ai-openai/src/utils/build-usage.ts
 /**
 * Build the neutral `Usage` from extracted counts. The optional detail
@@ -38,17 +153,27 @@ let _warlock_js_logger = require("@warlock.js/logger");
 * non-reasoning / uncached calls keep the lean `{ input, output, total }`
 * shape. Shared by the Chat Completions and Responses adapters so both
 * apply the same rule.
+*
+* OpenAI-style usage counts cache reads and writes inside the prompt
+* total (`input_tokens` includes `cached_tokens` and `cache_write_tokens`,
+* and the compatible vendors — DeepSeek, xAI, Groq, Mistral — document
+* the same), so the result is marked `inputIncludesCache: true`. When the
+* model is priced, `cost` is attached.
 */
-function buildUsage(counts) {
+function buildUsage(counts, pricing) {
 	const { input, output, total, cachedTokens, reasoningTokens, cacheWriteTokens } = counts;
-	return {
+	const usage = {
 		input,
 		output,
 		total,
+		inputIncludesCache: true,
 		...cachedTokens !== void 0 && cachedTokens > 0 ? { cachedTokens } : {},
 		...reasoningTokens !== void 0 && reasoningTokens > 0 ? { reasoningTokens } : {},
 		...cacheWriteTokens !== void 0 && cacheWriteTokens > 0 ? { cacheWriteTokens } : {}
 	};
+	const cost = (0, _warlock_js_ai.computeCost)(usage, pricing);
+	if (cost) usage.cost = cost;
+	return usage;
 }
 
 //#endregion
@@ -109,6 +234,11 @@ function wrapOpenAIError(thrown) {
 		cause: thrown,
 		context
 	});
+	if (shape.code === "server_is_overloaded" || shape.status === 503) return new _warlock_js_ai.ProviderOverloadedError(message, {
+		cause: thrown,
+		context,
+		retryAfter: parseRetryAfter(shape.headers)
+	});
 	return new _warlock_js_ai.ProviderError(message, {
 		cause: thrown,
 		context
@@ -271,15 +401,34 @@ function mapFinishReason(raw) {
 //#endregion
 //#region ../../packages/ai-openai/src/utils/prompt-cache-params.ts
 /**
-* Build the OpenAI-only prompt-cache request fields from the model config.
-* Returns nothing for any provider label other than `"openai"`: wrapper
-* endpoints use the same transport but may reject these OpenAI-only fields.
+* Provider labels whose OpenAI-compatible endpoint documents a
+* `prompt_cache_key` request field:
+*
+* - `openai` — https://developers.openai.com/api/docs/guides/prompt-caching
+* - `xai` — Chat Completions accepts `prompt_cache_key` ("plumbed to
+*   x-grok-conv-id"), https://docs.x.ai/openapi.json and
+*   https://docs.x.ai/developers/advanced-api-usage/prompt-caching/maximizing-cache-hits
+* - `mistral` — https://docs.mistral.ai/studio/conversations/advanced/prompt-caching
+*
+* Groq and DeepSeek cache automatically and document no request hint, so
+* they receive nothing (checked 2026-10-17).
+*/
+const PROMPT_CACHE_KEY_PROVIDERS = new Set([
+	"openai",
+	"xai",
+	"mistral"
+]);
+/**
+* Build the prompt-cache request fields from the model config.
+* `prompt_cache_key` is sent for the providers that document it
+* ({@link PROMPT_CACHE_KEY_PROVIDERS}); `prompt_cache_retention` is
+* OpenAI-only. Any other provider label — including a custom label on a
+* wrapper SDK — gets neither, since an unknown endpoint may reject them.
 */
 function buildPromptCacheParams(provider, config) {
-	if (provider !== "openai") return {};
 	return {
-		...config.promptCacheKey !== void 0 ? { prompt_cache_key: config.promptCacheKey } : {},
-		...config.promptCacheRetention !== void 0 ? { prompt_cache_retention: config.promptCacheRetention } : {}
+		...PROMPT_CACHE_KEY_PROVIDERS.has(provider) && config.promptCacheKey !== void 0 ? { prompt_cache_key: config.promptCacheKey } : {},
+		...provider === "openai" && config.promptCacheRetention !== void 0 ? { prompt_cache_retention: config.promptCacheRetention } : {}
 	};
 }
 
@@ -415,6 +564,28 @@ const RESPONSES_METADATA_KEY = "openaiResponses";
 function pickReplayableReasoning(items) {
 	return items.filter((item) => typeof item.encrypted_content === "string" && item.encrypted_content !== "");
 }
+/** Output item types that may follow a replayed reasoning item. */
+const REPLAY_SAFE_FOLLOWERS = new Set(["function_call", "message"]);
+/**
+* The reasoning items of a turn that are safe to replay, in order.
+*
+* The API pairs a reasoning item with the output item that followed it and
+* rejects a replayed reasoning item whose follower is missing. Only
+* `function_call` items are replayed, so a reasoning item that led into a
+* hosted (server-run) tool call — `web_search_call`, `file_search_call`,
+* `code_interpreter_call`, … from a provider-defined tool — is dropped
+* rather than sent without its follower. Encrypted reasoning only improves
+* continuity; dropping it never breaks the request.
+*/
+function pickTurnReasoning(output) {
+	const picked = [];
+	output.forEach((item, index) => {
+		if (item.type !== "reasoning") return;
+		const follower = output.slice(index + 1).find((next) => next.type !== "reasoning");
+		if (follower === void 0 || REPLAY_SAFE_FOLLOWERS.has(follower.type)) picked.push(item);
+	});
+	return picked;
+}
 /**
 * Attach the turn's reasoning items to the FIRST tool call only (parallel
 * calls do not each repeat the blobs). Returns the calls unchanged when
@@ -1065,6 +1236,51 @@ var OpenAIImageModel = class {
 	}
 };
 
+//#endregion
+//#region ../../packages/ai-openai/src/provider-options.ts
+const RESERVED_FIELDS = new Set([
+	"model",
+	"messages",
+	"input",
+	"instructions",
+	"tools",
+	"stream",
+	"stream_options",
+	"previous_response_id",
+	"conversation",
+	"store",
+	"include",
+	"functions",
+	"function_call",
+	"prompt",
+	"background"
+]);
+function mergeProviderBody(built, options) {
+	const body = (options?.providerOptions?.openai)?.body ?? {};
+	const reserved = Object.keys(body).filter((key) => RESERVED_FIELDS.has(key));
+	if (reserved.length > 0) throw new _warlock_js_ai.InvalidRequestError(`providerOptions.openai.body cannot set ${reserved.join(", ")}: use the call's messages, tools and model options.`, { context: { fields: reserved } });
+	const defaults = built;
+	const overrides = Object.fromEntries(Object.entries(body).map(([key, value]) => {
+		const previous = defaults[key];
+		if (!isPlainObject(previous) || !isPlainObject(value)) return [key, value];
+		if (typeof previous.type === "string" && typeof value.type === "string" && previous.type !== value.type) return [key, value];
+		return [key, {
+			...previous,
+			...value
+		}];
+	}));
+	return {
+		...built,
+		...overrides
+	};
+}
+/** Merge only plain objects; arrays, null and provider scalar values replace the field. */
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
 //#endregion
 //#region ../../packages/ai-openai/src/known-reasoning-models.ts
 /**
@@ -1227,15 +1443,15 @@ var OpenAIModel = class {
 		});
 		let response;
 		try {
-			response = await this.client.chat.completions.create({
+			response = await this.client.chat.completions.create(mergeProviderBody({
 				model: this.name,
 				messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),
 				...this.buildSamplingParams(options),
 				...buildPromptCacheParams(this.provider, this.config),
-				tools: toOpenAITools(options?.tools),
+				...this.buildTools(options),
 				...this.buildResponseFormat(options?.responseSchema),
 				...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length))
-			}, options?.signal ? { signal: options.signal } : void 0);
+			}, options), options?.signal ? { signal: options.signal } : void 0);
 		} catch (thrown) {
 			const wrapped = wrapOpenAIError(thrown);
 			this.logger.error(LOG_MODULE$3, "error", wrapped.message, {
@@ -1268,6 +1484,11 @@ var OpenAIModel = class {
 	* `delta` for text tokens, `tool-call` when the model requests a tool,
 	* and a terminal `done` carrying the final finish reason + usage totals.
 	* Callers consume it with `for await`.
+	*
+	* With `options.streamChunks` it also yields `tool-args` for each
+	* `tool_calls[].function.arguments` fragment and `reasoning` for a
+	* vendor's `reasoning_content` / `reasoning` delta field. Usage arrives
+	* only on the final chunk here, so no `usage` chunk is emitted.
 	*/
 	async *stream(messages, options) {
 		this.logger.debug(LOG_MODULE$3, "request", "Starting streaming call to chat.completions", {
@@ -1278,17 +1499,17 @@ var OpenAIModel = class {
 		});
 		let stream;
 		try {
-			stream = await this.client.chat.completions.create({
+			stream = await this.client.chat.completions.create(mergeProviderBody({
 				model: this.name,
 				messages: toOpenAIMessages(messages, this.promptCacheBreakpoints(options)),
 				...this.buildSamplingParams(options),
 				...buildPromptCacheParams(this.provider, this.config),
-				tools: toOpenAITools(options?.tools),
+				...this.buildTools(options),
 				stream: true,
 				stream_options: { include_usage: true },
 				...this.buildResponseFormat(options?.responseSchema),
 				...this.buildReasoningParams(options?.reasoning, Boolean(options?.tools?.length))
-			}, options?.signal ? { signal: options.signal } : void 0);
+			}, options), options?.signal ? { signal: options.signal } : void 0);
 		} catch (thrown) {
 			const wrapped = wrapOpenAIError(thrown);
 			this.logger.error(LOG_MODULE$3, "error", wrapped.message, {
@@ -1298,16 +1519,24 @@ var OpenAIModel = class {
 			throw wrapped;
 		}
 		let rawFinishReason = "stop";
-		const usage = {
+		let usage = {
 			input: 0,
 			output: 0,
 			total: 0
 		};
+		const want = (0, _warlock_js_ai.resolveStreamChunks)(options);
 		const toolCallAccum = /* @__PURE__ */ new Map();
 		try {
 			for await (const chunk of stream) {
 				const delta = chunk.choices[0]?.delta;
 				const finish = chunk.choices[0]?.finish_reason;
+				if (want.reasoning && delta) {
+					const reasoning = readReasoningDelta(delta);
+					if (reasoning) yield {
+						type: "reasoning",
+						delta: reasoning
+					};
+				}
 				if (delta?.content) yield {
 					type: "delta",
 					content: delta.content
@@ -1317,23 +1546,25 @@ var OpenAIModel = class {
 					if (!toolCallAccum.has(idx)) toolCallAccum.set(idx, {
 						id: "",
 						name: "",
-						arguments: ""
+						arguments: "",
+						streamed: 0
 					});
 					const acc = toolCallAccum.get(idx);
 					if (toolCall.id) acc.id = toolCall.id;
 					if (toolCall.function?.name) acc.name = toolCall.function.name;
 					if (toolCall.function?.arguments) acc.arguments += toolCall.function.arguments;
+					if (want.toolArgs && acc.name && acc.arguments.length > acc.streamed) {
+						yield {
+							type: "tool-args",
+							callId: acc.id,
+							name: acc.name,
+							delta: acc.arguments.slice(acc.streamed)
+						};
+						acc.streamed = acc.arguments.length;
+					}
 				}
 				if (finish) rawFinishReason = finish;
-				if (chunk.usage) {
-					usage.input = chunk.usage.prompt_tokens ?? 0;
-					usage.output = chunk.usage.completion_tokens ?? 0;
-					usage.total = chunk.usage.total_tokens ?? 0;
-					const cached = chunk.usage.prompt_tokens_details?.cached_tokens;
-					if (cached !== void 0 && cached > 0) usage.cachedTokens = cached;
-					const reasoning = chunk.usage.completion_tokens_details?.reasoning_tokens;
-					if (reasoning !== void 0 && reasoning > 0) usage.reasoningTokens = reasoning;
-				}
+				if (chunk.usage) usage = this.extractUsage(chunk.usage);
 			}
 			for (const acc of toolCallAccum.values()) {
 				if (!acc.name) continue;
@@ -1363,6 +1594,25 @@ var OpenAIModel = class {
 			usage
 		};
 	}
+	/**
+	* Spread-friendly `tools` fragment: the function tools, then the
+	* provider-defined entries whose `provider` equals this model's
+	* provider label (`"openai"`, or the vendor label an OpenAI-compatible
+	* wrapper sets, e.g. `"groq"`), sent verbatim. Chat Completions only
+	* accepts `function` and `custom` tool types from OpenAI itself; its
+	* hosted tools (`web_search`, `file_search`, …) need `api: "responses"`
+	* and OpenAI rejects them here with a 400.
+	*/
+	buildTools(options) {
+		const { tools, definitions } = (0, _warlock_js_ai.selectProviderTools)(options, {
+			accepts: [this.provider],
+			module: LOG_MODULE$3,
+			model: this.name,
+			logger: this.logger
+		});
+		const mapped = [...toOpenAITools(tools) ?? [], ...definitions];
+		return mapped.length > 0 ? { tools: mapped } : {};
+	}
 	/** Map the neutral cache hint only for the direct OpenAI provider. */
 	promptCacheBreakpoints(options) {
 		return this.provider === "openai" ? options?.cacheControl?.breakpoints ?? 0 : 0;
@@ -1401,7 +1651,9 @@ var OpenAIModel = class {
 	* (the hidden reasoning channel on o-series / gpt-5 models, already
 	* counted within `output`). Both are emitted only when the provider
 	* reports a positive value, so non-reasoning / uncached calls keep the
-	* lean `{ input, output, total }` shape.
+	* lean `{ input, output, total }` shape. `cacheWriteTokens` mirrors
+	* `prompt_tokens_details.cache_write_tokens` (billed writes on the
+	* models that charge for them). `cost` is attached when priced.
 	*/
 	extractUsage(raw) {
 		if (!raw) return {
@@ -1410,12 +1662,13 @@ var OpenAIModel = class {
 			total: 0
 		};
 		return buildUsage({
-			input: raw.prompt_tokens,
-			output: raw.completion_tokens,
-			total: raw.total_tokens,
+			input: raw.prompt_tokens ?? 0,
+			output: raw.completion_tokens ?? 0,
+			total: raw.total_tokens ?? 0,
 			cachedTokens: raw.prompt_tokens_details?.cached_tokens,
+			cacheWriteTokens: raw.prompt_tokens_details?.cache_write_tokens,
 			reasoningTokens: raw.completion_tokens_details?.reasoning_tokens
-		});
+		}, this.pricing);
 	}
 	/**
 	* Translate the neutral `ModelCallOptions.reasoning` hint into OpenAI's
@@ -1491,11 +1744,38 @@ var OpenAIModel = class {
 		}));
 	}
 };
+/**
+* Reasoning text an OpenAI-compatible vendor puts on a Chat Completions
+* stream delta. OpenAI itself streams none on this API. DeepSeek documents
+* `delta.reasoning_content` (API reference, chat completion chunk); Groq
+* documents the parsed reasoning under a `reasoning` field. Neither is in
+* the OpenAI SDK's delta type, so the delta is read as a plain record.
+*/
+function readReasoningDelta(delta) {
+	const record = delta;
+	for (const key of ["reasoning_content", "reasoning"]) {
+		const value = record[key];
+		if (typeof value === "string" && value !== "") return value;
+	}
+}
 
 //#endregion
 //#region ../../packages/ai-openai/src/responses-model.ts
 const LOG_MODULE$2 = "ai.openai";
 /**
+* Responses output item types of built-in tools the CALLER must execute
+* (installed SDK `ResponseOutputItem` union). The adapter maps only
+* `function_call` to a neutral tool call, so these fail closed.
+*/
+const CLIENT_RUN_ITEM_TYPES = new Set([
+	"computer_call",
+	"custom_tool_call",
+	"local_shell_call",
+	"shell_call",
+	"apply_patch_call",
+	"mcp_approval_request"
+]);
+/**
 * OpenAI Responses API implementation of `ModelContract` (`api: "responses"`).
 *
 * **Role.** A sibling of `OpenAIModel` that speaks `POST /v1/responses`
@@ -1522,7 +1802,16 @@ const LOG_MODULE$2 = "ai.openai";
 *
 * **Streaming.** `stream()` uses `responses.create({ stream: true })` and yields
 * the same chunk sequence as the Chat path: text `delta`s, then the
-* `tool-call`s, then one `done`.
+* `tool-call`s, then one `done`. With `streamChunks` it also yields
+* `reasoning` (reasoning summary / reasoning text deltas) and `tool-args`
+* (`response.function_call_arguments.delta`).
+*
+* **Provider-defined tools.** `ai.providerTool({ provider: "openai" })`
+* definitions are appended to `tools` verbatim. Hosted tools run inside the
+* response; their output items (`web_search_call`, …) are not replayed
+* (with `store: false` the next turn only needs the answer text), and a
+* reasoning item that led into one is not replayed either (see
+* `pickTurnReasoning`).
 */
 var OpenAIResponsesModel = class {
 	constructor(client, config, provider = "openai") {
@@ -1585,6 +1874,26 @@ var OpenAIResponsesModel = class {
 			...toolCalls ? { toolCalls } : {}
 		};
 	}
+	/** Count native Responses input tokens using the same converted input and tools. */
+	async countTokens(messages, options) {
+		const request = this.buildRequest(messages, options);
+		const body = {
+			model: request.model,
+			input: request.input,
+			instructions: request.instructions,
+			tools: request.tools,
+			tool_choice: request.tool_choice,
+			reasoning: request.reasoning,
+			text: request.text,
+			parallel_tool_calls: request.parallel_tool_calls,
+			truncation: request.truncation ?? void 0
+		};
+		try {
+			return (await this.client.responses.inputTokens.count(body, options?.signal ? { signal: options.signal } : void 0)).input_tokens;
+		} catch (thrown) {
+			throw this.logAndWrap(thrown);
+		}
+	}
 	/**
 	* Incremental streaming completion via `responses.create({ stream: true })`
 	* (the SDK's `Stream<ResponseStreamEvent>`, `responses.d.ts:55`). Yields the
@@ -1619,7 +1928,9 @@ var OpenAIResponsesModel = class {
 			throw this.logAndWrap(thrown);
 		}
 		const toolCalls = [];
-		const reasoningItems = [];
+		const outputItems = [];
+		const want = (0, _warlock_js_ai.resolveStreamChunks)(options);
+		const streamingCalls = /* @__PURE__ */ new Map();
 		let terminal;
 		try {
 			for await (const event of events) {
@@ -1630,10 +1941,36 @@ var OpenAIResponsesModel = class {
 					};
 					continue;
 				}
+				if (event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_text.delta") {
+					if (want.reasoning && event.delta) yield {
+						type: "reasoning",
+						delta: event.delta
+					};
+					continue;
+				}
+				if (event.type === "response.output_item.added") {
+					const { item } = event;
+					if (item.type === "function_call" && item.id) streamingCalls.set(item.id, {
+						callId: item.call_id,
+						name: item.name
+					});
+					continue;
+				}
+				if (event.type === "response.function_call_arguments.delta") {
+					const call = streamingCalls.get(event.item_id);
+					if (want.toolArgs && call && event.delta) yield {
+						type: "tool-args",
+						callId: call.callId,
+						name: call.name,
+						delta: event.delta
+					};
+					continue;
+				}
 				if (event.type === "response.output_item.done") {
 					const { item } = event;
-					if (item.type === "reasoning") reasoningItems.push(item);
-					else if (item.type === "function_call" && item.status !== "incomplete") toolCalls.push(this.toToolCall(item));
+					this.assertServerRunItem(item);
+					outputItems.push(item);
+					if (item.type === "function_call" && item.status !== "incomplete") toolCalls.push(this.toToolCall(item));
 					continue;
 				}
 				if (event.type === "response.completed" || event.type === "response.incomplete") {
@@ -1654,7 +1991,7 @@ var OpenAIResponsesModel = class {
 		} catch (thrown) {
 			throw this.logAndWrap(thrown);
 		}
-		for (const call of attachReasoningReplay(toolCalls, this.name, reasoningItems)) yield {
+		for (const call of attachReasoningReplay(toolCalls, this.name, pickTurnReasoning(outputItems))) yield {
 			type: "tool-call",
 			id: call.id,
 			name: call.name,
@@ -1692,11 +2029,11 @@ var OpenAIResponsesModel = class {
 	*/
 	buildRequest(messages, options) {
 		const { instructions, input } = toResponsesInput(messages, this.name);
-		const tools = toResponsesTools(options?.tools);
+		const tools = this.buildTools(options);
 		const toolChoice = tools ? toResponsesToolChoice(options?.toolChoice) : void 0;
 		const maxTokens = options?.maxTokens ?? this.config.maxTokens;
 		const temperature = options?.temperature ?? this.config.temperature;
-		return {
+		return mergeProviderBody({
 			model: this.name,
 			...instructions !== void 0 ? { instructions } : {},
 			input,
@@ -1709,7 +2046,24 @@ var OpenAIResponsesModel = class {
 			...this.buildTextFormat(options?.responseSchema),
 			...this.buildReasoningParams(options?.reasoning),
 			...buildPromptCacheParams(this.provider, this.config)
-		};
+		}, options);
+	}
+	/**
+	* The request `tools`: function tools (flat, `strict: false`), then the
+	* `ai.providerTool({ provider: "openai" })` definitions verbatim — the
+	* Responses built-in tools (`web_search`, `file_search`,
+	* `code_interpreter`, `image_generation`, `mcp`, …). Other providers'
+	* definitions are skipped with a warning. `undefined` when there are none.
+	*/
+	buildTools(options) {
+		const { tools, definitions } = (0, _warlock_js_ai.selectProviderTools)(options, {
+			accepts: [this.provider],
+			module: LOG_MODULE$2,
+			model: this.name,
+			logger: this.logger
+		});
+		const mapped = [...toResponsesTools(tools) ?? [], ...definitions];
+		return mapped.length > 0 ? mapped : void 0;
 	}
 	/**
 	* Structured output on Responses lives in `text.format`, and `name` /
@@ -1746,12 +2100,8 @@ var OpenAIResponsesModel = class {
 	readOutput(output) {
 		let content = "";
 		const toolCalls = [];
-		const reasoningItems = [];
 		for (const item of output) {
-			if (item.type === "reasoning") {
-				reasoningItems.push(item);
-				continue;
-			}
+			this.assertServerRunItem(item);
 			if (item.type === "message") {
 				for (const part of item.content) content += part.type === "refusal" ? part.refusal : part.text;
 				continue;
@@ -1760,9 +2110,24 @@ var OpenAIResponsesModel = class {
 		}
 		return {
 			content,
-			toolCalls: toolCalls.length > 0 ? attachReasoningReplay(toolCalls, this.name, reasoningItems) : void 0
+			toolCalls: toolCalls.length > 0 ? attachReasoningReplay(toolCalls, this.name, pickTurnReasoning(output)) : void 0
 		};
 	}
+	/**
+	* Fail closed on a built-in tool call that YOUR code would have to run
+	* (`shell_call`, `apply_patch_call`, `computer_call`, …, from a
+	* provider-defined client tool). These items have their own output item
+	* types that this adapter does not map, so the turn would otherwise end
+	* silently with the call dropped. Hosted (server-run) tool items pass.
+	*/
+	assertServerRunItem(item) {
+		if (!CLIENT_RUN_ITEM_TYPES.has(item.type)) return;
+		throw new _warlock_js_ai.InvalidRequestError(`OpenAI returned a "${item.type}" item: that built-in tool is executed by the caller, which the Responses adapter does not support. Use OpenAI's server-run built-in tools (web_search, file_search, code_interpreter, image_generation, mcp without approval) with ai.providerTool(), or a function tool from ai.tool().`, { context: {
+			provider: this.provider,
+			model: this.name,
+			itemType: item.type
+		} });
+	}
 	/** One completed `function_call` item as a neutral tool call (`call_id` -> `id`). */
 	toToolCall(item) {
 		return {
@@ -1791,7 +2156,7 @@ var OpenAIResponsesModel = class {
 			cachedTokens: raw.input_tokens_details?.cached_tokens,
 			cacheWriteTokens: raw.input_tokens_details?.cache_write_tokens,
 			reasoningTokens: raw.output_tokens_details?.reasoning_tokens
-		});
+		}, this.pricing);
 	}
 	/** Wrap (idempotently), log and return a failure for the caller to throw. */
 	logAndWrap(thrown) {
@@ -2014,8 +2379,9 @@ var OpenAISDK = class {
 	* coming from the same upstream.
 	*
 	* Pricing resolution: per-model `config.pricing` wins; otherwise the
-	* SDK-level registry entry keyed by `config.name`; otherwise
-	* `undefined` (no cost computed).
+	* SDK-level registry entry keyed by `config.name`; otherwise, when the
+	* provider label is `"openai"`, the built-in list price
+	* (`OPENAI_MODEL_PRICING`); otherwise `undefined` (no cost computed).
 	*
 	* `config.api` selects the wire API. Omitted or `"chat"` builds the Chat
 	* Completions `OpenAIModel`. `"responses"` builds `OpenAIResponsesModel`
@@ -2036,7 +2402,7 @@ var OpenAISDK = class {
 			model: config.name,
 			api
 		} });
-		const resolvedPricing = config.pricing ?? this.pricing?.[config.name];
+		const resolvedPricing = config.pricing ?? this.pricing?.[config.name] ?? (this.provider === "openai" ? openAIPricingFor(config.name) : void 0);
 		const resolvedConfig = resolvedPricing === config.pricing ? config : {
 			...config,
 			pricing: resolvedPricing
@@ -2123,9 +2489,11 @@ var OpenAISDK = class {
 };
 
 //#endregion
+exports.OPENAI_MODEL_PRICING = OPENAI_MODEL_PRICING;
 exports.OpenAIEmbedder = OpenAIEmbedder;
 exports.OpenAIImageModel = OpenAIImageModel;
 exports.OpenAISDK = OpenAISDK;
 exports.OpenAISpeechModel = OpenAISpeechModel;
 exports.OpenAITranscriptionModel = OpenAITranscriptionModel;
+exports.openAIPricingFor = openAIPricingFor;
 //# sourceMappingURL=index.cjs.map