@clinebot/llms 0.0.20 → 0.0.22

package/src/providers/handlers/fetch-base.ts

@@ -1,68 +0,0 @@
-import type { ApiStream } from "../types";
-import type { Message, ToolDefinition } from "../types/messages";
-import { retryStream } from "../utils/retry";
-import { BaseHandler } from "./base";
-
-type JsonRecord = Record<string, unknown>;
-
-export abstract class FetchBaseHandler extends BaseHandler {
-	protected abstract getDefaultBaseUrl(): string;
-
-	getMessages(systemPrompt: string, messages: Message[]): unknown {
-		return {
-			systemPrompt,
-			messages,
-		};
-	}
-
-	protected getBaseUrl(): string {
-		return this.config.baseUrl?.trim() || this.getDefaultBaseUrl();
-	}
-
-	protected getJsonHeaders(
-		extra?: Record<string, string>,
-	): Record<string, string> {
-		return {
-			"Content-Type": "application/json",
-			...this.getRequestHeaders(),
-			...(extra ?? {}),
-		};
-	}
-
-	protected async fetchJson<T>(
-		path: string,
-		init: {
-			method?: string;
-			body?: JsonRecord;
-			headers?: Record<string, string>;
-		},
-	): Promise<T> {
-		const response = await fetch(`${this.getBaseUrl()}${path}`, {
-			method: init.method ?? "POST",
-			headers: this.getJsonHeaders(init.headers),
-			body: init.body ? JSON.stringify(init.body) : undefined,
-			signal: this.getAbortSignal(),
-		});
-		if (!response.ok) {
-			const details = await response.text();
-			throw new Error(`HTTP ${response.status}: ${details}`);
-		}
-		return (await response.json()) as T;
-	}
-
-	async *createMessage(
-		systemPrompt: string,
-		messages: Message[],
-		tools?: ToolDefinition[],
-	): ApiStream {
-		void tools;
-		yield* retryStream(() =>
-			this.createMessageWithFetch(systemPrompt, messages),
-		);
-	}
-
-	protected abstract createMessageWithFetch(
-		systemPrompt: string,
-		messages: Message[],
-	): ApiStream;
-}

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

