@clinebot/llms 0.0.0

package/src/providers/handlers/ai-sdk-community.ts

@@ -0,0 +1,226 @@
+import type { ApiStream } from "../types";
+
+export type {
+	AiSdkMessage,
+	AiSdkMessagePart,
+} from "../transform/ai-sdk-community-format";
+export { toAiSdkMessages } from "../transform/ai-sdk-community-format";
+
+type AiSdkStreamPart = {
+	type?: string;
+	[key: string]: unknown;
+};
+
+type AiSdkUsage = {
+	inputTokens?: unknown;
+	outputTokens?: unknown;
+	reasoningTokens?: unknown;
+	thoughtsTokenCount?: unknown;
+	cachedInputTokens?: unknown;
+};
+
+export type AiSdkStream = {
+	fullStream?: AsyncIterable<AiSdkStreamPart>;
+	textStream?: AsyncIterable<string>;
+	text?: Promise<string> | string;
+	usage?: Promise<Record<string, unknown>>;
+};
+
+type AiSdkUsageMetrics = {
+	inputTokens: number;
+	outputTokens: number;
+	thoughtsTokenCount: number;
+	cacheReadTokens: number;
+	cacheWriteTokens?: number;
+};
+
+export type EmitAiSdkStreamOptions = {
+	responseId: string;
+	errorMessage: string;
+	calculateCost: (
+		inputTokens: number,
+		outputTokens: number,
+		cacheReadTokens: number,
+	) => number | undefined;
+	reasoningTypes?: string[];
+	enableToolCalls?: boolean;
+	toolCallArgsOrder?: Array<"args" | "input">;
+	toolCallFunctionIncludeId?: boolean;
+	enableTextFallback?: boolean;
+	resolveUsageMetrics?: (
+		usage: AiSdkUsage,
+		part?: AiSdkStreamPart,
+	) => AiSdkUsageMetrics;
+};
+
+let cachedAiModule: {
+	streamText: (input: Record<string, unknown>) => AiSdkStream;
+} | null = null;
+
+export type LoadAiSdkOptions = {
+	beforeImport?: () => void;
+};
+
+export async function loadAiSdkModule(options?: LoadAiSdkOptions): Promise<{
+	streamText: (input: Record<string, unknown>) => AiSdkStream;
+}> {
+	if (cachedAiModule) {
+		return cachedAiModule;
+	}
+	options?.beforeImport?.();
+	cachedAiModule = (await import("ai")) as unknown as {
+		streamText: (input: Record<string, unknown>) => AiSdkStream;
+	};
+	return cachedAiModule;
+}
+
+export function numberOrZero(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function defaultResolveUsageMetrics(usage: AiSdkUsage): AiSdkUsageMetrics {
+	return {
+		inputTokens: numberOrZero(usage.inputTokens),
+		outputTokens: numberOrZero(usage.outputTokens),
+		thoughtsTokenCount: numberOrZero(
+			usage.reasoningTokens ?? usage.thoughtsTokenCount,
+		),
+		cacheReadTokens: numberOrZero(usage.cachedInputTokens),
+	};
+}
+
+export async function* emitAiSdkStream(
+	stream: AiSdkStream,
+	options: EmitAiSdkStreamOptions,
+): ApiStream {
+	const resolveUsageMetrics =
+		options.resolveUsageMetrics ?? defaultResolveUsageMetrics;
+	const reasoningTypes = new Set(options.reasoningTypes ?? ["reasoning-delta"]);
+	const toolCallArgsOrder = options.toolCallArgsOrder ?? ["args", "input"];
+	const responseId = options.responseId;
+
+	let usageEmitted = false;
+	let textEmitted = false;
+
+	if (stream.fullStream) {
+		for await (const part of stream.fullStream) {
+			const partType = part.type;
+
+			if (partType === "text-delta") {
+				const text =
+					(part.textDelta as string | undefined) ??
+					(part.text as string | undefined) ??
+					(part.delta as string | undefined);
+				if (text) {
+					yield { type: "text", text, id: responseId };
+					textEmitted = true;
+				}
+				continue;
+			}
+
+			if (partType && reasoningTypes.has(partType)) {
+				const reasoning =
+					(part.textDelta as string | undefined) ??
+					(part.reasoning as string | undefined) ??
+					(part.text as string | undefined);
+				if (reasoning) {
+					yield { type: "reasoning", reasoning, id: responseId };
+				}
+				continue;
+			}
+
+			if (partType === "tool-call" && options.enableToolCalls) {
+				const toolCallId =
+					(part.toolCallId as string | undefined) ??
+					(part.id as string | undefined);
+				const toolName =
+					(part.toolName as string | undefined) ??
+					(part.name as string | undefined);
+				const args =
+					toolCallArgsOrder
+						.map((key) => part[key] as Record<string, unknown> | undefined)
+						.find((candidate) => candidate !== undefined) ?? {};
+
+				yield {
+					type: "tool_calls",
+					id: responseId,
+					tool_call: {
+						call_id: toolCallId,
+						function: {
+							id: options.toolCallFunctionIncludeId ? toolCallId : undefined,
+							name: toolName,
+							arguments: args,
+						},
+					},
+				};
+				continue;
+			}
+
+			if (partType === "error") {
+				const message =
+					(part.error as Error | undefined)?.message ?? options.errorMessage;
+				throw new Error(message);
+			}
+
+			if (partType === "finish") {
+				const usage = (part.totalUsage ?? part.usage ?? {}) as AiSdkUsage;
+				const usageMetrics = resolveUsageMetrics(usage, part);
+
+				yield {
+					type: "usage",
+					inputTokens: Math.max(
+						0,
+						usageMetrics.inputTokens - usageMetrics.cacheReadTokens,
+					),
+					outputTokens: usageMetrics.outputTokens,
+					thoughtsTokenCount: usageMetrics.thoughtsTokenCount,
+					cacheReadTokens: usageMetrics.cacheReadTokens,
+					cacheWriteTokens: usageMetrics.cacheWriteTokens,
+					totalCost: options.calculateCost(
+						usageMetrics.inputTokens,
+						usageMetrics.outputTokens,
+						usageMetrics.cacheReadTokens,
+					),
+					id: responseId,
+				};
+				usageEmitted = true;
+			}
+		}
+	} else if (stream.textStream) {
+		for await (const text of stream.textStream) {
+			yield { type: "text", text, id: responseId };
+			textEmitted = true;
+		}
+	}
+
+	if (!textEmitted && options.enableTextFallback && stream.text) {
+		const text = await stream.text;
+		if (typeof text === "string" && text.length > 0) {
+			yield { type: "text", text, id: responseId };
+		}
+	}
+
+	if (!usageEmitted && stream.usage) {
+		const usage = (await stream.usage) as AiSdkUsage;
+		const usageMetrics = resolveUsageMetrics(usage);
+		yield {
+			type: "usage",
+			inputTokens: Math.max(
+				0,
+				usageMetrics.inputTokens - usageMetrics.cacheReadTokens,
+			),
+			outputTokens: usageMetrics.outputTokens,
+			thoughtsTokenCount: usageMetrics.thoughtsTokenCount,
+			cacheReadTokens: usageMetrics.cacheReadTokens,
+			cacheWriteTokens: usageMetrics.cacheWriteTokens,
+			totalCost: options.calculateCost(
+				usageMetrics.inputTokens,
+				usageMetrics.outputTokens,
+				usageMetrics.cacheReadTokens,
+			),
+			id: responseId,
+		};
+	}
+
+	yield { type: "done", success: true, id: responseId };
+}

package/src/providers/handlers/ai-sdk-provider-base.ts

@@ -0,0 +1,193 @@
+import { toAiSdkMessages } from "../transform/ai-sdk-community-format";
+import type { ApiStream, HandlerModelInfo, ProviderConfig } from "../types";
+import type { Message, ToolDefinition } from "../types/messages";
+import { retryStream } from "../utils/retry";
+import {
+	type EmitAiSdkStreamOptions,
+	emitAiSdkStream,
+	type LoadAiSdkOptions,
+	loadAiSdkModule,
+} from "./ai-sdk-community";
+import { BaseHandler } from "./base";
+
+type AiSdkCommunityProvider = (
+	modelId: string,
+	settings?: Record<string, unknown>,
+) => unknown;
+
+type ProviderModule = Record<string, unknown>;
+
+const providerModuleCache = new Map<string, ProviderModule>();
+
+type CommunityProviderDefinition = {
+	moduleName: string;
+	createExportName: string;
+	providerExportName: string;
+	missingDependencyError: string;
+};
+
+export function resolveHandlerModel(
+	config: ProviderConfig,
+	defaultModelId?: string,
+): HandlerModelInfo {
+	const configuredModelId = config.modelId?.trim();
+	const modelId =
+		configuredModelId && configuredModelId.length > 0
+			? configuredModelId
+			: (defaultModelId ?? "");
+	const knownModels = config.knownModels ?? {};
+	const fallbackModel = knownModels[modelId] ?? {};
+	const modelInfo = config.modelInfo ?? fallbackModel;
+	return { id: modelId, info: { ...modelInfo, id: modelId } };
+}
+
+async function loadProviderModule(moduleName: string): Promise<ProviderModule> {
+	const cached = providerModuleCache.get(moduleName);
+	if (cached) {
+		return cached;
+	}
+	const loaded = (await import(moduleName)) as ProviderModule;
+	providerModuleCache.set(moduleName, loaded);
+	return loaded;
+}
+
+export abstract class AiSdkProviderHandler extends BaseHandler {
+	private provider: AiSdkCommunityProvider | undefined;
+	private providerPromise: Promise<AiSdkCommunityProvider> | undefined;
+
+	protected abstract getProviderDefinition(): CommunityProviderDefinition;
+	protected abstract getDefaultModelId(): string;
+
+	protected getProviderCreateOptions(): Record<string, unknown> | undefined {
+		return undefined;
+	}
+
+	protected async beforeLoadProviderModule(): Promise<void> {}
+
+	protected getProviderModelSettings(): Record<string, unknown> | undefined {
+		return undefined;
+	}
+
+	protected getLoadAiSdkOptions(): LoadAiSdkOptions | undefined {
+		return undefined;
+	}
+
+	protected getStreamErrorMessage(): string {
+		return "AI SDK stream failed";
+	}
+
+	protected getEmitStreamOptions(): Omit<
+		EmitAiSdkStreamOptions,
+		"responseId" | "errorMessage" | "calculateCost"
+	> {
+		return {};
+	}
+
+	protected getAssistantToolCallArgKey(): "args" | "input" {
+		return "args";
+	}
+
+	protected normalizeModelId(modelId: string): string {
+		return modelId;
+	}
+
+	protected async ensureProvider(): Promise<AiSdkCommunityProvider> {
+		if (this.provider) {
+			return this.provider;
+		}
+		if (!this.providerPromise) {
+			this.providerPromise = (async () => {
+				const definition = this.getProviderDefinition();
+				await this.beforeLoadProviderModule();
+				const module = await loadProviderModule(definition.moduleName);
+
+				const createProvider = module[definition.createExportName] as
+					| ((options?: Record<string, unknown>) => AiSdkCommunityProvider)
+					| undefined;
+				const provider = module[definition.providerExportName] as
+					| AiSdkCommunityProvider
+					| undefined;
+
+				if (createProvider) {
+					const created = createProvider(this.getProviderCreateOptions());
+					this.provider = created;
+					return created;
+				}
+
+				if (provider) {
+					this.provider = provider;
+					return provider;
+				}
+
+				throw new Error(
+					`${definition.moduleName} did not export \`${definition.providerExportName}\` or \`${definition.createExportName}\`.`,
+				);
+			})();
+		}
+
+		try {
+			return await this.providerPromise;
+		} catch (error) {
+			this.providerPromise = undefined;
+			const moduleName = this.getProviderDefinition().moduleName;
+			if (error instanceof Error && error.message.includes(moduleName)) {
+				throw new Error(this.getProviderDefinition().missingDependencyError, {
+					cause: error,
+				});
+			}
+			throw error;
+		}
+	}
+
+	getModel(): HandlerModelInfo {
+		return resolveHandlerModel(this.config, this.getDefaultModelId());
+	}
+
+	getMessages(systemPrompt: string, messages: Message[]) {
+		return toAiSdkMessages(systemPrompt, messages, {
+			assistantToolCallArgKey: this.getAssistantToolCallArgKey(),
+		});
+	}
+
+	async *createMessage(
+		systemPrompt: string,
+		messages: Message[],
+		tools?: ToolDefinition[],
+	): ApiStream {
+		yield* retryStream(() =>
+			this.createMessageInternal(systemPrompt, messages, tools),
+		);
+	}
+
+	private async *createMessageInternal(
+		systemPrompt: string,
+		messages: Message[],
+		tools?: ToolDefinition[],
+	): ApiStream {
+		void tools;
+
+		const ai = await loadAiSdkModule(this.getLoadAiSdkOptions());
+		const provider = await this.ensureProvider();
+		const { id: modelId, info } = this.getModel();
+		const responseId = this.createResponseId();
+
+		const stream = ai.streamText({
+			model: provider(
+				this.normalizeModelId(modelId),
+				this.getProviderModelSettings(),
+			),
+			messages: this.getMessages(systemPrompt, messages),
+			maxTokens: info.maxTokens ?? undefined,
+			temperature: info.temperature ?? undefined,
+			abortSignal: this.getAbortSignal(),
+		});
+
+		yield* emitAiSdkStream(stream, {
+			responseId,
+			errorMessage: this.getStreamErrorMessage(),
+			calculateCost: (inputTokens, outputTokens, cacheReadTokens) =>
+				this.calculateCost(inputTokens, outputTokens, cacheReadTokens),
+			...this.getEmitStreamOptions(),
+		});
+	}
+}