@byfriends/kosong 0.1.0

package/dist/openai-compat-CWbwO4b7.mjs

@@ -0,0 +1,801 @@
+import { a as isFunctionToolCall, i as extractUsage, l as toolToOpenAI, n as convertOpenAIError, o as normalizeOpenAIFinishReason, s as reasoningEffortToThinkingEffort, t as convertContentPart } from "./openai-common-08qin3UI.mjs";
+import { o as ChatProviderError } from "./errors-WFxxzL1B.mjs";
+import { i as UNKNOWN_CAPABILITY, n as requireProviderApiKey, r as resolveAuthBackedClient, t as mergeRequestHeaders } from "./request-auth-DCWSyCKI.mjs";
+import { t as convertChatCompletionStreamToolCall } from "./chat-completions-stream-BuMu_xr9.mjs";
+import OpenAI from "openai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+//#region src/providers/openai-compat-schema.ts
+/**
+* Dereference all `$ref` references in a JSON Schema by inlining definitions
+* from local JSON pointers such as `$defs` and draft-7 `definitions`. Resolved
+* top-level definition buckets are removed from the result.
+*
+* Circular references are detected and left as `$ref` to avoid infinite
+* recursion; in that case the referenced definition bucket is preserved so the
+* remaining local `$ref` pointers stay resolvable to a JSON Schema validator.
+*/
+function derefJsonSchema(schema) {
+	const result = resolveNode(schema, schema, /* @__PURE__ */ new Set());
+	if (!hasUnresolvedDefinitionRef(result, "$defs")) delete result["$defs"];
+	if (!hasUnresolvedDefinitionRef(result, "definitions")) delete result["definitions"];
+	return result;
+}
+const TYPE_COMPLETION_SKIP_KEYS = new Set([
+	"$ref",
+	"allOf",
+	"anyOf",
+	"else",
+	"if",
+	"not",
+	"oneOf",
+	"then"
+]);
+const CHILD_SCHEMA_SLOTS = [
+	{
+		key: "$defs",
+		kind: "map"
+	},
+	{
+		key: "definitions",
+		kind: "map"
+	},
+	{
+		key: "dependencies",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "dependentSchemas",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "patternProperties",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "properties",
+		kind: "map",
+		parentType: "object"
+	},
+	{
+		key: "additionalItems",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "additionalProperties",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "contains",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "contentSchema",
+		kind: "single",
+		parentType: "string"
+	},
+	{
+		key: "else",
+		kind: "single"
+	},
+	{
+		key: "if",
+		kind: "single"
+	},
+	{
+		key: "not",
+		kind: "single"
+	},
+	{
+		key: "propertyNames",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "then",
+		kind: "single"
+	},
+	{
+		key: "unevaluatedItems",
+		kind: "single",
+		parentType: "array"
+	},
+	{
+		key: "unevaluatedProperties",
+		kind: "single",
+		parentType: "object"
+	},
+	{
+		key: "allOf",
+		kind: "array"
+	},
+	{
+		key: "anyOf",
+		kind: "array"
+	},
+	{
+		key: "oneOf",
+		kind: "array"
+	},
+	{
+		key: "prefixItems",
+		kind: "array",
+		parentType: "array"
+	},
+	{
+		key: "items",
+		kind: "schema-or-array",
+		parentType: "array"
+	}
+];
+const OBJECT_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("object"),
+	"dependentRequired",
+	"maxProperties",
+	"minProperties",
+	"required"
+]);
+const ARRAY_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("array"),
+	"maxContains",
+	"maxItems",
+	"minContains",
+	"minItems",
+	"uniqueItems"
+]);
+const STRING_STRUCTURE_KEYS = new Set([
+	...childSchemaKeysForParentType("string"),
+	"contentEncoding",
+	"contentMediaType",
+	"format",
+	"maxLength",
+	"minLength",
+	"pattern"
+]);
+const NUMERIC_STRUCTURE_KEYS = new Set([
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"maximum",
+	"minimum",
+	"multipleOf"
+]);
+/**
+* Return a deep-cloned JSON Schema with missing `type` fields filled in for
+* OpenAI-compatible tool compatibility.
+*
+* The tool validator rejects some valid JSON Schema shapes when nested
+* property schemas omit `type` (for example enum-only MCP properties). This is
+* a provider-compatibility normalizer, not a complete JSON Schema compiler:
+* it resolves local refs, preserves combinator nodes, infers obvious
+* scalar/object/array types, and falls back to `string` only for nested
+* typeless property schemas. The root schema object is treated as a container
+* and is not itself normalized.
+*/
+function normalizeOpenAICompatToolSchema(schema) {
+	return ensureOpenAICompatPropertyTypes(derefJsonSchema(schema));
+}
+function ensureOpenAICompatPropertyTypes(schema) {
+	const normalized = cloneJsonValue(schema);
+	if (!isRecord(normalized)) throw new Error("JSON Schema root must normalize to an object.");
+	recurseSchema(normalized);
+	return normalized;
+}
+function hasUnresolvedDefinitionRef(node, bucketKey) {
+	if (Array.isArray(node)) return node.some((child) => hasUnresolvedDefinitionRef(child, bucketKey));
+	if (typeof node === "object" && node !== null) {
+		const obj = node;
+		const ref = obj["$ref"];
+		if (typeof ref === "string" && ref.startsWith(`#/${bucketKey}/`)) return true;
+		for (const [key, value] of Object.entries(obj)) {
+			if (key === bucketKey) continue;
+			if (hasUnresolvedDefinitionRef(value, bucketKey)) return true;
+		}
+		return false;
+	}
+	return false;
+}
+function resolveNode(node, root, visited) {
+	if (Array.isArray(node)) return node.map((item) => resolveNode(item, root, visited));
+	if (typeof node === "object" && node !== null) {
+		const obj = node;
+		if (typeof obj["$ref"] === "string") {
+			const ref = obj["$ref"];
+			if (isLocalJsonPointerRef(ref)) {
+				if (visited.has(ref)) return obj;
+				const resolvedRef = resolveLocalJsonPointer(root, ref);
+				if (resolvedRef.found) {
+					visited.add(ref);
+					const resolved = resolveNode(resolvedRef.value, root, visited);
+					visited.delete(ref);
+					if (typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+						const merged = { ...resolved };
+						for (const [key, value] of Object.entries(obj)) {
+							if (key === "$ref") continue;
+							merged[key] = resolveNode(value, root, visited);
+						}
+						return merged;
+					}
+					return resolved;
+				}
+			}
+			return obj;
+		}
+		const resolved = {};
+		for (const [key, value] of Object.entries(obj)) resolved[key] = resolveNode(value, root, visited);
+		return resolved;
+	}
+	return node;
+}
+function isLocalJsonPointerRef(ref) {
+	return ref === "#" || ref.startsWith("#/");
+}
+function resolveLocalJsonPointer(root, ref) {
+	if (ref === "#") return {
+		found: true,
+		value: root
+	};
+	let current = root;
+	for (const rawPart of ref.slice(2).split("/")) {
+		const part = unescapeJsonPointerPart(rawPart);
+		if (isRecord(current)) {
+			if (!hasOwn(current, part)) return { found: false };
+			current = current[part];
+		} else if (Array.isArray(current)) {
+			const index = parseJsonPointerArrayIndex(part);
+			if (index === null || index >= current.length) return { found: false };
+			current = current[index];
+		} else return { found: false };
+	}
+	return {
+		found: true,
+		value: current
+	};
+}
+function unescapeJsonPointerPart(part) {
+	return part.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function parseJsonPointerArrayIndex(part) {
+	if (!/^(0|[1-9]\d*)$/.test(part)) return null;
+	return Number(part);
+}
+function recurseSchema(node) {
+	if (!isRecord(node)) return;
+	visitChildSchemas(node, normalizeProperty);
+}
+function visitChildSchemas(node, visit) {
+	for (const { key, kind } of CHILD_SCHEMA_SLOTS) {
+		const value = node[key];
+		if (kind === "single") {
+			if (isRecord(value)) visit(value);
+		} else if (kind === "array") {
+			if (Array.isArray(value)) for (const item of value) visit(item);
+		} else if (kind === "map") {
+			if (isRecord(value)) for (const item of Object.values(value)) visit(item);
+		} else if (kind === "schema-or-array") {
+			if (isRecord(value)) visit(value);
+			else if (Array.isArray(value)) for (const item of value) visit(item);
+		}
+	}
+}
+function childSchemaKeysForParentType(parentType) {
+	return CHILD_SCHEMA_SLOTS.flatMap((slot) => {
+		if (!("parentType" in slot) || slot.parentType !== parentType) return [];
+		return [slot.key];
+	});
+}
+function normalizeProperty(node) {
+	if (!isRecord(node)) return;
+	if (!hasOwn(node, "type") && !hasAnyKey(node, TYPE_COMPLETION_SKIP_KEYS)) {
+		const enumValues = node["enum"];
+		if (Array.isArray(enumValues) && enumValues.length > 0) node["type"] = inferTypeFromValues(enumValues);
+		else if (hasOwn(node, "const")) node["type"] = inferTypeFromValues([node["const"]]);
+		else node["type"] = inferTypeFromStructure(node);
+	}
+	recurseSchema(node);
+}
+function inferTypeFromStructure(schema) {
+	if (hasAnyKey(schema, OBJECT_STRUCTURE_KEYS)) return "object";
+	if (hasAnyKey(schema, ARRAY_STRUCTURE_KEYS)) return "array";
+	if (hasAnyKey(schema, STRING_STRUCTURE_KEYS)) return "string";
+	if (hasAnyKey(schema, NUMERIC_STRUCTURE_KEYS)) return "number";
+	return "string";
+}
+function inferTypeFromValues(values) {
+	const inferred = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		const valueType = inferValueType(value);
+		if (valueType === void 0) throw new Error("Cannot infer JSON Schema type from non-JSON enum or const value.");
+		inferred.add(valueType);
+	}
+	const types = normalizeInferredTypes(inferred);
+	if (types.length === 1) {
+		const onlyType = types[0];
+		if (onlyType === void 0) throw new Error("Cannot infer JSON Schema type from an empty enum.");
+		return onlyType;
+	}
+	throw new Error("Mixed JSON Schema enum or const types are not supported by OpenAI-compatible tool schemas.");
+}
+function inferValueType(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	switch (typeof value) {
+		case "string": return "string";
+		case "number": return Number.isInteger(value) ? "integer" : "number";
+		case "boolean": return "boolean";
+		case "object": return "object";
+		case "bigint":
+		case "function":
+		case "symbol":
+		case "undefined": return;
+	}
+}
+function normalizeInferredTypes(types) {
+	const normalized = new Set(types);
+	if (normalized.has("number")) normalized.delete("integer");
+	return [
+		"string",
+		"number",
+		"integer",
+		"boolean",
+		"object",
+		"array",
+		"null"
+	].filter((type) => normalized.has(type));
+}
+function hasAnyKey(obj, keys) {
+	for (const key of keys) if (hasOwn(obj, key)) return true;
+	return false;
+}
+function cloneJsonValue(value) {
+	if (Array.isArray(value)) return value.map((item) => cloneJsonValue(item));
+	if (isRecord(value)) {
+		const cloned = {};
+		for (const [key, child] of Object.entries(value)) cloned[key] = cloneJsonValue(child);
+		return cloned;
+	}
+	return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+//#endregion
+//#region src/providers/openai-compat-files.ts
+/**
+* OpenAI-compatible file upload client.
+*
+* Wraps the underlying OpenAI-compatible `files.create` API to upload videos
+* to the file service and return them as {@link VideoURLPart} values
+* suitable for use in chat messages.
+*
+* An `OpenAICompatFiles` instance is typically obtained from
+* {@link OpenAICompatChatProvider.files}.
+*/
+var OpenAICompatFiles = class {
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_client;
+	_clientFactory;
+	constructor(options) {
+		this._apiKey = options.apiKey;
+		this._baseUrl = options.baseUrl;
+		this._defaultHeaders = options.defaultHeaders;
+		this._clientFactory = options.clientFactory;
+		this._client = options.apiKey === void 0 || options.apiKey.length === 0 ? void 0 : new OpenAI({
+			apiKey: options.apiKey,
+			baseURL: options.baseUrl,
+			defaultHeaders: options.defaultHeaders
+		});
+	}
+	/**
+	* Upload a video file for use in chat messages.
+	*
+	* Accepts either a local filesystem path or an in-memory
+	* {@link VideoUploadInput}. Returns a {@link VideoURLPart} referencing the
+	* uploaded file by its file id.
+	*
+	* @param input - Local path string or `{ data, mimeType }` object.
+	* @returns A `VideoURLPart` whose `url` references the uploaded file
+	*          by its file id (e.g. `ms://<file-id>`).
+	* @throws {ChatProviderError} if the input is not a video or the upload
+	*         fails.
+	*/
+	async uploadVideo(input, options) {
+		let file;
+		if (typeof input === "string") {
+			if (!fs.existsSync(input)) throw new ChatProviderError(`Video file not found: ${input}`);
+			const filename = path.basename(input);
+			const mimeType = guessMimeTypeFromExt(filename);
+			if (mimeType === void 0 || !mimeType.startsWith("video/")) throw new ChatProviderError(`OpenAICompatFiles.uploadVideo: file extension does not indicate a video type: ${filename}`);
+			const data = await fs.promises.readFile(input);
+			const blob = new Blob([new Uint8Array(data)], { type: mimeType });
+			file = new File([blob], filename, { type: mimeType });
+		} else {
+			if (!input.mimeType.startsWith("video/")) throw new ChatProviderError(`Expected a video mime type, got ${input.mimeType}`);
+			const filename = input.filename ?? guessFilename(input.mimeType);
+			const bytes = input.data instanceof Uint8Array ? input.data : new Uint8Array(input.data);
+			const blob = new Blob([bytes], { type: input.mimeType });
+			file = new File([blob], filename, { type: input.mimeType });
+		}
+		let uploaded;
+		try {
+			uploaded = await this._createClient(options?.auth).files.create({
+				file,
+				purpose: "video"
+			}, options?.signal ? { signal: options.signal } : void 0);
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+		return {
+			type: "video_url",
+			videoUrl: {
+				url: `ms://${uploaded.id}`,
+				id: uploaded.id
+			}
+		};
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => {
+			const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, a?.headers);
+			return new OpenAI({
+				apiKey: requireProviderApiKey("OpenAICompatFiles.uploadVideo", a, this._apiKey),
+				baseURL: this._baseUrl,
+				defaultHeaders
+			});
+		});
+	}
+};
+/**
+* Guess a filename for an upload from a video MIME type.
+* Falls back to `upload.bin` for unknown types.
+*/
+function guessFilename(mimeType) {
+	return `upload.${MIME_TO_EXT[mimeType.toLowerCase()] ?? "bin"}`;
+}
+const MIME_TO_EXT = {
+	"video/mp4": "mp4",
+	"video/mpeg": "mpeg",
+	"video/quicktime": "mov",
+	"video/webm": "webm",
+	"video/x-matroska": "mkv",
+	"video/x-msvideo": "avi",
+	"video/x-flv": "flv",
+	"video/3gpp": "3gp"
+};
+const EXT_TO_MIME = Object.fromEntries(Object.entries(MIME_TO_EXT).map(([mime, ext]) => [ext, mime]));
+/**
+* Guess a MIME type from a filename extension. Only recognises the video
+* types listed in {@link MIME_TO_EXT}; returns `undefined` otherwise.
+*/
+function guessMimeTypeFromExt(filename) {
+	const dot = filename.lastIndexOf(".");
+	if (dot < 0) return void 0;
+	return EXT_TO_MIME[filename.slice(dot + 1).toLowerCase()];
+}
+//#endregion
+//#region src/providers/openai-compat.ts
+function isEffectivelyEmptyContent(parts) {
+	for (const part of parts) {
+		if (part.type !== "text") return false;
+		if (part.text.trim() !== "") return false;
+	}
+	return true;
+}
+function convertMessage(message) {
+	let reasoningContent = "";
+	const nonThinkParts = [];
+	for (const part of message.content) if (part.type === "think") reasoningContent += part.think;
+	else nonThinkParts.push(part);
+	const result = { role: message.role };
+	const hasToolCalls = message.toolCalls.length > 0;
+	if (!(message.role === "assistant" && hasToolCalls && isEffectivelyEmptyContent(nonThinkParts))) {
+		const firstPart = nonThinkParts[0];
+		if (nonThinkParts.length === 1 && firstPart?.type === "text") result.content = firstPart.text;
+		else if (nonThinkParts.length > 0) result.content = nonThinkParts.map((p) => convertContentPart(p)).filter((p) => p !== null);
+	}
+	if (message.name !== void 0) result.name = message.name;
+	if (hasToolCalls) result.tool_calls = message.toolCalls.map((tc) => {
+		const mapped = {
+			type: tc.type,
+			id: tc.id,
+			function: {
+				name: tc.name,
+				arguments: tc.arguments
+			}
+		};
+		if (tc.extras !== void 0) mapped.extras = tc.extras;
+		return mapped;
+	});
+	if (message.toolCallId !== void 0) result.tool_call_id = message.toolCallId;
+	if (reasoningContent) result.reasoning_content = reasoningContent;
+	return result;
+}
+function convertTool(tool) {
+	if (tool.name.startsWith("$")) return {
+		type: "builtin_function",
+		function: { name: tool.name }
+	};
+	const converted = toolToOpenAI(tool);
+	return {
+		...converted,
+		function: {
+			...converted.function,
+			parameters: normalizeOpenAICompatToolSchema(tool.parameters)
+		}
+	};
+}
+/**
+* Extract usage from a streaming chunk. Some OpenAI-compatible providers may place usage in
+* `choices[0].usage` in addition to the top-level `usage` field.
+*/
+function extractUsageFromChunk(chunk) {
+	if (chunk["usage"] !== null && chunk["usage"] !== void 0 && typeof chunk["usage"] === "object") return chunk["usage"];
+	const choices = chunk["choices"];
+	if (!Array.isArray(choices) || choices.length === 0) return null;
+	const firstChoice = choices[0];
+	if (firstChoice === void 0) return null;
+	const choiceUsage = firstChoice["usage"];
+	if (choiceUsage !== null && choiceUsage !== void 0 && typeof choiceUsage === "object") return choiceUsage;
+	return null;
+}
+var OpenAICompatStreamedMessage = 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;
+	}
+	_captureFinishReason(raw) {
+		const normalized = normalizeOpenAIFinishReason(raw);
+		this._finishReason = normalized.finishReason;
+		this._rawFinishReason = normalized.rawFinishReason;
+	}
+	async *_convertNonStreamResponse(response) {
+		this._id = response.id;
+		if (response.usage) this._usage = extractUsage(response.usage) ?? null;
+		this._captureFinishReason(response.choices[0]?.finish_reason ?? null);
+		const message = response.choices[0]?.message;
+		if (!message) return;
+		const rc = message["reasoning_content"];
+		if (typeof rc === "string" && rc) yield {
+			type: "think",
+			think: rc
+		};
+		if (message.content) yield {
+			type: "text",
+			text: message.content
+		};
+		if (message.tool_calls) for (const toolCall of message.tool_calls) {
+			if (!isFunctionToolCall(toolCall)) continue;
+			yield {
+				type: "function",
+				id: toolCall.id || crypto.randomUUID(),
+				name: toolCall.function.name,
+				arguments: toolCall.function.arguments
+			};
+		}
+	}
+	async *_convertStreamResponse(response) {
+		const bufferedToolCalls = /* @__PURE__ */ new Map();
+		try {
+			for await (const chunk of response) {
+				if (chunk.id) this._id = chunk.id;
+				const rawUsage = extractUsageFromChunk(chunk);
+				if (rawUsage) this._usage = extractUsage(rawUsage) ?? null;
+				if (!chunk.choices || chunk.choices.length === 0) continue;
+				const choice = chunk.choices[0];
+				if (!choice) continue;
+				if (choice.finish_reason !== null && choice.finish_reason !== void 0) this._captureFinishReason(choice.finish_reason);
+				const delta = choice.delta;
+				const rc = delta["reasoning_content"];
+				if (typeof rc === "string" && rc) yield {
+					type: "think",
+					think: rc
+				};
+				if (delta.content) yield {
+					type: "text",
+					text: delta.content
+				};
+				for (const toolCall of delta.tool_calls ?? []) for (const part of convertChatCompletionStreamToolCall(toolCall, bufferedToolCalls)) yield part;
+			}
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+};
+var OpenAICompatChatProvider = class {
+	name = "openai-compat";
+	_model;
+	_stream;
+	_apiKey;
+	_baseUrl;
+	_defaultHeaders;
+	_generationKwargs;
+	_thinkingEffortKey;
+	_client;
+	_clientFactory;
+	_files;
+	constructor(options) {
+		const apiKey = options.apiKey;
+		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
+		this._baseUrl = options.baseUrl ?? process.env["BYF_BASE_URL"] ?? "";
+		this._defaultHeaders = options.defaultHeaders;
+		this._clientFactory = options.clientFactory;
+		this._model = options.model;
+		this._stream = options.stream ?? true;
+		const normalizedThinkingEffortKey = options.thinkingEffortKey?.trim();
+		this._thinkingEffortKey = normalizedThinkingEffortKey !== void 0 && normalizedThinkingEffortKey.length > 0 ? normalizedThinkingEffortKey : "reasoning_effort";
+		this._generationKwargs = { ...options.generationKwargs };
+		this._client = this._apiKey === void 0 ? void 0 : new OpenAI({
+			apiKey: this._apiKey,
+			baseURL: this._baseUrl,
+			defaultHeaders: this._defaultHeaders
+		});
+	}
+	get modelName() {
+		return this._model;
+	}
+	/**
+	* File upload client for an OpenAI-compatible service.
+	*
+	* Use this to upload videos (and other media in the future) to the file
+	* service and receive a content part that can be embedded in chat
+	* messages.
+	*/
+	get files() {
+		this._files ??= new OpenAICompatFiles({
+			apiKey: this._apiKey,
+			baseUrl: this._baseUrl,
+			defaultHeaders: this._defaultHeaders,
+			clientFactory: this._clientFactory
+		});
+		return this._files;
+	}
+	uploadVideo(input, options) {
+		return this.files.uploadVideo(input, options);
+	}
+	get thinkingEffort() {
+		const customValue = this._generationKwargs[this._thinkingEffortKey];
+		if (typeof customValue === "string") return reasoningEffortToThinkingEffort(customValue);
+		const defaultValue = this._generationKwargs.reasoning_effort;
+		return reasoningEffortToThinkingEffort(defaultValue);
+	}
+	get modelParameters() {
+		return {
+			model: this._model,
+			baseUrl: this._baseUrl,
+			...this._generationKwargs
+		};
+	}
+	async generate(systemPrompt, tools, history, options) {
+		const messages = [];
+		if (systemPrompt) messages.push({
+			role: "system",
+			content: systemPrompt
+		});
+		for (const msg of history) messages.push(convertMessage(msg));
+		const kwargs = { ...this._generationKwargs };
+		for (const key of Object.keys(kwargs)) if (kwargs[key] === void 0) delete kwargs[key];
+		if (kwargs["max_completion_tokens"] === void 0 && kwargs["max_tokens"] !== void 0) kwargs["max_completion_tokens"] = kwargs["max_tokens"];
+		delete kwargs["max_tokens"];
+		const { extra_body: extraBody, ...requestKwargs } = kwargs;
+		const createParams = {
+			model: this._model,
+			messages,
+			stream: this._stream,
+			...requestKwargs,
+			...extraBody
+		};
+		if (tools.length > 0) createParams["tools"] = tools.map((t) => convertTool(t));
+		if (this._stream) createParams["stream_options"] = { include_usage: true };
+		try {
+			return new OpenAICompatStreamedMessage(await this._createClient(options?.auth).chat.completions.create(createParams, options?.signal ? { signal: options.signal } : void 0), this._stream);
+		} catch (error) {
+			throw convertOpenAIError(error);
+		}
+	}
+	getCapability(_model) {
+		return UNKNOWN_CAPABILITY;
+	}
+	withThinking(effort) {
+		const thinking = { type: effort === "off" ? "disabled" : "enabled" };
+		let reasoningEffort;
+		switch (effort) {
+			case "off":
+				reasoningEffort = void 0;
+				break;
+			case "low":
+				reasoningEffort = "low";
+				break;
+			case "medium":
+				reasoningEffort = "medium";
+				break;
+			case "high":
+			case "xhigh":
+			case "max":
+				reasoningEffort = "high";
+				break;
+		}
+		const nextEffort = { [this._thinkingEffortKey]: reasoningEffort };
+		return this._withGenerationKwargs(nextEffort).withExtraBody({ thinking });
+	}
+	withGenerationKwargs(kwargs) {
+		return this._withGenerationKwargs(kwargs);
+	}
+	withMaxCompletionTokens(maxCompletionTokens) {
+		return this._withGenerationKwargs({ max_completion_tokens: maxCompletionTokens });
+	}
+	withExtraBody(extraBody) {
+		const oldExtra = this._generationKwargs.extra_body ?? {};
+		const merged = {
+			...oldExtra,
+			...extraBody
+		};
+		const oldThinking = oldExtra.thinking;
+		const newThinking = extraBody.thinking;
+		if (oldThinking !== void 0 && newThinking !== void 0) merged.thinking = {
+			...oldThinking,
+			...newThinking
+		};
+		return this._withGenerationKwargs({ extra_body: merged });
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => {
+			const defaultHeaders = mergeRequestHeaders(this._defaultHeaders, a?.headers);
+			return new OpenAI({
+				apiKey: requireProviderApiKey("OpenAICompatChatProvider", a, this._apiKey),
+				baseURL: this._baseUrl,
+				defaultHeaders
+			});
+		});
+	}
+	_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 };
+		clone._files = void 0;
+		return clone;
+	}
+};
+//#endregion
+export { extractUsageFromChunk as n, OpenAICompatChatProvider as t };