@revojs/ai 0.1.58

package/dist/protocols/google-models.js

@@ -0,0 +1,331 @@
+import { mergeHeaders, readDataFrames, toStream } from "../index.js";
+import { toJsonSchema } from "revojs/shared";
+//#region src/protocols/google-models.ts
+function toBase64(data) {
+	let binary = "";
+	for (let index = 0; index < data.length; index += 32768) binary += String.fromCharCode(...data.subarray(index, index + 32768));
+	return btoa(binary);
+}
+function toUsage(usage) {
+	const prompt = usage?.promptTokenCount;
+	const candidates = usage?.candidatesTokenCount;
+	const cached = usage?.cachedContentTokenCount;
+	const thoughts = usage?.thoughtsTokenCount;
+	return {
+		inputTokens: {
+			total: prompt,
+			noCache: prompt !== void 0 && cached !== void 0 ? Math.max(0, prompt - cached) : prompt,
+			cacheRead: cached,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: candidates,
+			text: candidates !== void 0 && thoughts !== void 0 ? Math.max(0, candidates - thoughts) : candidates,
+			reasoning: thoughts
+		},
+		raw: usage
+	};
+}
+function toFinishReason(raw, toolCalls) {
+	return {
+		unified: toolCalls ? "tool-calls" : raw === "MAX_TOKENS" ? "length" : raw === "SAFETY" || raw === "BLOCKLIST" || raw === "PROHIBITED_CONTENT" || raw === "SPII" ? "content-filter" : raw === void 0 || raw === "STOP" || raw === "FINISH_REASON_UNSPECIFIED" ? "stop" : "other",
+		raw
+	};
+}
+function toResponseValue(output) {
+	if (output.type === "text" || output.type === "error-text") return { output: output.value };
+	const value = "value" in output ? output.value : void 0;
+	return typeof value === "object" && value !== null ? value : { output: JSON.stringify(value ?? null) };
+}
+function toBody(options) {
+	let system = "";
+	const warnings = [];
+	const contents = [];
+	for (const message of options.prompt) {
+		if (message.role === "system") {
+			system += (system.length > 0 ? "\n" : "") + message.content;
+			continue;
+		}
+		if (message.role === "user") {
+			const parts = message.content.flatMap((part) => {
+				if (part.type === "text") return [{ text: part.text }];
+				if (part.type === "file" && part.data.type === "url") return [{ fileData: {
+					fileUri: part.data.url.toString(),
+					mimeType: part.mediaType
+				} }];
+				if (part.type === "file" && part.data.type === "data" && typeof part.data.data === "string") return [{ inlineData: {
+					mimeType: part.mediaType,
+					data: part.data.data
+				} }];
+				if (part.type === "file" && part.data.type === "data" && typeof part.data.data !== "string") return [{ inlineData: {
+					mimeType: part.mediaType,
+					data: toBase64(part.data.data)
+				} }];
+				warnings.push({
+					type: "unsupported",
+					feature: `user ${part.type === "file" ? `file (${part.mediaType})` : "custom"} message part`
+				});
+				return [];
+			});
+			if (parts.length > 0) contents.push({
+				role: "user",
+				parts
+			});
+			continue;
+		}
+		if (message.role === "tool") {
+			const parts = message.content.flatMap((part) => {
+				if (part.type !== "tool-result") return [];
+				return [{ functionResponse: {
+					name: part.toolName,
+					response: toResponseValue(part.output)
+				} }];
+			});
+			if (parts.length > 0) contents.push({
+				role: "user",
+				parts
+			});
+			continue;
+		}
+		const parts = message.content.flatMap((part) => {
+			if (part.type === "text" && part.text.length > 0) return [{ text: part.text }];
+			if (part.type === "tool-call") {
+				let args = {};
+				try {
+					args = JSON.parse(typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {}));
+				} catch {
+					args = {};
+				}
+				return [{ functionCall: {
+					name: part.toolName,
+					args
+				} }];
+			}
+			if (part.type === "tool-result") return [{ functionResponse: {
+				name: part.toolName,
+				response: toResponseValue(part.output)
+			} }];
+			if (part.type === "reasoning") return [{
+				text: part.text,
+				thought: true
+			}];
+			warnings.push({
+				type: "compatibility",
+				feature: `assistant ${part.type} message part`
+			});
+			return [];
+		});
+		if (parts.length > 0) contents.push({
+			role: "model",
+			parts
+		});
+	}
+	if (options.reasoning === "none") warnings.push({
+		type: "unsupported",
+		feature: "disabling reasoning"
+	});
+	const functionDeclarations = options.tools?.flatMap((tool) => {
+		if (tool.type !== "function") {
+			warnings.push({
+				type: "unsupported",
+				feature: `provider tool ${tool.id}`
+			});
+			return [];
+		}
+		return [{
+			name: tool.name,
+			description: tool.description,
+			parameters: toJsonSchema(tool.inputSchema)
+		}];
+	});
+	return [{
+		...system.length > 0 ? { systemInstruction: { parts: [{ text: system }] } } : {},
+		contents,
+		generationConfig: {
+			...options.maxOutputTokens !== void 0 ? { maxOutputTokens: options.maxOutputTokens } : {},
+			...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+			...options.topP !== void 0 ? { topP: options.topP } : {},
+			...options.topK !== void 0 ? { topK: options.topK } : {},
+			...options.stopSequences !== void 0 ? { stopSequences: options.stopSequences } : {},
+			...options.seed !== void 0 ? { seed: options.seed } : {},
+			...options.responseFormat !== void 0 && options.responseFormat.type === "json" ? {
+				responseMimeType: "application/json",
+				...options.responseFormat.schema !== void 0 ? { responseSchema: toJsonSchema(options.responseFormat.schema) } : {}
+			} : {},
+			...options.reasoning === "none" ? { thinkingConfig: { thinkingBudget: 0 } } : {}
+		},
+		...functionDeclarations !== void 0 && functionDeclarations.length > 0 ? { tools: [{ functionDeclarations }] } : {},
+		...options.toolChoice !== void 0 ? { toolConfig: { functionCallingConfig: {
+			mode: options.toolChoice.type === "tool" ? "ANY" : options.toolChoice.type.toUpperCase(),
+			...options.toolChoice.type === "tool" ? { allowedFunctionNames: [options.toolChoice.toolName] } : {}
+		} } } : {},
+		...options.providerOptions?.google
+	}, warnings];
+}
+function url(config, model, stream) {
+	const base = `${config.baseURL.replace(/\/+$/, "")}/models/${model}`;
+	return stream ? `${base}:streamGenerateContent?alt=sse` : `${base}:generateContent`;
+}
+function headers(config, options) {
+	return {
+		"Content-Type": "application/json",
+		...mergeHeaders(config.apiKey === void 0 ? {} : { "x-goog-api-key": config.apiKey }, options.headers)
+	};
+}
+async function* readParts(response, warnings) {
+	yield {
+		type: "stream-start",
+		warnings
+	};
+	let metadataSent = false;
+	let textStarted = false;
+	let reasoningStarted = false;
+	let toolCount = 0;
+	let toolCalls = false;
+	let finishRaw;
+	let usage;
+	for await (const data of readDataFrames(response)) {
+		let chunk;
+		try {
+			chunk = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		if (chunk.error !== void 0) throw new Error(chunk.error.message ?? "Unknown AI provider error");
+		if (!metadataSent && (chunk.responseId !== void 0 || chunk.modelVersion !== void 0)) {
+			metadataSent = true;
+			yield {
+				type: "response-metadata",
+				id: chunk.responseId,
+				modelId: chunk.modelVersion
+			};
+		}
+		if (chunk.usageMetadata !== void 0) usage = toUsage(chunk.usageMetadata);
+		const candidate = chunk.candidates?.at(0);
+		if (candidate?.finishReason !== void 0) finishRaw = candidate.finishReason;
+		for (const part of candidate?.content?.parts ?? []) {
+			if (part.thought === true && typeof part.text === "string" && part.text.length > 0) {
+				if (!reasoningStarted) {
+					reasoningStarted = true;
+					yield {
+						type: "reasoning-start",
+						id: "gemini-reasoning-0"
+					};
+				}
+				yield {
+					type: "reasoning-delta",
+					id: "gemini-reasoning-0",
+					delta: part.text
+				};
+				continue;
+			}
+			if (part.functionCall !== void 0) {
+				toolCalls = true;
+				yield {
+					type: "tool-call",
+					toolCallId: `gemini-tool-${toolCount++}`,
+					toolName: part.functionCall.name ?? "",
+					input: JSON.stringify(part.functionCall.args ?? {})
+				};
+				continue;
+			}
+			if (typeof part.text === "string" && part.text.length > 0) {
+				if (!textStarted) {
+					textStarted = true;
+					yield {
+						type: "text-start",
+						id: "gemini-text-0"
+					};
+				}
+				yield {
+					type: "text-delta",
+					id: "gemini-text-0",
+					delta: part.text
+				};
+			}
+		}
+	}
+	if (reasoningStarted) yield {
+		type: "reasoning-end",
+		id: "gemini-reasoning-0"
+	};
+	if (textStarted) yield {
+		type: "text-end",
+		id: "gemini-text-0"
+	};
+	yield {
+		type: "finish",
+		usage: usage ?? toUsage(void 0),
+		finishReason: toFinishReason(finishRaw, toolCalls)
+	};
+}
+function geminiGenerateProtocol(config) {
+	return async (options) => {
+		const [body, warnings] = toBody(options);
+		const response = await fetch(url(config, options.model, false), {
+			method: "POST",
+			headers: headers(config, options),
+			body: JSON.stringify(body),
+			signal: options.abortSignal
+		});
+		if (!response.ok) throw new Error(`AI provider responded with ${response.status}: ${(await response.text()).slice(0, 500)}`);
+		const data = await response.json();
+		const content = [];
+		let toolCount = 0;
+		let toolCalls = false;
+		for (const part of data.candidates?.at(0)?.content?.parts ?? []) {
+			if (part.thought === true && typeof part.text === "string" && part.text.length > 0) {
+				content.push({
+					type: "reasoning",
+					text: part.text
+				});
+				continue;
+			}
+			if (part.functionCall !== void 0) {
+				toolCalls = true;
+				content.push({
+					type: "tool-call",
+					toolCallId: `gemini-tool-${toolCount++}`,
+					toolName: part.functionCall.name ?? "",
+					input: JSON.stringify(part.functionCall.args ?? {})
+				});
+				continue;
+			}
+			if (typeof part.text === "string" && part.text.length > 0) content.push({
+				type: "text",
+				text: part.text
+			});
+		}
+		return {
+			content,
+			finishReason: toFinishReason(data.candidates?.at(0)?.finishReason, toolCalls),
+			usage: toUsage(data.usageMetadata),
+			request: { body },
+			response: {
+				id: data.responseId,
+				modelId: data.modelVersion,
+				headers: Object.fromEntries(response.headers.entries())
+			},
+			warnings
+		};
+	};
+}
+function geminiStreamProtocol(config) {
+	return async (options) => {
+		const [body, warnings] = toBody(options);
+		const response = await fetch(url(config, options.model, true), {
+			method: "POST",
+			headers: headers(config, options),
+			body: JSON.stringify(body),
+			signal: options.abortSignal
+		});
+		if (!response.ok) throw new Error(`AI provider responded with ${response.status}: ${(await response.text()).slice(0, 500)}`);
+		return {
+			request: { body },
+			response: { headers: Object.fromEntries(response.headers.entries()) },
+			stream: toStream(() => readParts(response, warnings))
+		};
+	};
+}
+//#endregion
+export { geminiGenerateProtocol, geminiStreamProtocol };

package/dist/protocols/openai-chat-completions.d.ts

@@ -0,0 +1,7 @@
+import { type LanguageModelCallOptions, type LanguageModelGenerateResult, type LanguageModelStreamResult, type Protocol } from "../index";
+export interface ChatCompletionConfig {
+    baseURL: string;
+    apiKey: string | undefined;
+}
+export declare function chatCompletionsGenerateProtocol(config: ChatCompletionConfig): Protocol<LanguageModelCallOptions, LanguageModelGenerateResult>;
+export declare function chatCompletionsStreamProtocol(config: ChatCompletionConfig): Protocol<LanguageModelCallOptions, LanguageModelStreamResult>;

package/dist/protocols/openai-chat-completions.js

@@ -0,0 +1,334 @@
+import { mergeHeaders, readDataFrames, toStream } from "../index.js";
+import { toJsonSchema } from "revojs/shared";
+//#region src/protocols/openai-chat-completions.ts
+function toMessages(prompt) {
+	const wire = [];
+	const warnings = [];
+	for (const message of prompt) {
+		if (message.role === "system") {
+			wire.push({
+				role: "system",
+				content: message.content
+			});
+			continue;
+		}
+		if (message.role === "user") {
+			wire.push({
+				role: "user",
+				content: message.content.flatMap((part) => {
+					if (part.type === "file" && part.data.type === "url") return [{
+						type: "image_url",
+						image_url: { url: part.data.url.toString() }
+					}];
+					if (part.type === "file" && part.data.type === "data" && typeof part.data.data === "string") return [{
+						type: "image_url",
+						image_url: { url: `data:${part.mediaType};base64,${part.data.data}` }
+					}];
+					if (part.type === "text") return [{
+						type: "text",
+						text: part.text
+					}];
+					warnings.push({
+						type: "unsupported",
+						feature: `user ${part.type === "file" ? `file (${part.mediaType})` : "custom"} message part`
+					});
+					return [];
+				})
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+			const calls = message.content.filter((part) => part.type === "tool-call");
+			wire.push({
+				role: "assistant",
+				content: text.length > 0 ? text : null,
+				...calls.length > 0 ? { tool_calls: calls.map((call) => ({
+					id: call.toolCallId,
+					type: "function",
+					function: {
+						name: call.toolName,
+						arguments: call.input
+					}
+				})) } : {}
+			});
+			continue;
+		}
+		for (const part of message.content) {
+			if (part.type !== "tool-result") continue;
+			const value = "value" in part.output ? part.output.value : void 0;
+			wire.push({
+				role: "tool",
+				tool_call_id: part.toolCallId,
+				content: part.output.type === "text" || part.output.type === "error-text" ? part.output.value : JSON.stringify(value ?? null)
+			});
+		}
+	}
+	return [wire, warnings];
+}
+function toBody(config, options, stream) {
+	const [messages, warnings] = toMessages(options.prompt);
+	return [
+		{
+			model: options.model,
+			messages,
+			...stream ? {
+				stream: true,
+				stream_options: { include_usage: true }
+			} : {},
+			...options.maxOutputTokens !== void 0 ? { max_completion_tokens: options.maxOutputTokens } : {},
+			...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+			...options.topP !== void 0 ? { top_p: options.topP } : {},
+			...options.stopSequences !== void 0 ? { stop: options.stopSequences } : {},
+			...options.seed !== void 0 ? { seed: options.seed } : {},
+			...options.presencePenalty !== void 0 ? { presence_penalty: options.presencePenalty } : {},
+			...options.frequencyPenalty !== void 0 ? { frequency_penalty: options.frequencyPenalty } : {},
+			...options.tools !== void 0 && options.tools.length > 0 ? { tools: options.tools.map((tool) => tool.type === "provider" ? {
+				type: tool.id,
+				[tool.name]: tool.args
+			} : {
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: toJsonSchema(tool.inputSchema),
+					strict: tool.strict
+				}
+			}) } : {},
+			...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice.type === "tool" ? {
+				type: "function",
+				function: { name: options.toolChoice.toolName }
+			} : options.toolChoice.type } : {},
+			...options.responseFormat !== void 0 ? { response_format: options.responseFormat.type === "json" ? options.responseFormat.schema === void 0 ? { type: "json_object" } : {
+				type: "json_schema",
+				json_schema: {
+					name: options.responseFormat.name ?? "response",
+					description: options.responseFormat.description,
+					schema: toJsonSchema(options.responseFormat.schema)
+				}
+			} : { type: "text" } } : {},
+			...options.reasoning !== void 0 && options.reasoning !== "provider-default" ? { reasoning_effort: options.reasoning } : {},
+			...options.providerOptions?.openai
+		},
+		warnings,
+		`${config.baseURL.replace(/\/+$/, "")}/chat/completions`
+	];
+}
+function toUsage(chunk) {
+	return {
+		inputTokens: {
+			total: chunk?.prompt_tokens,
+			noCache: chunk?.prompt_tokens,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: chunk?.completion_tokens,
+			text: chunk?.completion_tokens_details?.reasoning_tokens === void 0 ? chunk?.completion_tokens : void 0,
+			reasoning: chunk?.completion_tokens_details?.reasoning_tokens
+		},
+		raw: chunk
+	};
+}
+function toFinishReason(raw) {
+	if (raw === "length" || raw === "max_tokens") return {
+		unified: "length",
+		raw
+	};
+	if (raw === "tool_calls") return {
+		unified: "tool-calls",
+		raw
+	};
+	if (raw === "content_filter") return {
+		unified: "content-filter",
+		raw
+	};
+	return {
+		unified: "stop",
+		raw: raw ?? void 0
+	};
+}
+async function* readParts(response, warnings) {
+	yield {
+		type: "stream-start",
+		warnings
+	};
+	const tools = /* @__PURE__ */ new Map();
+	let metadataSent = false;
+	let textStarted = false;
+	let reasoningStarted = false;
+	let finishRaw;
+	let usage;
+	for await (const data of readDataFrames(response)) {
+		if (data === "[DONE]") break;
+		let chunk;
+		try {
+			chunk = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		if (!metadataSent) {
+			metadataSent = true;
+			yield {
+				type: "response-metadata",
+				id: chunk.id,
+				modelId: chunk.model
+			};
+		}
+		if (chunk.usage !== void 0) usage = toUsage(chunk.usage);
+		const choice = chunk.choices?.at(0);
+		if (typeof choice?.finish_reason === "string") finishRaw = choice.finish_reason;
+		const delta = choice?.delta;
+		if (delta === void 0) continue;
+		const thinking = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
+		if (thinking.length > 0) {
+			if (!reasoningStarted) {
+				reasoningStarted = true;
+				yield {
+					type: "reasoning-start",
+					id: "openai-reasoning-0"
+				};
+			}
+			yield {
+				type: "reasoning-delta",
+				id: "openai-reasoning-0",
+				delta: thinking
+			};
+		}
+		if (typeof delta.content === "string" && delta.content.length > 0) {
+			if (!textStarted) {
+				textStarted = true;
+				yield {
+					type: "text-start",
+					id: "openai-text-0"
+				};
+			}
+			yield {
+				type: "text-delta",
+				id: "openai-text-0",
+				delta: delta.content
+			};
+		}
+		for (const partial of delta.tool_calls ?? []) {
+			const index = partial.index ?? 0;
+			let accumulator = tools.get(index);
+			if (accumulator === void 0) {
+				accumulator = {
+					streamId: `openai-tool-${index}`,
+					callId: partial.id ?? "",
+					name: partial.function?.name ?? "",
+					arguments: ""
+				};
+				tools.set(index, accumulator);
+				yield {
+					type: "tool-input-start",
+					id: accumulator.streamId,
+					toolName: accumulator.name
+				};
+			}
+			if (partial.id !== void 0 && partial.id !== accumulator.callId) accumulator.callId = partial.id;
+			if (partial.function?.name !== void 0) accumulator.name += partial.function.name;
+			if (partial.function?.arguments !== void 0) {
+				accumulator.arguments += partial.function.arguments;
+				yield {
+					type: "tool-input-delta",
+					id: accumulator.streamId,
+					delta: partial.function.arguments
+				};
+			}
+		}
+	}
+	if (reasoningStarted) yield {
+		type: "reasoning-end",
+		id: "openai-reasoning-0"
+	};
+	if (textStarted) yield {
+		type: "text-end",
+		id: "openai-text-0"
+	};
+	for (const [, accumulator] of [...tools.entries()].sort(([left], [right]) => left - right)) {
+		yield {
+			type: "tool-input-end",
+			id: accumulator.streamId
+		};
+		if (accumulator.callId.length > 0 || accumulator.name.length > 0) yield {
+			type: "tool-call",
+			toolCallId: accumulator.callId.length > 0 ? accumulator.callId : accumulator.streamId,
+			toolName: accumulator.name,
+			input: accumulator.arguments
+		};
+	}
+	yield {
+		type: "finish",
+		usage: usage ?? toUsage(void 0),
+		finishReason: toFinishReason(finishRaw)
+	};
+}
+function chatCompletionsGenerateProtocol(config) {
+	return async (options) => {
+		const [body, warnings, url] = toBody(config, options, false);
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...mergeHeaders(config.apiKey === void 0 ? {} : { Authorization: `Bearer ${config.apiKey}` }, options.headers)
+			},
+			body: JSON.stringify(body),
+			signal: options.abortSignal
+		});
+		if (!response.ok) throw new Error(`AI provider responded with ${response.status}: ${(await response.text()).slice(0, 500)}`);
+		const chunk = await response.json();
+		const choice = chunk.choices?.at(0);
+		if (choice?.message === void 0) throw new Error("AI provider responded without choices");
+		const reasoning = typeof choice.message.reasoning_content === "string" ? choice.message.reasoning_content : typeof choice.message.reasoning === "string" ? choice.message.reasoning : "";
+		const content = [];
+		if (reasoning.length > 0) content.push({
+			type: "reasoning",
+			text: reasoning
+		});
+		if (typeof choice.message.content === "string" && choice.message.content.length > 0) content.push({
+			type: "text",
+			text: choice.message.content
+		});
+		for (const call of choice.message.tool_calls ?? []) content.push({
+			type: "tool-call",
+			toolCallId: call.id ?? "",
+			toolName: call.function?.name ?? "",
+			input: call.function?.arguments ?? ""
+		});
+		return {
+			content,
+			finishReason: toFinishReason(choice.finish_reason),
+			usage: toUsage(chunk.usage),
+			request: { body },
+			response: {
+				id: chunk.id,
+				modelId: chunk.model,
+				headers: Object.fromEntries(response.headers.entries())
+			},
+			warnings
+		};
+	};
+}
+function chatCompletionsStreamProtocol(config) {
+	return async (options) => {
+		const [body, warnings, url] = toBody(config, options, true);
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...mergeHeaders(config.apiKey === void 0 ? {} : { Authorization: `Bearer ${config.apiKey}` }, options.headers)
+			},
+			body: JSON.stringify(body),
+			signal: options.abortSignal
+		});
+		if (!response.ok) throw new Error(`AI provider responded with ${response.status}: ${(await response.text()).slice(0, 500)}`);
+		return {
+			request: { body },
+			response: { headers: Object.fromEntries(response.headers.entries()) },
+			stream: toStream(() => readParts(response, warnings))
+		};
+	};
+}
+//#endregion
+export { chatCompletionsGenerateProtocol, chatCompletionsStreamProtocol };

package/dist/protocols/openai-responses.d.ts

@@ -0,0 +1,7 @@
+import { type LanguageModelCallOptions, type LanguageModelGenerateResult, type LanguageModelStreamResult, type Protocol } from "../index";
+export interface ResponsesConfig {
+    baseURL: string;
+    apiKey: string | undefined;
+}
+export declare function responsesGenerateProtocol(config: ResponsesConfig): Protocol<LanguageModelCallOptions, LanguageModelGenerateResult>;
+export declare function responsesStreamProtocol(config: ResponsesConfig): Protocol<LanguageModelCallOptions, LanguageModelStreamResult>;