@revojs/ai 0.1.58

package/dist/module/index.js

@@ -0,0 +1,47 @@
+import { defineModule, useModule } from "revojs/module";
+//#region src/module/index.ts
+var module_default = defineModule({
+	name: "ai",
+	config: () => ({}),
+	setup() {
+		const { fromModule } = useModule(import.meta.url);
+		return {
+			variables: { server: {
+				anthropicApiKey: {
+					type: "string",
+					optional: true
+				},
+				deepseekApiKey: {
+					type: "string",
+					optional: true
+				},
+				googleApiKey: {
+					type: "string",
+					optional: true
+				},
+				moonshotaiApiKey: {
+					type: "string",
+					optional: true
+				},
+				openaiApiKey: {
+					type: "string",
+					optional: true
+				},
+				opencodeApiKey: {
+					type: "string",
+					optional: true
+				},
+				xaiApiKey: {
+					type: "string",
+					optional: true
+				}
+			} },
+			sources: { providers: {
+				match: ["**/*.{js,ts}", "!**/*.d.ts"],
+				from: ["./providers", fromModule("../providers")]
+			} }
+		};
+	}
+});
+//#endregion
+export { module_default as default };

package/dist/protocols/anthropic-messages.d.ts

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

package/dist/protocols/anthropic-messages.js

