@warlock.js/ai-openai 5.30.0 → 5.32.0

package/cjs/index.cjs

@@ -20,7 +20,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -31,6 +31,125 @@ 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];
+}
+/** USD per request for web_search (NOT non-reasoning web_search_preview).
+* Search content tokens are additional; preview variants can have other rates.
+* https://developers.openai.com/api/docs/pricing#built-in-tools — verified 2026-10-18. */
+const OPENAI_SERVER_TOOL_PRICING = { webSearch: .01 };
+
+//#endregion
 //#region ../../packages/ai-openai/src/utils/build-usage.ts
 /**
 * Build the neutral `Usage` from extracted counts. The optional detail
@@ -38,17 +157,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 +238,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 +405,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 = /* @__PURE__ */ 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 +568,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 = /* @__PURE__ */ 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 +1240,58 @@ var OpenAIImageModel = class {
 	}
 };
 
+//#endregion
+//#region ../../packages/ai-openai/src/provider-options.ts
+const RESERVED_FIELDS = /* @__PURE__ */ 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;
+}
+function compatibleSearchParams(provider, options) {
+	if (provider !== "qwen" && provider !== "dashscope") return {};
+	const value = options?.providerOptions?.[provider]?.enableSearch;
+	if (value === void 0) return {};
+	if (typeof value !== "boolean") throw new _warlock_js_ai.InvalidRequestError(`providerOptions.${provider}.enableSearch must be a boolean`);
+	return { enable_search: value };
+}
+
 //#endregion
 //#region ../../packages/ai-openai/src/known-reasoning-models.ts
 /**
@@ -1227,15 +1454,16 @@ var OpenAIModel = class {
 		});
 		let response;
 		try {
-			response = await this.client.chat.completions.create({
+			response = await this.client.chat.completions.create(mergeProviderBody({
 				model: this.name,
+				...compatibleSearchParams(this.provider, options),
 				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 +1496,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 +1511,18 @@ var OpenAIModel = class {
 		});
 		let stream;
 		try {
-			stream = await this.client.chat.completions.create({
+			stream = await this.client.chat.completions.create(mergeProviderBody({
 				model: this.name,
+				...compatibleSearchParams(this.provider, options),
 				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 +1532,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 +1559,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 +1607,30 @@ 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
+		});
+		if ((this.provider === "moonshot" || this.provider === "kimi") && definitions.some((definition) => {
+			const fn = definition.function;
+			return definition.type === "builtin_function" && typeof fn === "object" && fn !== null && "name" in fn && fn.name === "$web_search";
+		})) throw new _warlock_js_ai.InvalidRequestError("Kimi's builtin $web_search retires on 20 October 2026. Use kimiSearchTool() / kimiFetchTool() from @warlock.js/ai-openai.");
+		if (this.provider === "xai" && definitions.some((definition) => definition.type === "web_search" || definition.type === "x_search")) throw new _warlock_js_ai.InvalidRequestError("xAI native web_search / x_search requires POST /v1/responses. XaiSDK currently supports Chat Completions only; use xAI's Responses API with the vendor SDK for native search.");
+		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 +1669,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 +1680,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 +1762,56 @@ 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/utils/hosted-output.ts
+/** Installed openai 7.23.0 ResponseFunctionWebSearch (action includes search/open_page/find).
+* https://developers.openai.com/api/docs/guides/tools-web-search
+* Count output items, never URLs, sources, answer text, or function calls.
+* Fees and search content tokens are separate; preview pricing varies:
+* https://developers.openai.com/api/docs/pricing#built-in-tools */
+function hostedOutput(usage, output, pricing) {
+	const hosted = output.filter((item) => item.type !== "message" && item.type !== "reasoning" && item.type !== "function_call");
+	const searches = hosted.filter((item) => item.type === "web_search_call");
+	if (searches.length) usage.serverToolUse = {
+		...usage.serverToolUse,
+		webSearchRequests: searches.length
+	};
+	(0, _warlock_js_ai.attachCost)(usage, pricing);
+	return hosted.length ? { openai: { output: hosted } } : void 0;
+}
 
 //#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 = /* @__PURE__ */ 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 +1838,17 @@ 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 retained in
+* `providerMetadata.openai.output` for inspection and 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") {
@@ -1574,6 +1900,7 @@ var OpenAIResponsesModel = class {
 			hasToolCalls: toolCalls !== void 0
 		});
 		const usage = this.extractUsage(response.usage);
