ai.libx.js 0.1.1

package/src/adapters/cohere.ts

@@ -0,0 +1,158 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk, Message } from '../types';
+import { streamLines } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+interface CohereChatMessage {
+	role: 'USER' | 'CHATBOT' | 'SYSTEM';
+	message: string;
+}
+
+interface CohereRequest {
+	model?: string;
+	message: string;
+	chat_history?: Array<{ role: 'USER' | 'CHATBOT'; message: string; }>;
+	preamble?: string;
+	temperature?: number;
+	max_tokens?: number;
+	p?: number;
+	stop_sequences?: string[];
+	stream?: boolean;
+}
+
+/**
+ * Cohere API adapter
+ */
+export class CohereAdapter extends BaseAdapter {
+	get name(): string {
+		return 'cohere';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.cohere.ai/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^cohere\//, '');
+
+			// Transform messages to Cohere format
+			const { message, chatHistory, preamble } = this.transformMessages(options.messages);
+
+			const request: CohereRequest = {
+				message,
+				stream: options.stream || false,
+			};
+
+			// Add model if specified
+			if (model) request.model = model;
+
+			// Add chat history
+			if (chatHistory.length > 0) {
+				request.chat_history = chatHistory;
+			}
+
+			// Add preamble (system message)
+			if (preamble) {
+				request.preamble = preamble;
+			}
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.p = options.topP;
+			if (options.stop && Array.isArray(options.stop)) {
+				request.stop_sequences = options.stop;
+			}
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private transformMessages(messages: Message[]): {
+		message: string;
+		chatHistory: Array<{ role: 'USER' | 'CHATBOT'; message: string; }>;
+		preamble?: string;
+	} {
+		const systemMessage = messages.find((m) => m.role === 'system');
+		const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+
+		// Last message is the current message
+		const lastMessage = nonSystemMessages[nonSystemMessages.length - 1];
+		const historyMessages = nonSystemMessages.slice(0, -1);
+
+		return {
+			message: lastMessage?.content || '',
+			chatHistory: historyMessages.map((msg) => ({
+				role: msg.role === 'user' ? 'USER' : 'CHATBOT',
+				message: msg.content,
+			})),
+			preamble: systemMessage?.content,
+		};
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		return {
+			content: data.text || '',
+			finishReason: data.finish_reason,
+			usage: data.meta?.tokens ? {
+				promptTokens: data.meta.tokens.input_tokens || 0,
+				completionTokens: data.meta.tokens.output_tokens || 0,
+				totalTokens: (data.meta.tokens.input_tokens || 0) + (data.meta.tokens.output_tokens || 0),
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const line of streamLines(response.body)) {
+			try {
+				const chunk = JSON.parse(line);
+
+				if (chunk.event_type === 'text-generation') {
+					yield {
+						content: chunk.text || '',
+					};
+				} else if (chunk.event_type === 'stream-end') {
+					yield {
+						content: '',
+						finishReason: chunk.finish_reason,
+					};
+				}
+			} catch (e) {
+				// Skip invalid JSON
+				continue;
+			}
+		}
+	}
+}
+

package/src/adapters/deepseek.ts

@@ -0,0 +1,108 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+/**
+ * DeepSeek API adapter (uses OpenAI-compatible API)
+ */
+export class DeepSeekAdapter extends BaseAdapter {
+	get name(): string {
+		return 'deepseek';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.deepseek.com/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^deepseek\//, '');
+
+			const request: any = {
+				model,
+				messages: options.messages.map((msg) => ({
+					role: msg.role,
+					content: msg.content,
+				})),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.frequencyPenalty !== undefined) request.frequency_penalty = options.frequencyPenalty;
+			if (options.presencePenalty !== undefined) request.presence_penalty = options.presencePenalty;
+			if (options.stop !== undefined) request.stop = options.stop;
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+

package/src/adapters/google.ts

@@ -0,0 +1,170 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk, Message } from '../types';
+import { streamLines } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+interface GooglePart {
+	text: string;
+}
+
+interface GoogleContent {
+	role: string;
+	parts: GooglePart[];
+}
+
+interface GoogleRequest {
+	contents: GoogleContent[];
+	generationConfig?: {
+		temperature?: number;
+		maxOutputTokens?: number;
+		topP?: number;
+		topK?: number;
+		stopSequences?: string[];
+	};
+	systemInstruction?: {
+		parts: GooglePart[];
+	};
+}
+
+/**
+ * Google Gemini API adapter
+ */
+export class GoogleAdapter extends BaseAdapter {
+	get name(): string {
+		return 'google';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://generativelanguage.googleapis.com/v1beta');
+
+			// Strip provider prefix from model if present (e.g., "google/models/gemini-2.5-pro" -> "models/gemini-2.5-pro")
+			let model = options.model.replace(/^google\//, '');
+
+			// Ensure model has "models/" prefix for API
+			if (!model.startsWith('models/')) {
+				model = `models/${model}`;
+			}
+
+			// Extract system message if present
+			const systemMessage = options.messages.find((m) => m.role === 'system');
+			const nonSystemMessages = options.messages.filter((m) => m.role !== 'system');
+
+			const request: GoogleRequest = {
+				contents: this.transformMessages(nonSystemMessages),
+			};
+
+			// Add system instruction
+			if (systemMessage) {
+				request.systemInstruction = {
+					parts: [{ text: systemMessage.content }],
+				};
+			}
+
+			// Add generation config
+			const generationConfig: any = {};
+			if (options.temperature !== undefined) generationConfig.temperature = options.temperature;
+			if (options.maxTokens !== undefined) generationConfig.maxOutputTokens = options.maxTokens;
+			if (options.topP !== undefined) generationConfig.topP = options.topP;
+			if (options.topK !== undefined) generationConfig.topK = options.topK;
+			if (options.stop && Array.isArray(options.stop)) {
+				generationConfig.stopSequences = options.stop;
+			}
+
+			if (Object.keys(generationConfig).length > 0) {
+				request.generationConfig = generationConfig;
+			}
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const endpoint = options.stream ? 'streamGenerateContent' : 'generateContent';
+			const url = `${baseUrl}/${model}:${endpoint}?key=${apiKey}`;
+
+			const response = await this.fetchWithErrorHandling(
+				url,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private transformMessages(messages: Message[]): GoogleContent[] {
+		return messages.map((msg) => ({
+			role: msg.role === 'assistant' ? 'model' : 'user',
+			parts: [{ text: msg.content }],
+		}));
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const candidate = data.candidates?.[0];
+		if (!candidate) {
+			throw new Error('No candidates in response');
+		}
+
+		const content = candidate.content?.parts?.[0]?.text || '';
+
+		return {
+			content,
+			finishReason: candidate.finishReason,
+			usage: data.usageMetadata ? {
+				promptTokens: data.usageMetadata.promptTokenCount || 0,
+				completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+				totalTokens: data.usageMetadata.totalTokenCount || 0,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const line of streamLines(response.body)) {
+			if (!line.trim() || line.trim() === '[' || line.trim() === ']') continue;
+
+			// Remove trailing comma if present
+			const cleanLine = line.trim().replace(/,$/, '');
+
+			try {
+				const chunk = JSON.parse(cleanLine);
+				const candidate = chunk.candidates?.[0];
+
+				if (!candidate) continue;
+
+				const content = candidate.content?.parts?.[0]?.text || '';
+				const finishReason = candidate.finishReason;
+
+				if (content || finishReason) {
+					yield {
+						content,
+						finishReason,
+					};
+				}
+			} catch (e) {
+				// Skip invalid JSON
+				continue;
+			}
+		}
+	}
+}
+

package/src/adapters/groq.ts

@@ -0,0 +1,108 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+/**
+ * Groq API adapter (uses OpenAI-compatible API)
+ */
+export class GroqAdapter extends BaseAdapter {
+	get name(): string {
+		return 'groq';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.groq.com/openai/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^groq\//, '');
+
+			const request: any = {
+				model,
+				messages: options.messages.map((msg) => ({
+					role: msg.role,
+					content: msg.content,
+				})),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.frequencyPenalty !== undefined) request.frequency_penalty = options.frequencyPenalty;
+			if (options.presencePenalty !== undefined) request.presence_penalty = options.presencePenalty;
+			if (options.stop !== undefined) request.stop = options.stop;
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+

package/src/adapters/index.ts

@@ -0,0 +1,14 @@
+// Export all adapters for direct usage
+export { BaseAdapter } from './base/BaseAdapter';
+export { OpenAIAdapter } from './openai';
+export { AnthropicAdapter } from './anthropic';
+export { GoogleAdapter } from './google';
+export { GroqAdapter } from './groq';
+export { MistralAdapter } from './mistral';
+export { CohereAdapter } from './cohere';
+export { XAIAdapter } from './xai';
+export { DeepSeekAdapter } from './deepseek';
+export { AI21Adapter } from './ai21';
+export { OpenRouterAdapter } from './openrouter';
+export { CloudflareAdapter } from './cloudflare';
+

package/src/adapters/mistral.ts

@@ -0,0 +1,108 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+/**
+ * Mistral AI API adapter
+ */
+export class MistralAdapter extends BaseAdapter {
+	get name(): string {
+		return 'mistral';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.mistral.ai/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^mistral\//, '');
+
+			const request: any = {
+				model,
+				messages: options.messages.map((msg) => ({
+					role: msg.role,
+					content: msg.content,
+				})),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.stop && Array.isArray(options.stop)) {
+				request.stop = options.stop;
+			}
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+