genai-lite 0.1.0

package/dist/llm/clients/AnthropicClientAdapter.js

@@ -0,0 +1,281 @@
+"use strict";
+// AI Summary: Anthropic client adapter for making real API calls to Anthropic's messages endpoint.
+// Handles Claude-specific request formatting, response parsing, and error mapping to standardized format.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicClientAdapter = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const types_1 = require("./types");
+const adapterErrorUtils_1 = require("./adapterErrorUtils");
+/**
+ * Client adapter for Anthropic API integration
+ *
+ * This adapter:
+ * - Formats requests according to Anthropic's messages API requirements
+ * - Handles Claude-specific system message positioning and formatting
+ * - Maps Anthropic responses to standardized LLMResponse format
+ * - Converts Anthropic errors to standardized LLMFailureResponse format
+ * - Manages Claude-specific settings and constraints
+ */
+class AnthropicClientAdapter {
+    /**
+     * Creates a new Anthropic client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL for Anthropic-compatible APIs
+     */
+    constructor(config) {
+        this.baseURL = config?.baseURL;
+    }
+    /**
+     * Sends a chat message to Anthropic's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted Anthropic API key
+     * @returns Promise resolving to success or failure response
+     */
+    async sendMessage(request, apiKey) {
+        try {
+            // Initialize Anthropic client
+            const anthropic = new sdk_1.default({
+                apiKey,
+                ...(this.baseURL && { baseURL: this.baseURL }),
+            });
+            // Format messages for Anthropic API (Claude has specific requirements)
+            const { messages, systemMessage } = this.formatMessagesForAnthropic(request);
+            // Prepare API call parameters
+            const messageParams = {
+                model: request.modelId,
+                messages: messages,
+                max_tokens: request.settings.maxTokens,
+                temperature: request.settings.temperature,
+                top_p: request.settings.topP,
+                ...(systemMessage && { system: systemMessage }),
+                ...(request.settings.stopSequences.length > 0 && {
+                    stop_sequences: request.settings.stopSequences,
+                }),
+            };
+            console.log(`Making Anthropic API call for model: ${request.modelId}`);
+            console.log(`Anthropic API parameters:`, {
+                model: messageParams.model,
+                temperature: messageParams.temperature,
+                max_tokens: messageParams.max_tokens,
+                top_p: messageParams.top_p,
+                hasSystem: !!messageParams.system,
+                messageCount: messages.length,
+                hasStopSequences: !!messageParams.stop_sequences,
+            });
+            // Make the API call
+            const completion = await anthropic.messages.create(messageParams);
+            console.log(`Anthropic API call successful, response ID: ${completion.id}`);
+            // Convert to standardized response format
+            return this.createSuccessResponse(completion, request);
+        }
+        catch (error) {
+            console.error("Anthropic API error:", error);
+            return this.createErrorResponse(error, request);
+        }
+    }
+    /**
+     * Validates Anthropic API key format
+     *
+     * @param apiKey - The API key to validate
+     * @returns True if the key format appears valid
+     */
+    validateApiKey(apiKey) {
+        // Anthropic API keys typically start with 'sk-ant-' and are longer
+        return apiKey.startsWith("sk-ant-") && apiKey.length >= 30;
+    }
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo() {
+        return {
+            providerId: "anthropic",
+            name: "Anthropic Client Adapter",
+            version: "1.0.0",
+        };
+    }
+    /**
+     * Formats messages for Anthropic API with proper system message handling
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted messages and system message for Anthropic
+     */
+    formatMessagesForAnthropic(request) {
+        const messages = [];
+        let systemMessage = request.systemMessage;
+        // Process conversation messages
+        for (const message of request.messages) {
+            if (message.role === "system") {
+                // Anthropic handles system messages separately
+                // If we already have a system message, append to it
+                if (systemMessage) {
+                    systemMessage += "\n\n" + message.content;
+                }
+                else {
+                    systemMessage = message.content;
+                }
+            }
+            else if (message.role === "user") {
+                messages.push({
+                    role: "user",
+                    content: message.content,
+                });
+            }
+            else if (message.role === "assistant") {
+                messages.push({
+                    role: "assistant",
+                    content: message.content,
+                });
+            }
+        }
+        // Anthropic requires messages to start with 'user' role
+        // If the first message is not from user, we need to handle this
+        if (messages.length > 0 && messages[0].role !== "user") {
+            console.warn("Anthropic API requires first message to be from user. Adjusting message order.");
+            // Find the first user message and move it to the front, or create a default one
+            const firstUserIndex = messages.findIndex((msg) => msg.role === "user");
+            if (firstUserIndex > 0) {
+                const firstUserMessage = messages.splice(firstUserIndex, 1)[0];
+                messages.unshift(firstUserMessage);
+            }
+            else if (firstUserIndex === -1) {
+                // No user message found, create a default one
+                messages.unshift({
+                    role: "user",
+                    content: "Please respond based on the previous context.",
+                });
+            }
+        }
+        // Ensure alternating user/assistant pattern (Anthropic requirement)
+        const cleanedMessages = this.ensureAlternatingRoles(messages);
+        return {
+            messages: cleanedMessages,
+            systemMessage,
+        };
+    }
+    /**
+     * Ensures messages alternate between user and assistant roles as required by Anthropic
+     *
+     * @param messages - Original messages array
+     * @returns Cleaned messages with proper alternating pattern
+     */
+    ensureAlternatingRoles(messages) {
+        if (messages.length === 0)
+            return messages;
+        const cleanedMessages = [];
+        let expectedRole = "user";
+        for (const message of messages) {
+            if (message.role === expectedRole) {
+                cleanedMessages.push(message);
+                expectedRole = expectedRole === "user" ? "assistant" : "user";
+            }
+            else if (message.role === "user" || message.role === "assistant") {
+                // If roles don't alternate properly, we might need to combine messages
+                // or insert a placeholder. For now, we'll skip non-alternating messages
+                // and log a warning.
+                console.warn(`Skipping message with unexpected role: expected ${expectedRole}, got ${message.role}`);
+            }
+        }
+        return cleanedMessages;
+    }
+    /**
+     * Creates a standardized success response from Anthropic's response
+     *
+     * @param completion - Raw Anthropic completion response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    createSuccessResponse(completion, request) {
+        // Anthropic returns content as an array of content blocks
+        const contentBlock = completion.content[0];
+        if (!contentBlock || contentBlock.type !== "text") {
+            throw new Error("Invalid completion structure from Anthropic API");
+        }
+        // Map Anthropic's stop reason to our standard format
+        const finishReason = this.mapAnthropicStopReason(completion.stop_reason);
+        return {
+            id: completion.id,
+            provider: request.providerId,
+            model: completion.model || request.modelId,
+            created: Math.floor(Date.now() / 1000), // Anthropic doesn't provide created timestamp
+            choices: [
+                {
+                    message: {
+                        role: "assistant",
+                        content: contentBlock.text,
+                    },
+                    finish_reason: finishReason,
+                    index: 0,
+                },
+            ],
+            usage: completion.usage
+                ? {
+                    prompt_tokens: completion.usage.input_tokens,
+                    completion_tokens: completion.usage.output_tokens,
+                    total_tokens: completion.usage.input_tokens + completion.usage.output_tokens,
+                }
+                : undefined,
+            object: "chat.completion",
+        };
+    }
+    /**
+     * Maps Anthropic stop reasons to standardized format
+     *
+     * @param anthropicReason - The stop reason from Anthropic
+     * @returns Standardized finish reason
+     */
+    mapAnthropicStopReason(anthropicReason) {
+        if (!anthropicReason)
+            return null;
+        const reasonMap = {
+            end_turn: "stop",
+            max_tokens: "length",
+            stop_sequence: "stop",
+            content_filter: "content_filter",
+            tool_use: "tool_calls",
+        };
+        return reasonMap[anthropicReason] || "other";
+    }
+    /**
+     * Creates a standardized error response from Anthropic errors
+     *
+     * @param error - The error from Anthropic API
+     * @param request - Original request for context
+     * @returns Standardized LLM failure response
+     */
+    createErrorResponse(error, request) {
+        // Use shared error mapping utility for common error patterns
+        const initialProviderMessage = error instanceof sdk_1.default.APIError ? error.message : undefined;
+        let { errorCode, errorMessage, errorType, status } = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
+        // Apply Anthropic-specific refinements for 400 errors based on message content
+        if (error instanceof sdk_1.default.APIError && status === 400) {
+            if (error.message.toLowerCase().includes("context length") ||
+                error.message.toLowerCase().includes("too long")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED;
+            }
+            else if (error.message.toLowerCase().includes("content policy") ||
+                error.message.toLowerCase().includes("safety")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.CONTENT_FILTER;
+                errorType = "content_filter_error";
+            }
+            // For other 400 errors, use the default mapping from the utility (PROVIDER_ERROR)
+        }
+        return {
+            provider: request.providerId,
+            model: request.modelId,
+            error: {
+                message: errorMessage,
+                code: errorCode,
+                type: errorType,
+                ...(status && { status }),
+                providerError: error,
+            },
+            object: "error",
+        };
+    }
+}
+exports.AnthropicClientAdapter = AnthropicClientAdapter;

