@byfriends/kosong 0.1.0 → 0.2.0

package/dist/openai-compat-CWbwO4b7.mjs

@@ -1,801 +0,0 @@
-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 };