@byfriends/kosong 0.1.0

package/dist/providers/google-genai.d.mts

@@ -0,0 +1,2 @@
+import { a as convertGoogleGenAIError, i as GoogleGenAIStreamedMessage, n as GoogleGenAIGenerationKwargs, o as messagesToGoogleGenAIContents, r as GoogleGenAIOptions, t as GoogleGenAIChatProvider } from "../google-genai-hX0X6CF3.mjs";
+export { GoogleGenAIChatProvider, GoogleGenAIGenerationKwargs, GoogleGenAIOptions, GoogleGenAIStreamedMessage, convertGoogleGenAIError, messagesToGoogleGenAIContents };

package/dist/providers/google-genai.mjs

@@ -0,0 +1,562 @@
+import { a as APITimeoutError, o as ChatProviderError, s as normalizeAPIStatusError, t as APIConnectionError } from "../errors-WFxxzL1B.mjs";
+import { n as requireProviderApiKey, r as resolveAuthBackedClient } from "../request-auth-DCWSyCKI.mjs";
+import { n as getGoogleGenAIModelCapability } from "../capability-registry-CMBuEYcf.mjs";
+import { ApiError, GoogleGenAI } from "@google/genai";
+//#region src/providers/google-genai.ts
+/**
+* Normalize a Google GenAI (Gemini) `finishReason` value to the unified
+* {@link FinishReason} enum.
+*
+* Source: `candidates[0].finishReason` (works for both stream and
+* non-stream — the SDK normalizes them). Gemini does not emit a
+* `tool_calls`-style reason; tool calls come via `parts[].functionCall`
+* and `finishReason` stays `'completed'` even when the model produces
+* function calls.
+*/
+function normalizeGoogleGenAIFinishReason(raw) {
+	if (raw === null || raw === void 0) return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	let rawString;
+	if (typeof raw === "string") rawString = raw.toUpperCase();
+	else if (typeof raw === "number" || typeof raw === "bigint" || typeof raw === "boolean") rawString = String(raw).toUpperCase();
+	else return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	if (rawString === "FINISH_REASON_UNSPECIFIED" || rawString === "") return {
+		finishReason: null,
+		rawFinishReason: null
+	};
+	switch (rawString) {
+		case "STOP": return {
+			finishReason: "completed",
+			rawFinishReason: rawString
+		};
+		case "MAX_TOKENS": return {
+			finishReason: "truncated",
+			rawFinishReason: rawString
+		};
+		case "SAFETY":
+		case "RECITATION":
+		case "BLOCKLIST":
+		case "PROHIBITED_CONTENT":
+		case "SPII":
+		case "IMAGE_SAFETY": return {
+			finishReason: "filtered",
+			rawFinishReason: rawString
+		};
+		case "MALFORMED_FUNCTION_CALL":
+		case "OTHER":
+		case "LANGUAGE": return {
+			finishReason: "other",
+			rawFinishReason: rawString
+		};
+		default: return {
+			finishReason: "other",
+			rawFinishReason: rawString
+		};
+	}
+}
+function toolToGoogleGenAI(tool) {
+	return { function_declarations: [{
+		name: tool.name,
+		description: tool.description,
+		parameters_json_schema: tool.parameters
+	}] };
+}
+function toolCallIdToName(toolCallId, toolNameById) {
+	const name = toolNameById.get(toolCallId);
+	if (name !== void 0) return name;
+	return /^(.+)_[^_]+$/.exec(toolCallId)?.[1] ?? toolCallId;
+}
+/**
+* Convert a data URL or HTTP URL to a Google GenAI inline/file data part.
+* - data: URLs are parsed into { inlineData: { mimeType, data } }
+* - http(s): URLs use { fileData: { fileUri, mimeType } }
+*/
+function convertMediaUrl(url, fallbackMimeType) {
+	if (url.startsWith("data:")) {
+		const commaIndex = url.indexOf(",");
+		if (commaIndex === -1) return { fileData: {
+			fileUri: url,
+			mimeType: fallbackMimeType
+		} };
+		const meta = url.slice(0, commaIndex);
+		const data = url.slice(commaIndex + 1);
+		const colonIndex = meta.indexOf(":");
+		const semiIndex = meta.indexOf(";");
+		return { inlineData: {
+			mimeType: colonIndex !== -1 && semiIndex !== -1 ? meta.slice(colonIndex + 1, semiIndex) : fallbackMimeType,
+			data
+		} };
+	}
+	let mimeType = fallbackMimeType;
+	try {
+		const pathname = new URL(url).pathname.toLowerCase();
+		if (pathname.endsWith(".png")) mimeType = "image/png";
+		else if (pathname.endsWith(".jpg") || pathname.endsWith(".jpeg")) mimeType = "image/jpeg";
+		else if (pathname.endsWith(".gif")) mimeType = "image/gif";
+		else if (pathname.endsWith(".webp")) mimeType = "image/webp";
+		else if (pathname.endsWith(".mp3") || pathname.endsWith(".mpeg")) mimeType = "audio/mpeg";
+		else if (pathname.endsWith(".wav")) mimeType = "audio/wav";
+		else if (pathname.endsWith(".ogg")) mimeType = "audio/ogg";
+	} catch {}
+	return { fileData: {
+		fileUri: url,
+		mimeType
+	} };
+}
+function createAbortError() {
+	return new DOMException("The operation was aborted.", "AbortError");
+}
+async function abortPromise(signal) {
+	if (signal === void 0) return new Promise(() => {});
+	if (signal.aborted) throw createAbortError();
+	return new Promise((_, reject) => {
+		signal.addEventListener("abort", () => {
+			reject(createAbortError());
+		}, { once: true });
+	});
+}
+function messageToGoogleGenAI(message) {
+	if (message.role === "tool") throw new ChatProviderError("Tool messages must be converted via messagesToGoogleGenAIContents.");
+	const role = message.role === "assistant" ? "model" : message.role;
+	const parts = [];
+	for (const part of message.content) switch (part.type) {
+		case "text":
+			parts.push({ text: part.text });
+			break;
+		case "think": break;
+		case "image_url":
+			parts.push(convertMediaUrl(part.imageUrl.url, "image/jpeg"));
+			break;
+		case "audio_url":
+			parts.push(convertMediaUrl(part.audioUrl.url, "audio/mpeg"));
+			break;
+		case "video_url":
+			parts.push(convertMediaUrl(part.videoUrl.url, "video/mp4"));
+			break;
+	}
+	for (const toolCall of message.toolCalls) {
+		let args = {};
+		if (toolCall.arguments) try {
+			const parsed = JSON.parse(toolCall.arguments);
+			if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) args = parsed;
+			else throw new ChatProviderError("Tool call arguments must be a JSON object.");
+		} catch (error) {
+			if (error instanceof ChatProviderError) throw error;
+			throw new ChatProviderError("Tool call arguments must be valid JSON.");
+		}
+		const functionCallPart = { function_call: {
+			name: toolCall.name,
+			args
+		} };
+		if (toolCall.extras && "thought_signature_b64" in toolCall.extras) functionCallPart["thought_signature"] = toolCall.extras["thought_signature_b64"];
+		parts.push(functionCallPart);
+	}
+	return {
+		role,
+		parts
+	};
+}
+/**
+* Convert a tool message into a list of Google GenAI parts.
+*
+* Returns a `functionResponse` part carrying the text output, followed by
+* independent media parts (`inlineData` / `fileData`) for any image/audio/video
+* content in the tool result. This preserves multimodal tool outputs so the
+* next Gemini/Vertex turn can see them — returning only the text would silently
+* drop media and break tool chains that rely on images or audio.
+*/
+function toolMessageToFunctionResponseParts(message, toolNameById) {
+	if (message.role !== "tool") throw new ChatProviderError("Expected a tool message.");
+	if (message.toolCallId === void 0) throw new ChatProviderError("Tool response is missing `toolCallId`.");
+	let textOutput = "";
+	const mediaParts = [];
+	for (const part of message.content) switch (part.type) {
+		case "text":
+			if (part.text) textOutput += part.text;
+			break;
+		case "image_url":
+			mediaParts.push(convertMediaUrl(part.imageUrl.url, "image/jpeg"));
+			break;
+		case "audio_url":
+			mediaParts.push(convertMediaUrl(part.audioUrl.url, "audio/mpeg"));
+			break;
+		case "video_url":
+			mediaParts.push(convertMediaUrl(part.videoUrl.url, "video/mp4"));
+			break;
+		case "think": break;
+	}
+	return [{ function_response: {
+		name: toolCallIdToName(message.toolCallId, toolNameById),
+		response: { output: textOutput },
+		parts: []
+	} }, ...mediaParts];
+}
+function messagesToGoogleGenAIContents(messages) {
+	const contents = [];
+	const toolNameById = /* @__PURE__ */ new Map();
+	let i = 0;
+	while (i < messages.length) {
+		const message = messages[i];
+		if (message === void 0) break;
+		if (message.role === "system") {
+			const text = message.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+			if (text.length > 0) contents.push({
+				role: "user",
+				parts: [{ text: `<system>${text}</system>` }]
+			});
+			i += 1;
+			continue;
+		}
+		if (message.role === "assistant" && message.toolCalls.length > 0) {
+			contents.push(messageToGoogleGenAI(message));
+			const expectedToolCallIds = [];
+			for (const toolCall of message.toolCalls) {
+				toolNameById.set(toolCall.id, toolCall.name);
+				expectedToolCallIds.push(toolCall.id);
+			}
+			let j = i + 1;
+			const toolMessages = [];
+			while (j < messages.length) {
+				const toolMsg = messages[j];
+				if (toolMsg === void 0 || toolMsg.role !== "tool") break;
+				toolMessages.push(toolMsg);
+				j += 1;
+			}
+			if (toolMessages.length > 0) {
+				const toolMsgById = /* @__PURE__ */ new Map();
+				const seenToolCallIds = /* @__PURE__ */ new Set();
+				for (const toolMsg of toolMessages) {
+					if (toolMsg.toolCallId === void 0) throw new ChatProviderError("Tool response is missing `toolCallId`.");
+					if (seenToolCallIds.has(toolMsg.toolCallId)) throw new ChatProviderError(`Duplicate tool response for id: ${toolMsg.toolCallId}`);
+					seenToolCallIds.add(toolMsg.toolCallId);
+					toolMsgById.set(toolMsg.toolCallId, toolMsg);
+				}
+				const sortedToolMessages = [];
+				for (const expectedId of expectedToolCallIds) {
+					const msg = toolMsgById.get(expectedId);
+					if (msg === void 0) throw new ChatProviderError(`Missing tool responses for ids: ${expectedId}`);
+					sortedToolMessages.push(msg);
+					toolMsgById.delete(expectedId);
+				}
+				if (toolMsgById.size > 0) throw new ChatProviderError(`Unexpected tool responses for ids: ${JSON.stringify([...toolMsgById.keys()])}`);
+				const parts = [];
+				for (const toolMsg of sortedToolMessages) parts.push(...toolMessageToFunctionResponseParts(toolMsg, toolNameById));
+				contents.push({
+					role: "user",
+					parts
+				});
+				i = j;
+				continue;
+			}
+			i += 1;
+			continue;
+		}
+		if (message.role === "tool") {
+			const parts = toolMessageToFunctionResponseParts(message, toolNameById);
+			contents.push({
+				role: "user",
+				parts
+			});
+			i += 1;
+			continue;
+		}
+		contents.push(messageToGoogleGenAI(message));
+		i += 1;
+	}
+	return contents;
+}
+var GoogleGenAIStreamedMessage = class {
+	_id = null;
+	_usage = null;
+	_finishReason = null;
+	_rawFinishReason = null;
+	_iter;
+	constructor(response, isStream, signal) {
+		if (isStream) this._iter = this._convertStreamResponse(response, signal);
+		else this._iter = this._convertNonStreamResponse(response, signal);
+	}
+	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(response) {
+		const candidates = response["candidates"];
+		if (!candidates || candidates.length === 0) return;
+		const first = candidates[0];
+		if (first === void 0) return;
+		const raw = first["finishReason"] ?? first["finish_reason"];
+		if (raw === void 0) return;
+		const normalized = normalizeGoogleGenAIFinishReason(raw);
+		if (normalized.finishReason !== null || normalized.rawFinishReason !== null) {
+			this._finishReason = normalized.finishReason;
+			this._rawFinishReason = normalized.rawFinishReason;
+		}
+	}
+	/** Yield parts from a single (non-streamed) GenerateContentResponse. */
+	_extractChunkParts(response) {
+		const parts = [];
+		const candidates = response["candidates"];
+		for (const candidate of candidates ?? []) {
+			const contentParts = candidate["content"]?.["parts"];
+			if (!contentParts) continue;
+			for (const part of contentParts) {
+				const p = part;
+				if (p["thought"] === true && p["text"]) parts.push({
+					type: "think",
+					think: p["text"]
+				});
+				else if (p["text"]) parts.push({
+					type: "text",
+					text: p["text"]
+				});
+				else if (p["functionCall"] || p["function_call"]) {
+					const fc = p["functionCall"] ?? p["function_call"];
+					const name = fc["name"];
+					if (!name) continue;
+					const toolCallId = `${name}_${fc["id"] ?? crypto.randomUUID()}`;
+					const thoughtSigB64 = p["thoughtSignature"] ?? p["thought_signature"];
+					parts.push({
+						type: "function",
+						id: toolCallId,
+						name,
+						arguments: fc["args"] ? JSON.stringify(fc["args"]) : "{}",
+						...thoughtSigB64 ? { extras: { thought_signature_b64: thoughtSigB64 } } : {}
+					});
+				}
+			}
+		}
+		return parts;
+	}
+	/** Extract usage metadata from a response chunk. */
+	_extractUsage(response) {
+		const usageMetadata = response["usageMetadata"];
+		if (usageMetadata) {
+			const promptTokenCount = typeof usageMetadata["promptTokenCount"] === "number" ? usageMetadata["promptTokenCount"] : 0;
+			const cachedContentTokenCount = typeof usageMetadata["cachedContentTokenCount"] === "number" ? usageMetadata["cachedContentTokenCount"] : 0;
+			this._usage = {
+				inputOther: Math.max(promptTokenCount - cachedContentTokenCount, 0),
+				output: usageMetadata["candidatesTokenCount"] ?? 0,
+				inputCacheRead: cachedContentTokenCount,
+				inputCacheCreation: 0
+			};
+		}
+	}
+	/** Extract response ID from a response chunk. */
+	_extractId(response) {
+		if (response["responseId"] !== void 0) this._id = response["responseId"];
+	}
+	_throwIfAborted(signal) {
+		if (signal !== void 0 && signal.aborted) throw createAbortError();
+	}
+	async *_convertNonStreamResponse(response, signal) {
+		this._throwIfAborted(signal);
+		this._extractUsage(response);
+		this._extractId(response);
+		this._captureFinishReason(response);
+		for (const part of this._extractChunkParts(response)) {
+			this._throwIfAborted(signal);
+			yield part;
+		}
+	}
+	async *_convertStreamResponse(response, signal) {
+		try {
+			for await (const chunk of response) {
+				this._throwIfAborted(signal);
+				this._extractUsage(chunk);
+				this._extractId(chunk);
+				this._captureFinishReason(chunk);
+				for (const part of this._extractChunkParts(chunk)) {
+					this._throwIfAborted(signal);
+					yield part;
+				}
+			}
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") throw error;
+			throw convertGoogleGenAIError(error);
+		}
+	}
+};
+const NETWORK_RE = /network|connection|connect|disconnect|fetch failed/i;
+const TIMEOUT_RE = /timed?\s*out|timeout|deadline/i;
+/**
+* Convert a Google GenAI SDK error (or raw Error) to a kosong `ChatProviderError`.
+*/
+function convertGoogleGenAIError(error) {
+	if (error instanceof ApiError) return normalizeAPIStatusError(error.status, error.message);
+	if (error instanceof Error) {
+		const msg = error.message;
+		if (TIMEOUT_RE.test(msg)) return new APITimeoutError(msg);
+		if (NETWORK_RE.test(msg) || error instanceof TypeError && msg.includes("fetch")) return new APIConnectionError(msg);
+		const statusCode = error.code;
+		if (typeof statusCode === "number") return normalizeAPIStatusError(statusCode, msg);
+		return new ChatProviderError(`GoogleGenAI error: ${msg}`);
+	}
+	return new ChatProviderError(`GoogleGenAI error: ${String(error)}`);
+}
+var GoogleGenAIChatProvider = class {
+	name = "google_genai";
+	_model;
+	_client;
+	_generationKwargs;
+	_vertexai;
+	_stream;
+	_apiKey;
+	_project;
+	_location;
+	_clientFactory;
+	constructor(options) {
+		this._model = options.model;
+		this._vertexai = options.vertexai ?? false;
+		this._stream = options.stream ?? true;
+		this._generationKwargs = {};
+		const apiKey = options.apiKey ?? process.env["GOOGLE_API_KEY"];
+		this._apiKey = apiKey === void 0 || apiKey.length === 0 ? void 0 : apiKey;
+		this._project = options.project;
+		this._location = options.location;
+		this._clientFactory = options.clientFactory;
+		this._client = this._vertexai || this._apiKey !== void 0 ? this._buildClient(this._apiKey) : void 0;
+	}
+	_buildClient(apiKey) {
+		return new GoogleGenAI({
+			apiKey,
+			...this._vertexai ? {
+				vertexai: true,
+				project: this._project,
+				location: this._location
+			} : {}
+		});
+	}
+	get modelName() {
+		return this._model;
+	}
+	get thinkingEffort() {
+		const thinkingConfig = this._generationKwargs.thinking_config;
+		if (thinkingConfig === void 0) return null;
+		if (thinkingConfig.thinking_level !== void 0) switch (thinkingConfig.thinking_level) {
+			case "MINIMAL": return thinkingConfig.include_thoughts === false ? "off" : "low";
+			case "LOW": return "low";
+			case "MEDIUM": return "medium";
+			case "HIGH": return "high";
+			default: return null;
+		}
+		if (thinkingConfig.thinking_budget !== void 0) {
+			if (thinkingConfig.thinking_budget === 0) return "off";
+			if (thinkingConfig.thinking_budget <= 1024) return "low";
+			if (thinkingConfig.thinking_budget <= 4096) return "medium";
+			return "high";
+		}
+		return null;
+	}
+	get modelParameters() {
+		return {
+			model: this._model,
+			...this._generationKwargs
+		};
+	}
+	getCapability(model) {
+		return getGoogleGenAIModelCapability(model ?? this._model);
+	}
+	async generate(systemPrompt, tools, history, options) {
+		if (options?.signal?.aborted === true) throw createAbortError();
+		const contents = messagesToGoogleGenAIContents(history);
+		const config = {
+			...this._generationKwargs,
+			system_instruction: systemPrompt,
+			...tools.length > 0 ? { tools: tools.map((t) => toolToGoogleGenAI(t)) } : {}
+		};
+		try {
+			const models = this._createClient(options?.auth).models;
+			const params = {
+				model: this._model,
+				contents,
+				config
+			};
+			if (this._stream) return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContentStream(params), abortPromise(options?.signal)]), true, options?.signal);
+			return new GoogleGenAIStreamedMessage(await Promise.race([models.generateContent(params), abortPromise(options?.signal)]), false, options?.signal);
+		} catch (error) {
+			if (error instanceof DOMException && error.name === "AbortError") throw error;
+			throw convertGoogleGenAIError(error);
+		}
+	}
+	_createClient(auth) {
+		return resolveAuthBackedClient({
+			cachedClient: this._client,
+			clientFactory: this._clientFactory
+		}, auth, (a) => {
+			if (this._vertexai) return this._buildClient(this._apiKey);
+			return this._buildClient(requireProviderApiKey("GoogleGenAIChatProvider", a, this._apiKey));
+		});
+	}
+	withThinking(effort) {
+		const thinkingConfig = { include_thoughts: true };
+		if (this._model.includes("gemini-3")) switch (effort) {
+			case "off":
+				thinkingConfig.thinking_level = "MINIMAL";
+				thinkingConfig.include_thoughts = false;
+				break;
+			case "low":
+				thinkingConfig.thinking_level = "LOW";
+				break;
+			case "medium":
+				thinkingConfig.thinking_level = "MEDIUM";
+				break;
+			case "high":
+			case "xhigh":
+			case "max":
+				thinkingConfig.thinking_level = "HIGH";
+				break;
+		}
+		else switch (effort) {
+			case "off":
+				thinkingConfig.thinking_budget = 0;
+				thinkingConfig.include_thoughts = false;
+				break;
+			case "low":
+				thinkingConfig.thinking_budget = 1024;
+				thinkingConfig.include_thoughts = true;
+				break;
+			case "medium":
+				thinkingConfig.thinking_budget = 4096;
+				thinkingConfig.include_thoughts = true;
+				break;
+			case "high":
+			case "xhigh":
+			case "max":
+				thinkingConfig.thinking_budget = 32e3;
+				thinkingConfig.include_thoughts = true;
+				break;
+		}
+		return this.withGenerationKwargs({ thinking_config: thinkingConfig });
+	}
+	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;
+	}
+};
+//#endregion
+export { GoogleGenAIChatProvider, GoogleGenAIStreamedMessage, convertGoogleGenAIError, messagesToGoogleGenAIContents };