@@ -0,0 +1,377 @@
+import { mergeHeaders, readDataFrames, toStream } from "../index.js";
+import { toJsonSchema } from "revojs/shared";
+//#region src/protocols/anthropic-messages.ts
+function toUsage(inputTokens, cacheRead, cacheWrite, outputTokens) {
+	const raw = {};
+	if (inputTokens !== void 0) raw.input_tokens = inputTokens;
+	if (cacheRead !== void 0) raw.cache_read_input_tokens = cacheRead;
+	if (cacheWrite !== void 0) raw.cache_creation_input_tokens = cacheWrite;
+	if (outputTokens !== void 0) raw.output_tokens = outputTokens;
+	return {
+		inputTokens: {
+			total: inputTokens,
+			noCache: inputTokens !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0 ? Math.max(0, inputTokens - cacheRead - cacheWrite) : void 0,
+			cacheRead,
+			cacheWrite
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: void 0,
+			reasoning: void 0
+		},
+		raw
+	};
+}
+function toFinishReason(raw) {
+	return {
+		unified: raw === "max_tokens" ? "length" : raw === "refusal" ? "content-filter" : raw === "tool_use" ? "tool-calls" : "stop",
+		raw: raw ?? void 0
+	};
+}
+function toParsedInput(input) {
+	try {
+		return JSON.parse(input || "{}");
+	} catch {
+		return {};
+	}
+}
+function toResultValue(output) {
+	if (output.type === "text" || output.type === "error-text") return output.value;
+	const value = "value" in output ? output.value : void 0;
+	return JSON.stringify(value ?? null);
+}
+function toBody(options, stream) {
+	let system = "";
+	const warnings = [];
+	const wire = [];
+	let pendingUser;
+	const flushUser = () => {
+		if (pendingUser !== void 0 && pendingUser.length > 0) wire.push({
+			role: "user",
+			content: pendingUser
+		});
+		pendingUser = void 0;
+	};
+	for (const message of options.prompt) {
+		if (message.role === "system") {
+			flushUser();
+			system += (system.length > 0 ? "\n" : "") + message.content;
+			continue;
+		}
+		if (message.role === "user") {
+			flushUser();
+			const content = message.content.flatMap((part) => {
+				if (part.type === "text") return [{
+					type: "text",
+					text: part.text
+				}];
+				if (part.data.type === "url") return [{
+					type: "image",
+					source: {
+						type: "url",
+						url: part.data.url.toString()
+					}
+				}];
+				if (part.data.type === "data" && typeof part.data.data === "string") return [{
+					type: "image",
+					source: {
+						type: "base64",
+						media_type: part.mediaType,
+						data: part.data.data
+					}
+				}];
+				warnings.push({
+					type: "unsupported",
+					feature: `user file (${part.mediaType}) message part`
+				});
+				return [];
+			});
+			if (content.length > 0) wire.push({
+				role: "user",
+				content
+			});
+			continue;
+		}
+		if (message.role === "tool") {
+			for (const part of message.content) {
+				if (part.type !== "tool-result") continue;
+				(pendingUser ??= []).push({
+					type: "tool_result",
+					tool_use_id: part.toolCallId,
+					content: toResultValue(part.output)
+				});
+			}
+			continue;
+		}
+		flushUser();
+		const blocks = [];
+		for (const part of message.content) {
+			if (part.type === "text") {
+				if (part.text.length > 0) blocks.push({
+					type: "text",
+					text: part.text
+				});
+				continue;
+			}
+			if (part.type === "reasoning") {
+				blocks.push({
+					type: "thinking",
+					thinking: part.text
+				});
+				continue;
+			}
+			if (part.type === "tool-call") {
+				blocks.push({
+					type: "tool_use",
+					id: part.toolCallId,
+					name: part.toolName,
+					input: toParsedInput(typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {}))
+				});
+				continue;
+			}
+			if (part.type !== "tool-result") warnings.push({
+				type: "compatibility",
+				feature: `assistant ${part.type} message part`
+			});
+		}
+		if (blocks.length > 0) wire.push({
+			role: "assistant",
+			content: blocks
+		});
+		for (const part of message.content) if (part.type === "tool-result") (pendingUser ??= []).push({
+			type: "tool_result",
+			tool_use_id: part.toolCallId,
+			content: toResultValue(part.output)
+		});
+	}
+	flushUser();
+	return [{
+		model: options.model,
+		max_tokens: options.maxOutputTokens ?? 8192,
+		stream,
+		...options.temperature !== void 0 ? { temperature: options.temperature } : {},
+		...options.topP !== void 0 ? { top_p: options.topP } : {},
+		...options.topK !== void 0 ? { top_k: options.topK } : {},
+		...options.stopSequences !== void 0 ? { stop_sequences: options.stopSequences } : {},
+		...system.length > 0 ? { system } : {},
+		...options.tools !== void 0 && options.tools.length > 0 ? { tools: options.tools.map((tool) => tool.type === "provider" ? {
+			type: "custom",
+			name: `${tool.id}.${tool.name}`,
+			...tool.args
+		} : {
+			name: tool.name,
+			description: tool.description,
+			input_schema: toJsonSchema(tool.inputSchema)
+		}) } : {},
+		...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice.type === "tool" ? {
+			type: "tool",
+			name: options.toolChoice.toolName
+		} : { type: options.toolChoice.type } } : {},
+		...options.providerOptions?.anthropic,
+		messages: wire
+	}, warnings];
+}
+async function* readParts(response, warnings) {
+	yield {
+		type: "stream-start",
+		warnings
+	};
+	const active = /* @__PURE__ */ new Map();
+	const complete = /* @__PURE__ */ new Map();
+	let streamCount = 0;
+	let metadataSent = false;
+	let inputTokens;
+	let cacheRead;
+	let cacheWrite;
+	let outputTokens;
+	let stopReason;
+	for await (const data of readDataFrames(response)) {
+		let chunk;
+		try {
+			chunk = JSON.parse(data);
+		} catch {
+			continue;
+		}
+		if (chunk.type === "error") throw new Error(chunk.error?.message ?? "Unknown AI provider error");
+		if (!metadataSent && chunk.type === "message_start") {
+			metadataSent = true;
+			yield {
+				type: "response-metadata",
+				id: chunk.id,
+				modelId: chunk.model
+			};
+		}
+		if (chunk.type === "message_start") {
+			inputTokens = chunk.message?.usage?.input_tokens;
+			cacheRead = chunk.message?.usage?.cache_read_input_tokens;
+			cacheWrite = chunk.message?.usage?.cache_creation_input_tokens;
+			continue;
+		}
+		if (chunk.type === "content_block_start") {
+			const index = chunk.index ?? 0;
+			const kind = chunk.content_block?.type ?? "";
+			const streamId = `anthropic-${kind}-${streamCount++}`;
+			const record = {
+				index,
+				kind,
+				streamId,
+				callId: chunk.content_block?.id ?? "",
+				name: chunk.content_block?.name ?? "",
+				json: ""
+			};
+			active.set(index, record);
+			if (kind === "tool_use") yield {
+				type: "tool-input-start",
+				id: streamId,
+				toolName: record.name
+			};
+			else if (kind === "thinking") yield {
+				type: "reasoning-start",
+				id: streamId
+			};
+			else yield {
+				type: "text-start",
+				id: streamId
+			};
+			continue;
+		}
+		const record = chunk.index === void 0 ? void 0 : active.get(chunk.index);
+		if (chunk.type === "content_block_delta" && record !== void 0 && chunk.delta !== void 0) {
+			if (chunk.delta.type === "input_json_delta" && typeof chunk.delta.partial_json === "string") {
+				record.json += chunk.delta.partial_json;
+				yield {
+					type: "tool-input-delta",
+					id: record.streamId,
+					delta: chunk.delta.partial_json
+				};
+				continue;
+			}
+			if (chunk.delta.type === "text_delta" && typeof chunk.delta.text === "string" && chunk.delta.text.length > 0) {
+				yield {
+					type: "text-delta",
+					id: record.streamId,
+					delta: chunk.delta.text
+				};
+				continue;
+			}
+			if (chunk.delta.type === "thinking_delta" && typeof chunk.delta.thinking === "string" && chunk.delta.thinking.length > 0) yield {
+				type: "reasoning-delta",
+				id: record.streamId,
+				delta: chunk.delta.thinking
+			};
+			continue;
+		}
+		if (chunk.type === "content_block_stop" && record !== void 0 && chunk.index !== void 0) {
+			active.delete(chunk.index);
+			complete.set(chunk.index, record);
+			if (record.kind === "tool_use") yield {
+				type: "tool-input-end",
+				id: record.streamId
+			};
+			else if (record.kind === "thinking") yield {
+				type: "reasoning-end",
+				id: record.streamId
+			};
+			else yield {
+				type: "text-end",
+				id: record.streamId
+			};
+			continue;
+		}
+		if (chunk.type === "message_delta") {
+			if (typeof chunk.delta?.stop_reason === "string") stopReason = chunk.delta.stop_reason;
+			if (typeof chunk.usage?.output_tokens === "number") outputTokens = chunk.usage.output_tokens;
+		}
+	}
+	for (const record of active.values()) if (record.kind === "tool_use") yield {
+		type: "tool-input-end",
+		id: record.streamId
+	};
+	else if (record.kind === "thinking") yield {
+		type: "reasoning-end",
+		id: record.streamId
+	};
+	else yield {
+		type: "text-end",
+		id: record.streamId
+	};
+	for (const record of [...complete.values()].sort((left, right) => left.index - right.index)) if (record.callId.length > 0) yield {
+		type: "tool-call",
+		toolCallId: record.callId,
+		toolName: record.name,
+		input: record.json
+	};
+	yield {
+		type: "finish",
+		usage: toUsage(inputTokens, cacheRead, cacheWrite, outputTokens),
+		finishReason: toFinishReason(stopReason)
+	};
+}
+async function post(config, options, body) {
+	const response = await fetch(`${config.baseURL.replace(/\/+$/, "")}/messages`, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			...mergeHeaders(config.apiKey === void 0 ? {} : { "x-api-key": config.apiKey }, { "anthropic-version": "2023-06-01" }, 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 response;
+}
+function messagesGenerateProtocol(config) {
+	return async (options) => {
+		const [body, warnings] = toBody(options, false);
+		const response = await post(config, options, body);
+		const data = await response.json();
+		const content = [];
+		for (const part of data.content ?? []) {
+			if (part.type === "text" && typeof part.text === "string") {
+				content.push({
+					type: "text",
+					text: part.text
+				});
+				continue;
+			}
+			if (part.type === "thinking" && typeof part.thinking === "string") {
+				content.push({
+					type: "reasoning",
+					text: part.thinking
+				});
+				continue;
+			}
+			if (part.type === "tool_use" && typeof part.id === "string" && typeof part.name === "string") content.push({
+				type: "tool-call",
+				toolCallId: part.id,
+				toolName: part.name,
+				input: JSON.stringify(part.input ?? {})
+			});
+		}
+		return {
+			content,
+			finishReason: toFinishReason(data.stop_reason),
+			usage: toUsage(data.usage?.input_tokens, data.usage?.cache_read_input_tokens, data.usage?.cache_creation_input_tokens, data.usage?.output_tokens),
+			request: { body },
+			response: {
+				id: data.id,
+				modelId: data.model,
+				headers: Object.fromEntries(response.headers.entries())
+			},
+			warnings
+		};
+	};
+}
+function messagesStreamProtocol(config) {
+	return async (options) => {
+		const [body, warnings] = toBody(options, true);
+		const response = await post(config, options, body);
+		return {
+			request: { body },
+			response: { headers: Object.fromEntries(response.headers.entries()) },
+			stream: toStream(() => readParts(response, warnings))
+		};
+	};
+}
+//#endregion
+export { messagesGenerateProtocol, messagesStreamProtocol };

package/dist/protocols/google-models.d.ts

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