@byfriends/kosong 0.1.0

package/dist/providers/openai-responses.mjs

@@ -0,0 +1,623 @@
+import { c as thinkingEffortToReasoningEffort, n as convertOpenAIError, p as extractText, s as reasoningEffortToThinkingEffort } from "../openai-common-08qin3UI.mjs";
+import { o as ChatProviderError } from "../errors-WFxxzL1B.mjs";
+import { n as requireProviderApiKey, r as resolveAuthBackedClient, t as mergeRequestHeaders } from "../request-auth-DCWSyCKI.mjs";
+import { a as usesOpenAIResponsesDeveloperRole, i as getOpenAIResponsesModelCapability } from "../capability-registry-CMBuEYcf.mjs";
+import OpenAI from "openai";
+//#region src/providers/openai-responses.ts
+/**
+* Normalize the Responses API status / incomplete_details into the unified
+* {@link FinishReason} enum.
+*
+* Note: the Responses API has no `tool_calls`-style status. When a response
+* completes with `function_call` items inline the status is still
+* `'completed'`; callers detect tool calls via `message.toolCalls.length`,
+* not via finishReason.
+*/
+function normalizeResponsesFinishReason(status, incompleteReason) {
+	if (status === null || status === void 0) return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	if (status === "completed") return {
+		finishReason: "completed",
+		rawFinishReason: "completed"
+	};
+	if (status === "incomplete") {
+		if (incompleteReason === "max_output_tokens") return {
+			finishReason: "truncated",
+			rawFinishReason: "max_output_tokens"
+		};
+		if (incompleteReason === "content_filter") return {
+			finishReason: "filtered",
+			rawFinishReason: "content_filter"
+		};
+		return {
+			finishReason: "other",
+			rawFinishReason: incompleteReason ?? "incomplete"
+		};
+	}
+	if (status === "failed") return {
+		finishReason: "other",
+		rawFinishReason: "failed"
+	};
+	return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+}
+function asRawObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function readStringField(object, key) {
+	const value = object[key];
+	return typeof value === "string" ? value : void 0;
+}
+function readNullableStringField(object, key) {
+	const value = object[key];
+	if (value === null) return null;
+	return typeof value === "string" ? value : void 0;
+}
+function readNumberField(object, key) {
+	const value = object[key];
+	return typeof value === "number" ? value : void 0;
+}
+function readObjectField(object, key) {
+	return asRawObject(object[key]) ?? void 0;
+}
+function readObjectArrayField(object, key) {
+	const value = object[key];
+	if (!Array.isArray(value)) return void 0;
+	return value.flatMap((item) => {
+		const objectItem = asRawObject(item);
+		return objectItem === null ? [] : [objectItem];
+	});
+}
+function failResponsesDecode(context, detail) {
+	throw new ChatProviderError(`OpenAI Responses decode error: ${context} ${detail}`);
+}
+function requireStringField(object, key, context) {
+	const value = readStringField(object, key);
+	if (value === void 0) failResponsesDecode(`${context}.${key}`, "must be a string.");
+	return value;
+}
+function requireObjectField(object, key, context) {
+	const value = readObjectField(object, key);
+	if (value === void 0) failResponsesDecode(`${context}.${key}`, "must be an object.");
+	return value;
+}
+function readResponseOutputItem(value, context) {
+	const item = asRawObject(value);
+	if (item === null) failResponsesDecode(context, "must be an object.");
+	const type = requireStringField(item, "type", context);
+	if (type === "message") return {
+		type,
+		content: readObjectArrayField(item, "content") ?? []
+	};
+	if (type === "function_call") return {
+		type,
+		itemId: readStringField(item, "id"),
+		callId: readStringField(item, "call_id"),
+		name: readStringField(item, "name"),
+		arguments: readNullableStringField(item, "arguments")
+	};
+	if (type === "reasoning") return {
+		type,
+		encryptedContent: readStringField(item, "encrypted_content"),
+		summary: readObjectArrayField(item, "summary") ?? []
+	};
+	return { type: "other" };
+}
+function responseStreamIndex(itemId, outputIndex) {
+	return itemId ?? outputIndex;
+}
+function formatResponseStreamIndex(streamIndex) {
+	return streamIndex === void 0 ? "<unindexed>" : String(streamIndex);
+}
+function requireFunctionCallName(item) {
+	if (item.name === void 0) throw new ChatProviderError("OpenAI Responses function_call item is missing a name.");
+	return item.name;
+}
+function functionCallId(callId) {
+	return callId === void 0 || callId.length === 0 ? crypto.randomUUID() : callId;
+}
+function formatResponsesErrorEvent(code, message, param) {
+	return `${code ?? "unknown"}: ${message}${param === null ? "" : ` (param: ${param})`}`;
+}
+function formatResponsesFailedResponse(response) {
+	const error = readObjectField(response, "error");
+	if (error !== void 0) return `${readNullableStringField(error, "code") ?? "unknown"}: ${readStringField(error, "message") ?? "no message"}`;
+	const incompleteDetails = readObjectField(response, "incomplete_details");
+	const reason = incompleteDetails === void 0 ? void 0 : readStringField(incompleteDetails, "reason");
+	return reason === void 0 ? "Unknown error (no error details in response)" : `incomplete: ${reason}`;
+}
+function contentPartsToInputItems(parts) {
+	const items = [];
+	for (const part of parts) switch (part.type) {
+		case "text":
+			if (part.text) items.push({
+				type: "input_text",
+				text: part.text
+			});
+			break;
+		case "image_url":
+			items.push({
+				type: "input_image",
+				detail: "auto",
+				image_url: part.imageUrl.url
+			});
+			break;
+		case "audio_url": {
+			const mapped = mapAudioUrlToInputItem(part.audioUrl.url);
+			if (mapped !== null) items.push(mapped);
+			break;
+		}
+		case "think":
+		case "video_url": break;
+	}
+	return items;
+}
+function contentPartsToOutputItems(parts) {
+	const items = [];
+	for (const part of parts) if (part.type === "text" && part.text) items.push({
+		type: "output_text",
+		text: part.text,
+		annotations: []
+	});
+	return items;
+}
+function messageContentToFunctionOutputItems(content) {
+	const items = [];
+	for (const part of content) switch (part.type) {
+		case "text":
+			if (part.text) items.push({
+				type: "input_text",
+				text: part.text
+			});
+			break;
+		case "image_url":
+			items.push({
+				type: "input_image",
+				image_url: part.imageUrl.url
+			});
+			break;
+		case "audio_url": {
+			const mapped = mapAudioUrlToInputItem(part.audioUrl.url);
+			if (mapped !== null) items.push(mapped);
+			break;
+		}
+		case "think":
+		case "video_url": break;
+	}
+	return items;
+}
+function mapAudioUrlToInputItem(url) {
+	if (url.startsWith("data:audio/")) try {
+		const parts = url.split(",", 2);
+		if (parts.length !== 2 || parts[0] === void 0 || parts[1] === void 0) return null;
+		const header = parts[0];
+		const b64 = parts[1];
+		const subtypePart = header.split("/")[1];
+		if (subtypePart === void 0) return null;
+		const [subtypeHead = ""] = subtypePart.split(";");
+		const subtype = subtypeHead.toLowerCase();
+		const ext = subtype === "mp3" || subtype === "mpeg" ? "mp3" : subtype === "wav" ? "wav" : null;
+		if (ext === null) return null;
+		return {
+			type: "input_file",
+			file_data: b64,
+			filename: `inline.${ext}`
+		};
+	} catch {
+		return null;
+	}
+	if (url.startsWith("http://") || url.startsWith("https://")) return {
+		type: "input_file",
+		file_url: url
+	};
+	return null;
+}
+function convertMessage(message, modelName, toolMessageConversion) {
+	let role = message.role;
+	if (usesOpenAIResponsesDeveloperRole(modelName) && role === "system") role = "developer";
+	if (role === "tool") return [{
+		call_id: message.toolCallId ?? "",
+		output: toolMessageConversion === "extract_text" ? extractText(message) : messageContentToFunctionOutputItems(message.content),
+		type: "function_call_output"
+	}];
+	const result = [];
+	if (message.content.length > 0) {
+		const pendingParts = [];
+		const flushPendingParts = () => {
+			if (pendingParts.length === 0) return;
+			if (role === "assistant") result.push({
+				content: contentPartsToOutputItems(pendingParts),
+				role,
+				type: "message"
+			});
+			else result.push({
+				content: contentPartsToInputItems(pendingParts),
+				role,
+				type: "message"
+			});
+			pendingParts.length = 0;
+		};
+		let i = 0;
+		const n = message.content.length;
+		while (i < n) {
+			const part = message.content[i];
+			if (part === void 0) break;
+			if (part.type === "think") {
+				flushPendingParts();
+				const encryptedValue = part.encrypted;
+				const summaries = [{
+					type: "summary_text",
+					text: part.think || ""
+				}];
+				i += 1;
+				while (i < n) {
+					const nextPart = message.content[i];
+					if (nextPart === void 0) break;
+					if (nextPart.type !== "think") break;
+					if (nextPart.encrypted !== encryptedValue) break;
+					summaries.push({
+						type: "summary_text",
+						text: nextPart.think || ""
+					});
+					i += 1;
+				}
+				result.push({
+					summary: summaries,
+					type: "reasoning",
+					encrypted_content: encryptedValue
+				});
+			} else {
+				pendingParts.push(part);
+				i += 1;
+			}
+		}
+		flushPendingParts();
+	}
+	for (const toolCall of message.toolCalls) result.push({
+		arguments: toolCall.arguments ?? "{}",
+		call_id: toolCall.id,
+		name: toolCall.name,
+		type: "function_call"
+	});
+	return result;
+}
+function convertTool(tool) {
+	return {
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters,
+		strict: false
+	};
+}
+var OpenAIResponsesStreamedMessage = class {
+	_id = null;
+	_usage = null;
+	_finishReason = null;
+	_rawFinishReason = null;
+	_iter;
+	constructor(response, isStream) {
+		if (isStream) this._iter = this._convertStreamResponse(response);
+		else this._iter = this._convertNonStreamResponse(response);
+	}
+	get id() {
+		return this._id;
+	}
+	get usage() {
+		return this._usage;
+	}
+	get finishReason() {
+		return this._finishReason;
+	}
+	get rawFinishReason() {
+		return this._rawFinishReason;
+	}
+	async *[Symbol.asyncIterator]() {
+		yield* this._iter;
+	}
+	_captureFinishReasonFromResponse(response) {
+		const status = readNullableStringField(response, "status");
+		const incomplete = readObjectField(response, "incomplete_details");
+		const normalized = normalizeResponsesFinishReason(status, incomplete ? readStringField(incomplete, "reason") : null);
+		this._finishReason = normalized.finishReason;
+		this._rawFinishReason = normalized.rawFinishReason;
+	}
+	_extractUsage(usage) {
+		const inputTokens = readNumberField(usage, "input_tokens") ?? 0;
+		const outputTokens = readNumberField(usage, "output_tokens") ?? 0;
+		const details = readObjectField(usage, "input_tokens_details");
+		const cached = details ? readNumberField(details, "cached_tokens") ?? 0 : 0;
+		this._usage = {
+			inputOther: inputTokens - cached,
+			output: outputTokens,
+			inputCacheRead: cached,
+			inputCacheCreation: 0
+		};
+	}
+	async *_convertNonStreamResponse(response) {
+		this._id = readStringField(response, "id") ?? null;
+		const usage = readObjectField(response, "usage");
+		if (usage !== void 0) this._extractUsage(usage);
+		this._captureFinishReasonFromResponse(response);
+		const output = readObjectArrayField(response, "output");
+		if (output === void 0) return;
+		for (const item of output) {
+			const outputItem = readResponseOutputItem(item, "response.output item");
+			if (outputItem.type === "message") {
+				for (const contentItem of outputItem.content) if (contentItem["type"] === "output_text") {
+					const text = readStringField(contentItem, "text");
+					if (text !== void 0) yield {
+						type: "text",
+						text
+					};
+				}
+			} else if (outputItem.type === "function_call") yield {
+				type: "function",
+				id: functionCallId(outputItem.callId),
+				name: requireFunctionCallName(outputItem),
+				arguments: outputItem.arguments ?? null
+			};
+			else if (outputItem.type === "reasoning") for (const summary of outputItem.summary) {
+				const text = readStringField(summary, "text");
+				if (text === void 0) continue;
+				const thinkPart = {
+					type: "think",
+					think: text
+				};
+				if (outputItem.encryptedContent !== void 0) thinkPart.encrypted = outputItem.encryptedContent;
+				yield thinkPart;
+			}
+		}
+	}
+	async *_convertStreamResponse(response) {
+		const functionCallArgumentsByIndex = /* @__PURE__ */ new Map();
+		let unindexedFunctionCallArguments;
+		const hasFunctionCallArguments = (streamIndex) => streamIndex === void 0 ? unindexedFunctionCallArguments !== void 0 : functionCallArgumentsByIndex.has(streamIndex);
+		const getFunctionCallArguments = (streamIndex) => streamIndex === void 0 ? unindexedFunctionCallArguments : functionCallArgumentsByIndex.get(streamIndex);
+		const setFunctionCallArguments = (streamIndex, argumentsValue) => {
+			if (streamIndex === void 0) unindexedFunctionCallArguments = argumentsValue;
+			else functionCallArgumentsByIndex.set(streamIndex, argumentsValue);
+		};
+		const appendFunctionCallArguments = (streamIndex, argumentsPart, context) => {
+			if (!hasFunctionCallArguments(streamIndex)) failResponsesDecode(context, `received function-call arguments for unknown stream index ${formatResponseStreamIndex(streamIndex)}.`);
+			setFunctionCallArguments(streamIndex, getFunctionCallArguments(streamIndex) + argumentsPart);
+		};
+		const yieldFinalArgumentsSuffix = function* (streamIndex, finalArguments, context) {
+			if (!hasFunctionCallArguments(streamIndex)) failResponsesDecode(context, `received final function-call arguments for unknown stream index ${formatResponseStreamIndex(streamIndex)}.`);
+			const accumulatedArguments = getFunctionCallArguments(streamIndex);
+			if (finalArguments === accumulatedArguments) return;
+			if (!finalArguments.startsWith(accumulatedArguments)) throw new ChatProviderError(`OpenAI Responses final function-call arguments for stream index ${formatResponseStreamIndex(streamIndex)} do not match the streamed argument deltas.`);
+			const suffix = finalArguments.slice(accumulatedArguments.length);
+			setFunctionCallArguments(streamIndex, finalArguments);
+			if (suffix.length === 0) return;
+			const part = {
+				type: "tool_call_part",
+				argumentsPart: suffix
+			};
+			if (streamIndex !== void 0) part.index = streamIndex;
+			yield part;
+		};
+		try {
+			for await (const chunk of response) {
+				const type = requireStringField(chunk, "type", "stream event");
+				switch (type) {
+					case "response.output_text.delta":
+						yield {
+							type: "text",
+							text: requireStringField(chunk, "delta", type)
+						};
+						break;
+					case "response.created":
+					case "response.in_progress": {
+						const respId = readStringField(requireObjectField(chunk, "response", type), "id");
+						if (respId !== void 0) this._id = respId;
+						break;
+					}
+					case "response.output_item.added": {
+						const item = readResponseOutputItem(chunk["item"], `${type}.item`);
+						const outputIndex = readNumberField(chunk, "output_index");
+						if (item.type === "function_call") {
+							const streamIndex = responseStreamIndex(item.itemId, outputIndex);
+							setFunctionCallArguments(streamIndex, item.arguments ?? "");
+							const tc = {
+								type: "function",
+								id: functionCallId(item.callId),
+								name: requireFunctionCallName(item),
+								arguments: item.arguments ?? null
+							};
+							if (streamIndex !== void 0) tc._streamIndex = streamIndex;
+							yield tc;
+						}
+						break;
+					}
+					case "response.output_item.done": {
+						const item = readResponseOutputItem(chunk["item"], `${type}.item`);
+						const outputIndex = readNumberField(chunk, "output_index");
+						if (item.type === "reasoning") {
+							const thinkPart = {
+								type: "think",
+								think: ""
+							};
+							if (item.encryptedContent !== void 0) thinkPart.encrypted = item.encryptedContent;
+							yield thinkPart;
+						} else if (item.type === "function_call" && typeof item.arguments === "string") yield* yieldFinalArgumentsSuffix(responseStreamIndex(item.itemId, outputIndex), item.arguments, type);
+						break;
+					}
+					case "response.function_call_arguments.delta": {
+						const streamIndex = responseStreamIndex(readStringField(chunk, "item_id"), readNumberField(chunk, "output_index"));
+						const argumentsPart = requireStringField(chunk, "delta", type);
+						const part = {
+							type: "tool_call_part",
+							argumentsPart
+						};
+						appendFunctionCallArguments(streamIndex, argumentsPart, type);
+						if (streamIndex !== void 0) part.index = streamIndex;
+						yield part;
+						break;
+					}
+					case "response.function_call_arguments.done": {
+						const functionArguments = requireStringField(chunk, "arguments", type);
+						yield* yieldFinalArgumentsSuffix(responseStreamIndex(readStringField(chunk, "item_id"), readNumberField(chunk, "output_index")), functionArguments, type);
+						break;
+					}
+					case "response.reasoning_summary_part.added":
+						yield {
+							type: "think",
+							think: ""
+						};
+						break;
+					case "response.reasoning_summary_text.delta":
+						yield {
+							type: "think",
+							think: requireStringField(chunk, "delta", type)
+						};
+						break;
+					case "response.completed":
+					case "response.incomplete": {
+						const responseObject = requireObjectField(chunk, "response", type);
+						const respId = readStringField(responseObject, "id");
+						if (respId !== void 0) this._id = respId;
+						const usage = readObjectField(responseObject, "usage");
+						if (usage !== void 0) this._extractUsage(usage);
+						this._captureFinishReasonFromResponse(responseObject);
+						break;
+					}
+					case "error": {
+						const message = requireStringField(chunk, "message", type);
+						throw new ChatProviderError(`OpenAI Responses stream error: ${formatResponsesErrorEvent(readNullableStringField(chunk, "code") ?? null, message, readNullableStringField(chunk, "param") ?? null)}`);
+					}
+					case "response.failed": throw new ChatProviderError(`OpenAI Responses response.failed: ${formatResponsesFailedResponse(requireObjectField(chunk, "response", type))}`);
+					default: break;
+				}
+			}
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+};
+var OpenAIResponsesChatProvider = class {
+	name = "openai-responses";
+	_model;
+	_stream;
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_generationKwargs;
+	_toolMessageConversion;
+	_client;
+	_httpClient;
+	_clientFactory;
+	constructor(options) {
+		const apiKey = options.apiKey ?? process.env["OPENAI_API_KEY"];
+		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
+		this._baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+		this._defaultHeaders = options.defaultHeaders;
+		this._model = options.model;
+		this._stream = true;
+		this._generationKwargs = {};
+		this._toolMessageConversion = options.toolMessageConversion ?? null;
+		this._httpClient = options.httpClient;
+		this._clientFactory = options.clientFactory;
+		if (options.maxOutputTokens !== void 0) this._generationKwargs.max_output_tokens = options.maxOutputTokens;
+		this._client = this._apiKey === void 0 ? void 0 : this._buildClient(this._apiKey);
+	}
+	get modelName() {
+		return this._model;
+	}
+	get thinkingEffort() {
+		return reasoningEffortToThinkingEffort(this._generationKwargs.reasoning_effort);
+	}
+	get modelParameters() {
+		return {
+			model: this._model,
+			baseUrl: this._baseUrl,
+			...this._generationKwargs
+		};
+	}
+	getCapability(model) {
+		return getOpenAIResponsesModelCapability(model ?? this._model);
+	}
+	async generate(systemPrompt, tools, history, options) {
+		const input = [];
+		if (systemPrompt) {
+			const sysItem = {
+				role: "system",
+				content: systemPrompt
+			};
+			if (usesOpenAIResponsesDeveloperRole(this._model)) sysItem["role"] = "developer";
+			input.push(sysItem);
+		}
+		for (const msg of history) input.push(...convertMessage(msg, this._model, this._toolMessageConversion));
+		const kwargs = { ...this._generationKwargs };
+		const reasoningEffort = kwargs["reasoning_effort"];
+		delete kwargs["reasoning_effort"];
+		if (reasoningEffort !== void 0) {
+			kwargs["reasoning"] = {
+				effort: reasoningEffort,
+				summary: "auto"
+			};
+			kwargs["include"] = ["reasoning.encrypted_content"];
+		}
+		for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
+		try {
+			const client = this._createClient(options?.auth);
+			const createParams = {
+				model: this._model,
+				input,
+				tools: tools.map((t) => convertTool(t)),
+				store: false,
+				stream: this._stream,
+				...kwargs
+			};
+			if (!("responses" in client) || typeof client.responses?.create !== "function") throw new Error("OpenAI SDK version does not support Responses API. Upgrade to >=4.x with responses support.");
+			return new OpenAIResponsesStreamedMessage(await client.responses.create(createParams, options?.signal ? { signal: options.signal } : void 0), this._stream);
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+	withThinking(effort) {
+		const reasoningEffort = thinkingEffortToReasoningEffort(effort);
+		const clone = this._clone();
+		clone._generationKwargs = {
+			...clone._generationKwargs,
+			reasoning_effort: reasoningEffort
+		};
+		return clone;
+	}
+	withGenerationKwargs(kwargs) {
+		const clone = this._clone();
+		clone._generationKwargs = {
+			...clone._generationKwargs,
+			...kwargs
+		};
+		return clone;
+	}
+	_clone() {
+		const clone = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+		clone._generationKwargs = { ...this._generationKwargs };
+		return clone;
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => this._buildClient(requireProviderApiKey("OpenAIResponsesChatProvider", a, this._apiKey), a));
+	}
+	_buildClient(apiKey, auth) {
+		const clientOpts = {
+			apiKey,
+			baseURL: this._baseUrl
+		};
+		const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, auth?.headers);
+		if (defaultHeaders !== void 0) clientOpts["defaultHeaders"] = defaultHeaders;
+		if (this._httpClient !== void 0) clientOpts["httpClient"] = this._httpClient;
+		return new OpenAI(clientOpts);
+	}
+};
+//#endregion
+export { OpenAIResponsesChatProvider, OpenAIResponsesStreamedMessage };

package/dist/request-auth-DCWSyCKI.mjs

@@ -0,0 +1,63 @@
+import { o as ChatProviderError } from "./errors-WFxxzL1B.mjs";
+//#region src/capability.ts
+const UNKNOWN_CAPABILITY_MARKER = Symbol.for("byf.kosong.UNKNOWN_CAPABILITY");
+/**
+* Shared read-only default returned when a provider has not catalogued a
+* given model. Frozen so accidental mutation at one call site cannot leak
+* into another.
+*/
+const UNKNOWN_CAPABILITY = Object.freeze(Object.defineProperty({
+	image_in: false,
+	video_in: false,
+	audio_in: false,
+	thinking: false,
+	tool_use: false,
+	max_context_tokens: 0
+}, UNKNOWN_CAPABILITY_MARKER, { value: true }));
+function isUnknownCapability(capability) {
+	if (capability === UNKNOWN_CAPABILITY) return true;
+	if (capability[UNKNOWN_CAPABILITY_MARKER] === true) return true;
+	return !capability.image_in && !capability.video_in && !capability.audio_in && !capability.thinking && !capability.tool_use && capability.max_context_tokens === 0;
+}
+//#endregion
+//#region src/providers/request-auth.ts
+function requireProviderApiKey(providerName, auth, defaultApiKey) {
+	const apiKey = auth?.apiKey ?? defaultApiKey;
+	if (apiKey === void 0 || apiKey.length === 0) throw new ChatProviderError(`${providerName}: apiKey is required. Provide it via the constructor options, the provider's API-key environment variable, options.auth.apiKey on each request, or an OAuth login.`);
+	return apiKey;
+}
+function mergeRequestHeaders(defaultHeaders, requestHeaders) {
+	const merged = {};
+	if (defaultHeaders !== void 0) Object.assign(merged, defaultHeaders);
+	if (requestHeaders !== void 0) Object.assign(merged, requestHeaders);
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+/**
+* Resolve the SDK client to use for a single provider request, applying the
+* standard precedence shared by every provider adapter:
+*
+* 1. If a `clientFactory` was supplied, delegate to it (it receives the
+*    per-request {@link ProviderRequestAuth}, defaulting to `{}`).
+* 2. Otherwise, if no per-request auth is needed AND a constructor-time
+*    client was cached, reuse the cached instance.
+* 3. Otherwise, call `build(auth)` to construct a fresh client for this
+*    request — typically using `requireProviderApiKey` plus
+*    `mergeRequestHeaders`.
+*
+* Note: when per-request `auth` is provided (e.g. an OAuth bearer token
+* resolved immediately before each call), step 3 fires and a brand-new SDK
+* client is constructed per request. This is intentional — it keeps short-lived
+* credentials out of any long-lived shared state and avoids racing concurrent
+* requests on a mutable client. The trade-off is that connection-pool / keep-
+* alive state inside the SDK client isn't reused across requests on the OAuth
+* path. For the current agent-CLI workload (one LLM call per turn step) this
+* is fine; if a future host needs high-throughput per-request auth, the
+* obvious optimization is a small LRU keyed on `(apiKey, headers digest)`.
+*/
+function resolveAuthBackedClient(state, auth, build) {
+	if (state.clientFactory !== void 0) return state.clientFactory(auth ?? {});
+	if (auth === void 0 && state.cachedClient !== void 0) return state.cachedClient;
+	return build(auth);
+}
+//#endregion
+export { isUnknownCapability as a, UNKNOWN_CAPABILITY as i, requireProviderApiKey as n, resolveAuthBackedClient as r, mergeRequestHeaders as t };