@@ -1,261 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { ToolDefinition } from "../types/messages";
-import type { ApiStreamChunk } from "../types/stream";
-
-const generateContentStreamSpy = vi.fn();
-const googleGenAIConstructorSpy = vi.fn();
-
-vi.mock("@google/genai", () => {
-	class GoogleGenAI {
-		models = {
-			generateContentStream: generateContentStreamSpy,
-		};
-
-		constructor(config: unknown) {
-			googleGenAIConstructorSpy(config);
-		}
-	}
-
-	return {
-		GoogleGenAI,
-		FunctionCallingConfigMode: { AUTO: "AUTO" },
-		ThinkingLevel: { HIGH: "HIGH", LOW: "LOW" },
-	};
-});
-
-import { GeminiHandler } from "./gemini-base";
-
-function createAsyncIterable<T>(items: T[]): AsyncIterable<T> {
-	return {
-		async *[Symbol.asyncIterator]() {
-			for (const item of items) {
-				yield item;
-			}
-		},
-	};
-}
-
-async function collectChunks(stream: AsyncIterable<ApiStreamChunk>) {
-	const chunks: ApiStreamChunk[] = [];
-	for await (const chunk of stream) {
-		chunks.push(chunk);
-	}
-	return chunks;
-}
-
-describe("GeminiHandler", () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	it("preserves per-call ids for parallel function calls and keeps falsy args", async () => {
-		generateContentStreamSpy.mockResolvedValue(
-			createAsyncIterable([
-				{
-					candidates: [
-						{
-							content: {
-								parts: [
-									{
-										functionCall: {
-											id: "call_a",
-											name: "power_disco_ball",
-											args: { power: false },
-										},
-									},
-									{
-										functionCall: {
-											id: "call_b",
-											name: "dim_lights",
-											args: { brightness: 0 },
-										},
-									},
-								],
-							},
-						},
-					],
-					usageMetadata: {
-						promptTokenCount: 10,
-						candidatesTokenCount: 4,
-					},
-				},
-			]),
-		);
-
-		const handler = new GeminiHandler({
-			providerId: "gemini",
-			modelId: "gemini-2.5-flash",
-			apiKey: "test-key",
-			modelInfo: {
-				id: "gemini-2.5-flash",
-				contextWindow: 1_000_000,
-				maxTokens: 8192,
-				temperature: 1,
-			},
-		});
-
-		const tools: ToolDefinition[] = [
-			{
-				name: "power_disco_ball",
-				description: "toggle disco ball power",
-				inputSchema: {
-					type: "object",
-					properties: { power: { type: "boolean" } },
-					required: ["power"],
-				},
-			},
-			{
-				name: "dim_lights",
-				description: "set light brightness",
-				inputSchema: {
-					type: "object",
-					properties: { brightness: { type: "number" } },
-					required: ["brightness"],
-				},
-			},
-		];
-
-		const chunks = await collectChunks(
-			handler.createMessage(
-				"You are helpful.",
-				[{ role: "user", content: "start" }],
-				tools,
-			),
-		);
-
-		const toolChunks = chunks.filter((chunk) => chunk.type === "tool_calls");
-		expect(toolChunks).toHaveLength(2);
-		expect(toolChunks[0]).toMatchObject({
-			tool_call: {
-				call_id: "call_a",
-				function: {
-					id: "call_a",
-					name: "power_disco_ball",
-					arguments: { power: false },
-				},
-			},
-		});
-		expect(toolChunks[1]).toMatchObject({
-			tool_call: {
-				call_id: "call_b",
-				function: {
-					id: "call_b",
-					name: "dim_lights",
-					arguments: { brightness: 0 },
-				},
-			},
-		});
-	});
-
-	it("generates distinct fallback ids when Gemini omits functionCall.id", async () => {
-		generateContentStreamSpy.mockResolvedValue(
-			createAsyncIterable([
-				{
-					candidates: [
-						{
-							content: {
-								parts: [
-									{
-										functionCall: {
-											name: "read_file",
-											args: { path: "a.ts" },
-										},
-									},
-									{
-										functionCall: {
-											name: "search_files",
-											args: { query: "TODO" },
-										},
-									},
-								],
-							},
-						},
-					],
-					usageMetadata: {
-						promptTokenCount: 5,
-						candidatesTokenCount: 3,
-					},
-				},
-			]),
-		);
-
-		const handler = new GeminiHandler({
-			providerId: "gemini",
-			modelId: "gemini-2.5-flash",
-			apiKey: "test-key",
-		});
-
-		const chunks = await collectChunks(
-			handler.createMessage(
-				"System",
-				[{ role: "user", content: "go" }],
-				[
-					{
-						name: "read_file",
-						description: "read file",
-						inputSchema: {
-							type: "object",
-							properties: { path: { type: "string" } },
-						},
-					},
-					{
-						name: "search_files",
-						description: "search files",
-						inputSchema: {
-							type: "object",
-							properties: { query: { type: "string" } },
-						},
-					},
-				],
-			),
-		);
-
-		const toolChunks = chunks.filter((chunk) => chunk.type === "tool_calls");
-		expect(toolChunks).toHaveLength(2);
-		const firstId = toolChunks[0].tool_call.call_id;
-		const secondId = toolChunks[1].tool_call.call_id;
-		expect(firstId).toBeTruthy();
-		expect(secondId).toBeTruthy();
-		expect(firstId).not.toBe(secondId);
-	});
-
-	it("defaults maxOutputTokens to 8192 for gemini-3-flash when no model or config limit is provided", async () => {
-		generateContentStreamSpy.mockResolvedValue(createAsyncIterable([]));
-
-		const handler = new GeminiHandler({
-			providerId: "gemini",
-			modelId: "gemini-3-flash",
-			apiKey: "test-key",
-		});
-
-		await collectChunks(
-			handler.createMessage("System", [{ role: "user", content: "go" }]),
-		);
-
-		expect(generateContentStreamSpy).toHaveBeenCalledTimes(1);
-		const request = generateContentStreamSpy.mock.calls[0]?.[0] as {
-			config?: { maxOutputTokens?: number };
-		};
-		expect(request.config?.maxOutputTokens).toBe(8192);
-	});
-
-	it("defaults maxOutputTokens to 128000 for non gemini-3-flash models when no model or config limit is provided", async () => {
-		generateContentStreamSpy.mockResolvedValue(createAsyncIterable([]));
-
-		const handler = new GeminiHandler({
-			providerId: "gemini",
-			modelId: "gemini-2.5-flash",
-			apiKey: "test-key",
-		});
-
-		await collectChunks(
-			handler.createMessage("System", [{ role: "user", content: "go" }]),
-		);
-
-		expect(generateContentStreamSpy).toHaveBeenCalledTimes(1);
-		const request = generateContentStreamSpy.mock.calls[0]?.[0] as {
-			config?: { maxOutputTokens?: number };
-		};
-		expect(request.config?.maxOutputTokens).toBe(128000);
-	});
-});