package/dist/llm/clients/GeminiClientAdapter.d.ts

@@ -0,0 +1,83 @@
+import type { LLMResponse, LLMFailureResponse } from "../types";
+import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+/**
+ * Client adapter for Google Gemini API integration
+ *
+ * This adapter:
+ * - Formats requests according to Gemini's generative AI API requirements
+ * - Handles Gemini-specific safety settings and system instructions
+ * - Maps Gemini responses to standardized LLMResponse format
+ * - Converts Gemini errors to standardized LLMFailureResponse format
+ * - Manages Gemini-specific settings and constraints
+ */
+export declare class GeminiClientAdapter implements ILLMClientAdapter {
+    private baseURL?;
+    /**
+     * Creates a new Gemini client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL (unused for Gemini but kept for consistency)
+     */
+    constructor(config?: {
+        baseURL?: string;
+    });
+    /**
+     * Sends a chat message to Gemini's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted Gemini API key
+     * @returns Promise resolving to success or failure response
+     */
+    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    /**
+     * Validates Gemini API key format
+     *
+     * @param apiKey - The API key to validate
+     * @returns True if the key format appears valid
+     */
+    validateApiKey(apiKey: string): boolean;
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo(): {
+        providerId: "gemini";
+        name: string;
+        version: string;
+    };
+    /**
+     * Formats the internal LLM request for Gemini API
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted request components for Gemini
+     */
+    private formatInternalRequestToGemini;
+    /**
+     * Creates a standardized success response from Gemini's response
+     *
+     * @param response - Raw Gemini response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    private createSuccessResponse;
+    /**
+     * Maps Gemini finish reasons to standardized format
+     *
+     * @param geminiReason - The finish reason from Gemini
+     * @returns Standardized finish reason
+     */
+    private mapGeminiFinishReason;
+    /**
+     * Creates a standardized error response from Gemini errors
+     *
+     * @param error - The error from Gemini API
+     * @param request - Original request for context
+     * @returns Standardized LLM failure response
+     */
+    private createErrorResponse;
+    /**
+     * Generates a unique response ID
+     *
+     * @returns A unique response ID string
+     */
+    private generateResponseId;
+}