+		const providerMetadata = hostedOutput(usage, output, this.pricing);
 		this.logger.debug(LOG_MODULE$2, "response", "call to responses.create succeeded", {
 			finishReason,
 			usage
@@ -1582,9 +1909,30 @@ var OpenAIResponsesModel = class {
 			content,
 			finishReason,
 			usage,
+			...providerMetadata ? { providerMetadata } : {},
 			...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 +1967,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 +1980,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 +2030,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,
@@ -1667,6 +2043,8 @@ var OpenAIResponsesModel = class {
 			hasToolCalls: toolCalls.length > 0
 		});
 		const usage = this.extractUsage(terminal.usage);
+		const output = terminal.output?.length ? terminal.output : outputItems;
+		const providerMetadata = hostedOutput(usage, output, this.pricing);
 		this.logger.debug(LOG_MODULE$2, "response", "Streaming call to responses.create succeeded", {
 			finishReason,
 			usage
@@ -1674,7 +2052,8 @@ var OpenAIResponsesModel = class {
 		yield {
 			type: "done",
 			finishReason,
-			usage
+			usage,
+			...providerMetadata ? { providerMetadata } : {}
 		};
 	}
 	/**
@@ -1692,16 +2071,16 @@ 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,
 			store: false,
-			include: ["reasoning.encrypted_content"],
+			include: ["reasoning.encrypted_content", ...tools?.some((tool) => tool.type === "web_search" || tool.type === "web_search_2025_08_26" || tool.type === "web_search_preview" || tool.type === "web_search_preview_2025_03_11") ? ["web_search_call.action.sources"] : []],
 			...maxTokens !== void 0 ? { max_output_tokens: maxTokens } : {},
 			...!this.capabilities.reasoning && temperature !== void 0 ? { temperature } : {},
 			...tools ? { tools } : {},
@@ -1709,7 +2088,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 +2142,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 +2152,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 +2198,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 +2421,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 +2444,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 +2531,265 @@ var OpenAISDK = class {
 };
 
 //#endregion
+//#region ../../packages/ai-openai/src/kimi-tools.ts
+/** USD per billable REST request, verified 2026-10-18:
+* https://platform.kimi.ai/docs/pricing/websearch
+* HTTP 200 + nonempty search_results / nonblank markdown only. Taxes excluded.
+* Namespaced rates avoid charging the generic counters a second time. */
+const KIMI_SERVER_TOOL_PRICING = Object.freeze({
+	kimiSearchRequests: .002,
+	kimiSearchProRequests: .003,
+	kimiFetchRequests: .002
+});
+/** Standalone first-party REST search, registered as an ordinary client function tool.
+* Wire contract: https://platform.kimi.ai/docs/api/tools-search and tools-search-pro.
+* Reuse the API key / baseURL configuration passed to OpenAISDK; the default URL
+* here is Moonshot, independent of the model used by the agent. */
+function kimiSearchTool(options) {
+	const mode = options.mode ?? "basic";
+	if (mode !== "basic" && mode !== "pro") throw new _warlock_js_ai.InvalidRequestError("Invalid Kimi search mode.");
+	const limit = integer(options.limit ?? 5, 1, 20, "limit");
+	const timeout = integer(options.timeoutSeconds ?? 30, 1, 60, "timeoutSeconds");
+	if (mode === "basic" && (options.sites !== void 0 || options.timeWindow !== void 0)) throw new _warlock_js_ai.InvalidRequestError("Kimi sites and timeWindow require mode: pro.");
+	if (mode === "pro" && options.includeContent !== void 0) throw new _warlock_js_ai.InvalidRequestError("Kimi includeContent is available only in basic mode.");
+	if (options.sites && (options.sites.length > 5 || options.sites.some((site) => !site || /[\s()]/u.test(site)))) throw new _warlock_js_ai.InvalidRequestError("Kimi sites accepts at most five nonempty sites without whitespace or parentheses.");
+	const maxChars = contentLimit(options);
+	const client = createClient(options);
+	const counter = mode === "pro" ? "kimiSearchProRequests" : "kimiSearchRequests";
+	return meteredTool({
+		name: mode === "pro" ? "kimi_search_pro" : "kimi_search",
+		description: "Search the web with Kimi and return cited sources and relevant text.",
+		input: stringInput("query"),
+		async execute({ query }, ctx, record) {
+			const body = {
+				text_query: query,
+				limit,
+				timeout_seconds: timeout,
+				...mode === "basic" ? { include_content: options.includeContent ?? false } : {
+					...options.sites !== void 0 ? { sites: options.sites } : {},
+					...options.timeWindow !== void 0 ? { time_window: options.timeWindow } : {}
+				}
+			};
+			const raw = await request(client, mode === "pro" ? "/tools/search_pro" : "/tools/search", body, ctx);
+			if (!isObject(raw.data) || !Array.isArray(raw.data.search_results)) throw new _warlock_js_ai.ProviderError("Kimi returned invalid search_results.");
+			record(raw.status === 200 && raw.data.search_results.length > 0);
+			const budget = textBudget(maxChars);
+			return {
+				results: raw.data.search_results.slice(0, limit).map((value) => {
+					if (!isObject(value)) throw new _warlock_js_ai.ProviderError("Kimi returned an invalid search result.");
+					const result = {
+						title: stringValue(value.title),
+						url: stringValue(value.url),
+						snippet: budget.take(stringValue(value.snippet)),
+						siteName: stringValue(value.site_name),
+						date: stringValue(value.date),
+						authority: stringValue(value.authority)
+					};
+					if (mode === "basic" && options.includeContent) result.text = budget.take(stringValue(value.text));
+					if (mode === "pro") {
+						if (!Array.isArray(value.chunks)) throw new _warlock_js_ai.ProviderError("Kimi returned invalid search chunks.");
+						result.chunks = value.chunks.map((chunk) => {
+							if (!isObject(chunk) || typeof chunk.score !== "number" || !Number.isFinite(chunk.score)) throw new _warlock_js_ai.ProviderError("Kimi returned an invalid search chunk.");
+							return {
+								text: budget.take(stringValue(chunk.text)),
+								score: chunk.score
+							};
+						}).filter((chunk) => chunk.text.length > 0);
+					}
+					return result;
+				}),
+				truncated: budget.truncated || raw.data.search_results.length > limit
+			};
+		}
+	}, counter, options.pricing);
+}
+/** First-party URL-to-Markdown REST tool.
+* https://platform.kimi.ai/docs/api/tools-fetch — only http/https inputs. */
+function kimiFetchTool(options) {
+	const client = createClient(options);
+	const maxChars = contentLimit(options);
+	return meteredTool({
+		name: "kimi_fetch",
+		description: "Read a web page with Kimi and return its title, URL and Markdown body.",
+		input: stringInput("url"),
+		async execute({ url }, ctx, record) {
+			let parsed;
+			try {
+				parsed = new URL(url);
+			} catch {
+				throw new _warlock_js_ai.InvalidRequestError("Kimi fetch requires an http/https URL.");
+			}
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new _warlock_js_ai.InvalidRequestError("Kimi fetch requires an http/https URL.");
+			const raw = await request(client, "/tools/fetch", { url }, ctx);
+			if (!isObject(raw.data) || typeof raw.data.markdown !== "string") throw new _warlock_js_ai.ProviderError("Kimi returned invalid fetch content.");
+			record(raw.status === 200 && raw.data.markdown.trim().length > 0);
+			return {
+				url: stringValue(raw.data.url),
+				title: stringValue(raw.data.title),
+				markdown: raw.data.markdown.slice(0, maxChars),
+				truncated: raw.data.markdown.length > maxChars
+			};
+		}
+	}, "kimiFetchRequests", options.pricing);
+}
+function createClient(options) {
+	const { apiKey, baseURL, fetch, timeout, defaultHeaders } = options;
+	if (!apiKey) throw new _warlock_js_ai.ProviderAuthError("Kimi tools require an explicitly configured API key.");
+	return new openai.default({
+		apiKey,
+		baseURL: baseURL ?? "https://api.moonshot.ai/v1",
+		fetch,
+		timeout,
+		defaultHeaders,
+		maxRetries: 0
+	});
+}
+async function request(client, path, body, ctx) {
+	try {
+		ctx?.signal?.throwIfAborted();
+		const response = await client.post(path, {
+			body,
+			signal: ctx?.signal
+		}).withResponse();
+		return {
+			data: response.data,
+			status: response.response.status
+		};
+	} catch (thrown) {
+		if (ctx?.signal?.aborted) throw new _warlock_js_ai.AgentCancelledError("Kimi tool request cancelled.", { cause: thrown });
+		if (thrown instanceof openai.APIError) {
+			const context = {
+				status: thrown.status,
+				type: thrown.type,
+				requestId: thrown.headers?.get("x-msh-track-id")
+			};
+			if (thrown.status === 408 || thrown.status === 504) throw new _warlock_js_ai.ProviderTimeoutError(thrown.message, {
+				cause: thrown,
+				context
+			});
+			if (thrown.status === 429) {
+				const retry = Number(thrown.headers?.get("retry-after") ?? NaN);
+				throw new _warlock_js_ai.ProviderRateLimitError(thrown.message, {
+					cause: thrown,
+					context,
+					retryAfter: Number.isFinite(retry) && retry >= 0 ? retry * 1e3 : void 0
+				});
+			}
+			if (thrown.status === 403 && !thrown.type) throw new _warlock_js_ai.ProviderAuthError(thrown.message, {
+				cause: thrown,
+				context
+			});
+		}
+		throw wrapOpenAIError(thrown);
+	}
+}
+/** Each invoke owns its ledger, including concurrent calls and post-response failures.
+* ToolContract.invoke is the existing accounting boundary used by agents/reports. */
+function meteredTool(config, counter, prices = KIMI_SERVER_TOOL_PRICING) {
+	const rate = prices[counter];
+	if (rate !== void 0 && (!Number.isFinite(rate) || rate < 0)) throw new _warlock_js_ai.InvalidRequestError("Kimi per-call pricing must be finite and nonnegative.");
+	return {
+		...(0, _warlock_js_ai.tool)({
+			...config,
+			execute: (input, ctx) => config.execute(input, ctx, () => {})
+		}),
+		async invoke(input, ctx) {
+			let usage = {
+				input: 0,
+				output: 0,
+				total: 0
+			};
+			const result = await (0, _warlock_js_ai.tool)({
+				...config,
+				execute: (validated, context) => config.execute(validated, context, (billable) => {
+					const count = billable ? 1 : 0;
+					usage = {
+						input: 0,
+						output: 0,
+						total: 0,
+						serverToolUse: {
+							[counter]: count,
+							[counter === "kimiFetchRequests" ? "webFetchRequests" : "webSearchRequests"]: count
+						}
+					};
+					if (rate !== void 0) usage.cost = (0, _warlock_js_ai.computeCost)(usage, {
+						input: 0,
+						output: 0,
+						serverTools: { [counter]: rate }
+					});
+				})
+			}).invoke(input, ctx);
+			return {
+				...result,
+				usage,
+				report: {
+					...result.report,
+					usage
+				}
+			};
+		}
+	};
+}
+function integer(value, min, max, name) {
+	if (!Number.isInteger(value) || value < min || value > max) throw new _warlock_js_ai.InvalidRequestError(`Kimi ${name} must be an integer from ${min} to ${max}.`);
+	return value;
+}
+function contentLimit(options) {
+	return integer(options.maxContentChars ?? 12e3, 1, Number.MAX_SAFE_INTEGER, "maxContentChars");
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+	if (typeof value !== "string") throw new _warlock_js_ai.ProviderError("Kimi returned an invalid text field.");
+	return value;
+}
+function textBudget(max) {
+	return {
+		truncated: false,
+		take(text) {
+			const result = text.slice(0, max);
+			if (text.length > max) this.truncated = true;
+			max -= result.length;
+			return result;
+		}
+	};
+}
+function stringInput(key) {
+	return {
+		jsonSchema: {
+			type: "object",
+			properties: { [key]: {
+				type: "string",
+				minLength: 1
+			} },
+			required: [key],
+			additionalProperties: false
+		},
+		"~standard": {
+			version: 1,
+			vendor: "kimi",
+			validate(value) {
+				if (!isObject(value) || typeof value[key] !== "string" || !value[key].trim()) return { issues: [{
+					message: `${key} must be a nonempty string`,
+					path: [key]
+				}] };
+				return { value: { [key]: value[key] } };
+			}
+		}
+	};
+}
+
+//#endregion
+exports.KIMI_SERVER_TOOL_PRICING = KIMI_SERVER_TOOL_PRICING;
+exports.OPENAI_MODEL_PRICING = OPENAI_MODEL_PRICING;
+exports.OPENAI_SERVER_TOOL_PRICING = OPENAI_SERVER_TOOL_PRICING;
 exports.OpenAIEmbedder = OpenAIEmbedder;
 exports.OpenAIImageModel = OpenAIImageModel;
 exports.OpenAISDK = OpenAISDK;
 exports.OpenAISpeechModel = OpenAISpeechModel;
 exports.OpenAITranscriptionModel = OpenAITranscriptionModel;
+exports.kimiFetchTool = kimiFetchTool;
+exports.kimiSearchTool = kimiSearchTool;
+exports.openAIPricingFor = openAIPricingFor;
 //# sourceMappingURL=index.cjs.map