package/src/providers/handlers/gemini-base.ts

@@ -1,307 +0,0 @@
-/**
- * Gemini Base Handler
- *
- * Handler for Google's Gemini API using the official SDK.
- * Supports Vertex AI, thinking/reasoning, and native tool calling.
- */
-
-import {
-	FunctionCallingConfigMode,
-	type GenerateContentConfig,
-	GoogleGenAI,
-	ThinkingLevel,
-} from "@google/genai";
-import {
-	convertToGeminiMessages,
-	convertToolsToGemini,
-} from "../transform/gemini-format";
-import {
-	type ApiStream,
-	type HandlerModelInfo,
-	type ProviderConfig,
-	supportsModelThinking,
-} from "../types";
-import type { Message, ToolDefinition } from "../types/messages";
-import { RetriableError, retryStream } from "../utils/retry";
-import { BaseHandler } from "./base";
-
-const DEFAULT_THINKING_BUDGET_TOKENS = 1024;
-const DEFAULT_MAX_OUTPUT_TOKENS = 128_000;
-const GEMINI_3_FLASH_MAX_OUTPUT_TOKENS = 8192;
-
-function isGemini3FlashModel(modelId: string): boolean {
-	const normalized = modelId.toLowerCase();
-	return (
-		normalized.includes("gemini-3-flash") ||
-		normalized.includes("gemini-3.0-flash")
-	);
-}
-
-/**
- * Handler for Google's Gemini API
- */
-export class GeminiHandler extends BaseHandler {
-	private client: GoogleGenAI | undefined;
-
-	private ensureClient(): GoogleGenAI {
-		if (!this.client) {
-			// Check for Vertex AI configuration
-			if (this.config.gcp?.projectId) {
-				this.client = new GoogleGenAI({
-					vertexai: true,
-					project: this.config.gcp.projectId,
-					location: this.config.region ?? "us-central1",
-					httpOptions: {
-						headers: this.getRequestHeaders(),
-					},
-				});
-			} else {
-				// Standard API key auth
-				if (!this.config.apiKey) {
-					throw new Error(
-						"Gemini API key is required when not using Vertex AI",
-					);
-				}
-
-				this.client = new GoogleGenAI({
-					apiKey: this.config.apiKey,
-					httpOptions: {
-						headers: this.getRequestHeaders(),
-					},
-				});
-			}
-		}
-		return this.client;
-	}
-
-	getModel(): HandlerModelInfo {
-		const modelId = this.config.modelId;
-		const knownModels = this.config.knownModels ?? {};
-		const fallbackModel = knownModels[modelId] ?? {};
-		const modelInfo = this.config.modelInfo ?? fallbackModel;
-
-		return { id: modelId, info: { ...modelInfo, id: modelId } };
-	}
-
-	getMessages(_systemPrompt: string, messages: Message[]) {
-		return convertToGeminiMessages(messages);
-	}
-
-	async *createMessage(
-		systemPrompt: string,
-		messages: Message[],
-		tools?: ToolDefinition[],
-	): ApiStream {
-		yield* retryStream(
-			() => this.createMessageInternal(systemPrompt, messages, tools),
-			{ maxRetries: 4, baseDelay: 2000, maxDelay: 15000 },
-		);
-	}
-
-	private async *createMessageInternal(
-		systemPrompt: string,
-		messages: Message[],
-		tools?: ToolDefinition[],
-	): ApiStream {
-		const client = this.ensureClient();
-		const { id: modelId, info } = this.getModel();
-		const abortSignal = this.getAbortSignal();
-		const responseId = this.createResponseId();
-
-		// Convert messages
-		const contents = this.getMessages(systemPrompt, messages);
-
-		const thinkingSupported = supportsModelThinking(info);
-		const thinkingRequested =
-			this.config.thinking === true ||
-			typeof this.config.thinkingBudgetTokens === "number" ||
-			typeof this.config.reasoningEffort === "string";
-		let thinkingBudget = 0;
-		let thinkingLevel: ThinkingLevel | undefined;
-
-		if (thinkingSupported && thinkingRequested) {
-			const requestedBudget =
-				this.config.thinkingBudgetTokens ??
-				(this.config.thinking ? DEFAULT_THINKING_BUDGET_TOKENS : 0);
-			thinkingBudget = Math.min(
-				Math.max(0, requestedBudget),
-				info.thinkingConfig?.maxBudget ?? 24576,
-			);
-
-			// If thinkingConfig has a thinkingLevel, it supports thinking level control
-			if (info.thinkingConfig?.thinkingLevel) {
-				const level = this.config.reasoningEffort;
-				if (level === "high") {
-					thinkingLevel = ThinkingLevel.HIGH;
-				} else if (level === "low" || level === "medium") {
-					thinkingLevel = ThinkingLevel.LOW;
-				}
-			}
-		}
-
-		// Build request config with abort signal
-		const fallbackMaxOutputTokens = isGemini3FlashModel(modelId)
-			? GEMINI_3_FLASH_MAX_OUTPUT_TOKENS
-			: DEFAULT_MAX_OUTPUT_TOKENS;
-		const maxOutputTokens =
-			info.maxTokens ?? this.config.maxOutputTokens ?? fallbackMaxOutputTokens;
-		const requestConfig: GenerateContentConfig = {
-			httpOptions: this.config.baseUrl
-				? { baseUrl: this.config.baseUrl, headers: this.getRequestHeaders() }
-				: undefined,
-			abortSignal,
-			systemInstruction: systemPrompt,
-			temperature: info.temperature ?? 1,
-			maxOutputTokens,
-		};
-
-		// Add thinking config only when explicitly requested and supported.
-		if (
-			info.thinkingConfig &&
-			thinkingSupported &&
-			thinkingRequested &&
-			(thinkingBudget > 0 || !!thinkingLevel)
-		) {
-			requestConfig.thinkingConfig = {
-				thinkingBudget: thinkingLevel ? undefined : thinkingBudget,
-				thinkingLevel,
-				includeThoughts: true,
-			};
-		}
-
-		// Add tools if provided
-		if (tools && tools.length > 0) {
-			const functionDeclarations = convertToolsToGemini(tools);
-			requestConfig.tools = [{ functionDeclarations }];
-			requestConfig.toolConfig = {
-				functionCallingConfig: {
-					mode: FunctionCallingConfigMode.AUTO,
-				},
-			};
-		}
-
-		try {
-			const result = await client.models.generateContentStream({
-				model: modelId,
-				contents,
-				config: requestConfig,
-			});
-
-			let promptTokens = 0;
-			let outputTokens = 0;
-			let cacheReadTokens = 0;
-			let thoughtsTokenCount = 0;
-			let syntheticToolCallIndex = 0;
-
-			for await (const chunk of result) {
-				// Handle content parts
-				const parts = chunk?.candidates?.[0]?.content?.parts ?? [];
-
-				for (const part of parts) {
-					if ((part as any).thought && part.text) {
-						// Thinking content
-						yield {
-							type: "reasoning",
-							reasoning: part.text || "",
-							signature: (part as any).thoughtSignature,
-							id: responseId,
-						};
-					} else if (part.text) {
-						// Regular text
-						yield {
-							type: "text",
-							text: part.text,
-							id: responseId,
-							signature: (part as any).thoughtSignature,
-						};
-					}
-
-					if (part.functionCall) {
-						// Tool call
-						const functionCall = part.functionCall;
-						const callId =
-							functionCall.id ??
-							`${responseId}_tool_${syntheticToolCallIndex++}`;
-						if (functionCall.name) {
-							yield {
-								type: "tool_calls",
-								tool_call: {
-									call_id: callId,
-									function: {
-										id: callId,
-										name: functionCall.name,
-										arguments:
-											(functionCall.args as Record<string, unknown>) ?? {},
-									},
-								},
-								id: responseId,
-								signature: (part as any).thoughtSignature,
-							};
-						}
-					}
-				}
-
-				// Track usage
-				if (chunk.usageMetadata) {
-					promptTokens = chunk.usageMetadata.promptTokenCount ?? promptTokens;
-					outputTokens =
-						chunk.usageMetadata.candidatesTokenCount ?? outputTokens;
-					thoughtsTokenCount =
-						(chunk.usageMetadata as any).thoughtsTokenCount ??
-						thoughtsTokenCount;
-					cacheReadTokens =
-						(chunk.usageMetadata as any).cachedContentTokenCount ??
-						cacheReadTokens;
-				}
-			}
-
-			// Yield final usage
-			const totalCost = this.calculateGeminiCost(
-				promptTokens,
-				outputTokens,
-				thoughtsTokenCount,
-				cacheReadTokens,
-			);
-
-			yield {
-				type: "usage",
-				inputTokens: promptTokens,
-				outputTokens,
-				thoughtsTokenCount,
-				cacheReadTokens,
-				cacheWriteTokens: 0,
-				totalCost,
-				id: responseId,
-			};
-
-			// Yield done chunk to indicate streaming completed successfully
-			yield { type: "done", success: true, id: responseId };
-		} catch (error) {
-			// Handle rate limit errors with retry info
-			if (error instanceof Error && error.message.includes("429")) {
-				throw new RetriableError(error.message, undefined, { cause: error });
-			}
-			throw error;
-		}
-	}
-
-	private calculateGeminiCost(
-		inputTokens: number,
-		outputTokens: number,
-		thoughtsTokenCount: number,
-		cacheReadTokens: number,
-	): number | undefined {
-		return this.calculateCost(
-			inputTokens,
-			outputTokens + thoughtsTokenCount,
-			cacheReadTokens,
-		);
-	}
-}
-
-/**
- * Create a Gemini handler
- */
-export function createGeminiHandler(config: ProviderConfig): GeminiHandler {
-	return new GeminiHandler(config);
-}