package/dist/llm/clients/GeminiClientAdapter.js

@@ -0,0 +1,266 @@
+"use strict";
+// AI Summary: Gemini client adapter for making real API calls to Google's Gemini LLM APIs.
+// Handles Gemini-specific request formatting, safety settings, response parsing, and error mapping.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiClientAdapter = void 0;
+const genai_1 = require("@google/genai");
+const types_1 = require("./types");
+const adapterErrorUtils_1 = require("./adapterErrorUtils");
+/**
+ * Client adapter for Google Gemini API integration
+ *
+ * This adapter:
+ * - Formats requests according to Gemini's generative AI API requirements
+ * - Handles Gemini-specific safety settings and system instructions
+ * - Maps Gemini responses to standardized LLMResponse format
+ * - Converts Gemini errors to standardized LLMFailureResponse format
+ * - Manages Gemini-specific settings and constraints
+ */
+class GeminiClientAdapter {
+    /**
+     * Creates a new Gemini client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL (unused for Gemini but kept for consistency)
+     */
+    constructor(config) {
+        this.baseURL = config?.baseURL;
+    }
+    /**
+     * Sends a chat message to Gemini's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted Gemini API key
+     * @returns Promise resolving to success or failure response
+     */
+    async sendMessage(request, apiKey) {
+        try {
+            // Initialize Gemini client
+            const genAI = new genai_1.GoogleGenAI({ apiKey });
+            // Format the request for Gemini API
+            const { contents, generationConfig, safetySettings, systemInstruction } = this.formatInternalRequestToGemini(request);
+            console.log(`Making Gemini API call for model: ${request.modelId}`);
+            console.log(`Gemini API parameters:`, {
+                model: request.modelId,
+                temperature: generationConfig.temperature,
+                maxOutputTokens: generationConfig.maxOutputTokens,
+                hasSystemInstruction: !!systemInstruction,
+                contentsLength: contents.length,
+                safetySettingsCount: safetySettings?.length || 0,
+            });
+            // Generate content using the modern API
+            const result = await genAI.models.generateContent({
+                model: request.modelId,
+                contents: contents,
+                config: {
+                    ...generationConfig,
+                    safetySettings: safetySettings,
+                    ...(systemInstruction && { systemInstruction: systemInstruction }),
+                },
+            });
+            console.log(`Gemini API call successful, processing response`);
+            // Convert to standardized response format
+            return this.createSuccessResponse(result, request);
+        }
+        catch (error) {
+            console.error("Gemini API error:", error);
+            return this.createErrorResponse(error, request);
+        }
+    }
+    /**
+     * Validates Gemini API key format
+     *
+     * @param apiKey - The API key to validate
+     * @returns True if the key format appears valid
+     */
+    validateApiKey(apiKey) {
+        // Gemini API keys typically start with 'AIza' and are around 39 characters long
+        return (typeof apiKey === "string" &&
+            apiKey.startsWith("AIza") &&
+            apiKey.length >= 35);
+    }
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo() {
+        return {
+            providerId: "gemini",
+            name: "Gemini Client Adapter",
+            version: "1.0.0",
+        };
+    }
+    /**
+     * Formats the internal LLM request for Gemini API
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted request components for Gemini
+     */
+    formatInternalRequestToGemini(request) {
+        const contents = [];
+        let systemInstruction = request.systemMessage;
+        // Process messages - separate system messages and build conversation contents
+        for (const message of request.messages) {
+            if (message.role === "system") {
+                // Gemini handles system messages as systemInstruction
+                if (systemInstruction) {
+                    systemInstruction += "\n\n" + message.content;
+                }
+                else {
+                    systemInstruction = message.content;
+                }
+            }
+            else if (message.role === "user") {
+                contents.push({
+                    role: "user",
+                    parts: [{ text: message.content }],
+                });
+            }
+            else if (message.role === "assistant") {
+                // Map assistant to model for Gemini
+                contents.push({
+                    role: "model",
+                    parts: [{ text: message.content }],
+                });
+            }
+        }
+        // Build generation config
+        const generationConfig = {
+            maxOutputTokens: request.settings.maxTokens,
+            temperature: request.settings.temperature,
+            ...(request.settings.topP && { topP: request.settings.topP }),
+            ...(request.settings.stopSequences &&
+                request.settings.stopSequences.length > 0 && {
+                stopSequences: request.settings.stopSequences,
+            }),
+        };
+        // Map safety settings from Athanor format to Gemini SDK format
+        const safetySettings = request.settings.geminiSafetySettings?.map((setting) => ({
+            category: setting.category,
+            threshold: setting.threshold,
+        }));
+        return {
+            contents,
+            generationConfig,
+            safetySettings,
+            systemInstruction,
+        };
+    }
+    /**
+     * Creates a standardized success response from Gemini's response
+     *
+     * @param response - Raw Gemini response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    createSuccessResponse(response, request) {
+        // Extract content from the response object
+        const candidate = response.candidates?.[0];
+        const content = candidate?.content?.parts?.[0]?.text || "";
+        // Extract usage data if available
+        const usageMetadata = response.usageMetadata || {};
+        const finishReason = this.mapGeminiFinishReason(candidate?.finishReason || null);
+        return {
+            id: this.generateResponseId(),
+            provider: request.providerId,
+            model: response.modelUsed || request.modelId,
+            created: Math.floor(Date.now() / 1000),
+            choices: [
+                {
+                    message: {
+                        role: "assistant",
+                        content: content,
+                    },
+                    finish_reason: finishReason,
+                    index: 0,
+                },
+            ],
+            usage: usageMetadata
+                ? {
+                    prompt_tokens: usageMetadata.promptTokenCount || 0,
+                    completion_tokens: usageMetadata.candidatesTokenCount || 0,
+                    total_tokens: usageMetadata.totalTokenCount || 0,
+                }
+                : undefined,
+            object: "chat.completion",
+        };
+    }
+    /**
+     * Maps Gemini finish reasons to standardized format
+     *
+     * @param geminiReason - The finish reason from Gemini
+     * @returns Standardized finish reason
+     */
+    mapGeminiFinishReason(geminiReason) {
+        if (!geminiReason)
+            return null;
+        const reasonMap = {
+            STOP: "stop",
+            MAX_TOKENS: "length",
+            SAFETY: "content_filter",
+            RECITATION: "content_filter",
+            PROHIBITED_CONTENT: "content_filter",
+            SPII: "content_filter",
+            BLOCKLIST: "content_filter",
+            LANGUAGE: "other",
+            OTHER: "other",
+            MALFORMED_FUNCTION_CALL: "function_call_error",
+        };
+        return reasonMap[geminiReason] || "other";
+    }
+    /**
+     * Creates a standardized error response from Gemini errors
+     *
+     * @param error - The error from Gemini API
+     * @param request - Original request for context
+     * @returns Standardized LLM failure response
+     */
+    createErrorResponse(error, request) {
+        // Use shared error mapping utility for common error patterns
+        const initialProviderMessage = error?.message;
+        let { errorCode, errorMessage, errorType, status } = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
+        // Apply Gemini-specific refinements for certain error types
+        if (error && error.message) {
+            const message = error.message.toLowerCase();
+            if (message.includes("context length") || message.includes("too long")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED;
+                errorType = "invalid_request_error";
+            }
+            else if (message.includes("safety") || message.includes("blocked")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.CONTENT_FILTER;
+                errorType = "content_filter_error";
+            }
+            else if (message.includes("api key") ||
+                message.includes("authentication")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY;
+                errorType = "authentication_error";
+            }
+            else if (message.includes("quota") || message.includes("limit")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED;
+                errorType = "rate_limit_error";
+            }
+        }
+        return {
+            provider: request.providerId,
+            model: request.modelId,
+            error: {
+                message: errorMessage,
+                code: errorCode,
+                type: errorType,
+                ...(status && { status }),
+                providerError: error,
+            },
+            object: "error",
+        };
+    }
+    /**
+     * Generates a unique response ID
+     *
+     * @returns A unique response ID string
+     */
+    generateResponseId() {
+        return `gemini-${Date.now()}-${Math.random()
+            .toString(36)
+            .substring(2, 15)}`;
+    }
+}
+exports.GeminiClientAdapter = GeminiClientAdapter;

