@clinebot/llms 0.0.20 → 0.0.22

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

@@ -1,229 +0,0 @@
-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,
-		cacheWriteTokens?: 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,
-						usageMetrics.cacheWriteTokens,
-					),
-					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,
-				usageMetrics.cacheWriteTokens,
-			),
-			id: responseId,
-		};
-	}
-
-	yield { type: "done", success: true, id: responseId };
-}

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

@@ -1,203 +0,0 @@
-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,
-				cacheWriteTokens,
-			) =>
-				this.calculateCost(
-					inputTokens,
-					outputTokens,
-					cacheReadTokens,
-					cacheWriteTokens,
-				),
-			...this.getEmitStreamOptions(),
-		});
-	}
-}

package/src/providers/handlers/anthropic-base.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { AnthropicHandler } from "./anthropic-base";
-
-describe("AnthropicHandler prompt cache detection", () => {
-	it("enables prompt caching when model pricing includes cache pricing", () => {
-		const handler = new AnthropicHandler({
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4-6",
-			apiKey: "test-key",
-			modelInfo: {
-				id: "claude-sonnet-4-6",
-				pricing: {
-					input: 3,
-					output: 15,
-					cacheRead: 0.3,
-					cacheWrite: 3.75,
-				},
-			},
-		});
-
-		const messages = handler.getMessages("system", [
-			{ role: "user", content: "Tell me about this repo" },
-		]);
-		const userTextBlock = messages[0]?.content?.[0] as
-			| { cache_control?: { type: string } }
-			| undefined;
-
-		expect(userTextBlock?.cache_control).toEqual({ type: "ephemeral" });
-	});
-});