package/src/providers/handlers/index.ts

@@ -1,67 +0,0 @@
-/**
- * Handlers Index
- *
- * Re-exports all handler classes and factory functions.
- */
-
-export { AnthropicHandler, createAnthropicHandler } from "./anthropic-base";
-export { AskSageHandler, createAskSageHandler } from "./asksage";
-export {
-	getMissingApiKeyError,
-	getProviderEnvKeys,
-	normalizeProviderId,
-	resolveApiKeyForProvider,
-} from "./auth";
-// Base classes
-export { BaseHandler } from "./base";
-export { BedrockHandler, createBedrockHandler } from "./bedrock-base";
-export {
-	ClaudeCodeHandler,
-	CodexHandler,
-	createClaudeCodeHandler,
-	createCodexHandler,
-	createDifyHandler,
-	createMistralHandler,
-	createOpenCodeHandler,
-	createSapAiCoreHandler,
-	DifyHandler,
-	MistralHandler,
-	OpenCodeHandler,
-	SapAiCoreHandler,
-} from "./community-sdk";
-export { FetchBaseHandler } from "./fetch-base";
-export { createGeminiHandler, GeminiHandler } from "./gemini-base";
-// OpenAI Chat Completions API handler
-export { createOpenAIHandler, OpenAIBaseHandler } from "./openai-base";
-// OpenAI Responses API handler
-export {
-	createOpenAIResponsesHandler,
-	OpenAIResponsesHandler,
-} from "./openai-responses";
-// Provider configurations
-export {
-	clearLiveModelsCatalogCache,
-	clearPrivateModelsCatalogCache,
-	DEFAULT_MODELS_CATALOG_URL,
-	getLiveModelsCatalog,
-	getProviderConfig,
-	isOpenAICompatibleProvider,
-	OPENAI_COMPATIBLE_PROVIDERS,
-	type ProviderDefaults,
-	resolveProviderConfig,
-} from "./providers";
-// R1-based handlers (DeepSeek Reasoner, etc.)
-export { createR1Handler, R1BaseHandler } from "./r1-base";
-// Custom handler registry
-export {
-	clearRegistry,
-	getRegisteredHandler,
-	getRegisteredHandlerAsync,
-	getRegisteredProviderIds,
-	hasRegisteredHandler,
-	isRegisteredHandlerAsync,
-	registerAsyncHandler,
-	registerHandler,
-	unregisterHandler,
-} from "./registry";
-export { createVertexHandler, VertexHandler } from "./vertex";