package/dist/llm/clients/MockClientAdapter.d.ts

@@ -0,0 +1,69 @@
+import type { LLMResponse, LLMFailureResponse, ApiProviderId } from "../types";
+import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+/**
+ * Mock client adapter for testing LLM functionality
+ *
+ * This adapter simulates various LLM provider responses without making real API calls.
+ * It's useful for:
+ * - Testing the LLM service flow
+ * - Development when API keys are not available
+ * - Simulating error conditions
+ * - Performance testing without API costs
+ */
+export declare class MockClientAdapter implements ILLMClientAdapter {
+    private providerId;
+    constructor(providerId?: ApiProviderId);
+    /**
+     * Sends a mock message response based on request content
+     *
+     * @param request - The LLM request
+     * @param apiKey - The API key (ignored for mock)
+     * @returns Promise resolving to mock response
+     */
+    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    /**
+     * Validates API key format (always returns true for mock)
+     */
+    validateApiKey(apiKey: string): boolean;
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo(): {
+        providerId: string;
+        name: string;
+        version: string;
+        supportedModels: string[];
+    };
+    /**
+     * Creates a successful mock response
+     */
+    private createSuccessResponse;
+    /**
+     * Generates a response that demonstrates temperature effects
+     */
+    private generateTemperatureTestResponse;
+    /**
+     * Generates a response that shows current settings
+     */
+    private generateSettingsTestResponse;
+    /**
+     * Applies mock temperature effects to response content
+     */
+    private applyTemperatureEffects;
+    /**
+     * Creates an error response
+     */
+    private createErrorResponse;
+    /**
+     * Maps error codes to error types
+     */
+    private getErrorType;
+    /**
+     * Generates a longer mock response for testing
+     */
+    private generateLongResponse;
+    /**
+     * Simulates network delay with random variation
+     */
+    private simulateDelay;
+}