package/dist/providers/openai-common.d.mts

@@ -0,0 +1,2 @@
+import { a as convertContentPart, c as extractUsage, d as reasoningEffortToThinkingEffort, f as thinkingEffortToReasoningEffort, i as ToolMessageConversion, l as isFunctionToolCall, n as OpenAIContentPart, o as convertOpenAIError, p as toolToOpenAI, r as OpenAIToolParam, s as convertToolMessageContent, t as FunctionToolCallShape, u as normalizeOpenAIFinishReason } from "../openai-common-B6cK2ig3.mjs";
+export { FunctionToolCallShape, OpenAIContentPart, OpenAIToolParam, ToolMessageConversion, convertContentPart, convertOpenAIError, convertToolMessageContent, extractUsage, isFunctionToolCall, normalizeOpenAIFinishReason, reasoningEffortToThinkingEffort, thinkingEffortToReasoningEffort, toolToOpenAI };

package/dist/providers/openai-common.mjs

@@ -0,0 +1,2 @@
+import { a as isFunctionToolCall, c as thinkingEffortToReasoningEffort, i as extractUsage, l as toolToOpenAI, n as convertOpenAIError, o as normalizeOpenAIFinishReason, r as convertToolMessageContent, s as reasoningEffortToThinkingEffort, t as convertContentPart } from "../openai-common-08qin3UI.mjs";
+export { convertContentPart, convertOpenAIError, convertToolMessageContent, extractUsage, isFunctionToolCall, normalizeOpenAIFinishReason, reasoningEffortToThinkingEffort, thinkingEffortToReasoningEffort, toolToOpenAI };

package/dist/providers/openai-compat.d.mts

@@ -0,0 +1,2 @@
+import { a as ThinkingConfig, i as OpenAICompatOptions, n as GenerationKwargs, o as extractUsageFromChunk, r as OpenAICompatChatProvider, t as ExtraBody } from "../openai-compat-CMrIk-ib.mjs";
+export { ExtraBody, GenerationKwargs, OpenAICompatChatProvider, OpenAICompatOptions, ThinkingConfig, extractUsageFromChunk };

package/dist/providers/openai-compat.mjs

@@ -0,0 +1,2 @@
+import { n as extractUsageFromChunk, t as OpenAICompatChatProvider } from "../openai-compat-CWbwO4b7.mjs";
+export { OpenAICompatChatProvider, extractUsageFromChunk };

package/dist/providers/openai-legacy.d.mts

@@ -0,0 +1,2 @@
+import { i as OpenAILegacyStreamedMessage, n as OpenAILegacyGenerationKwargs, r as OpenAILegacyOptions, t as OpenAILegacyChatProvider } from "../openai-legacy-B6CVfLlr.mjs";
+export { OpenAILegacyChatProvider, OpenAILegacyGenerationKwargs, OpenAILegacyOptions, OpenAILegacyStreamedMessage };