genai-lite 0.1.0

package/dist/llm/clients/MockClientAdapter.js

@@ -0,0 +1,284 @@
+"use strict";
+// AI Summary: Mock client adapter for testing LLM functionality without making real API calls.
+// Provides deterministic responses based on request content for development and testing.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockClientAdapter = void 0;
+const types_1 = require("./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
+ */
+class MockClientAdapter {
+    constructor(providerId = "openai") {
+        this.providerId = providerId;
+    }
+    /**
+     * 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
+     */
+    async sendMessage(request, apiKey) {
+        // Simulate network delay
+        await this.simulateDelay(100, 500);
+        try {
+            // Check for special test patterns in the last user message
+            const lastMessage = request.messages[request.messages.length - 1];
+            const content = lastMessage?.content?.toLowerCase() || "";
+            // Simulate various error conditions based on message content
+            if (content.includes("error_invalid_key")) {
+                return this.createErrorResponse("Invalid API key provided", types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY, 401, request);
+            }
+            if (content.includes("error_rate_limit")) {
+                return this.createErrorResponse("Rate limit exceeded", types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED, 429, request);
+            }
+            if (content.includes("error_credits")) {
+                return this.createErrorResponse("Insufficient credits", types_1.ADAPTER_ERROR_CODES.INSUFFICIENT_CREDITS, 402, request);
+            }
+            if (content.includes("error_context_length")) {
+                return this.createErrorResponse("Context length exceeded", types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED, 400, request);
+            }
+            if (content.includes("error_model_not_found")) {
+                return this.createErrorResponse("Model not found", types_1.ADAPTER_ERROR_CODES.MODEL_NOT_FOUND, 404, request);
+            }
+            if (content.includes("error_content_filter")) {
+                return this.createErrorResponse("Content filtered due to policy violation", types_1.ADAPTER_ERROR_CODES.CONTENT_FILTER, 400, request);
+            }
+            if (content.includes("error_network")) {
+                return this.createErrorResponse("Network connection failed", types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR, 0, request);
+            }
+            if (content.includes("error_generic")) {
+                return this.createErrorResponse("Generic provider error", types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR, 500, request);
+            }
+            // Generate successful mock response
+            return this.createSuccessResponse(request, content);
+        }
+        catch (error) {
+            return this.createErrorResponse(`Mock adapter error: ${error instanceof Error ? error.message : "Unknown error"}`, types_1.ADAPTER_ERROR_CODES.UNKNOWN_ERROR, 500, request);
+        }
+    }
+    /**
+     * Validates API key format (always returns true for mock)
+     */
+    validateApiKey(apiKey) {
+        return apiKey.length > 0;
+    }
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo() {
+        return {
+            providerId: this.providerId,
+            name: "Mock Client Adapter",
+            version: "1.0.0",
+            supportedModels: ["mock-model-1", "mock-model-2"],
+        };
+    }
+    /**
+     * Creates a successful mock response
+     */
+    createSuccessResponse(request, userContent) {
+        // Generate response content based on user input and settings
+        let responseContent;
+        // Check for settings-based test patterns
+        if (userContent.includes("test_temperature")) {
+            responseContent = this.generateTemperatureTestResponse(request.settings.temperature);
+        }
+        else if (userContent.includes("test_settings")) {
+            responseContent = this.generateSettingsTestResponse(request.settings);
+        }
+        else if (userContent.includes("hello") || userContent.includes("hi")) {
+            responseContent =
+                "Hello! I'm a mock LLM assistant. How can I help you today?";
+        }
+        else if (userContent.includes("weather")) {
+            responseContent =
+                "I'm a mock assistant and don't have access to real weather data, but I can pretend it's sunny and 72°F!";
+        }
+        else if (userContent.includes("code") ||
+            userContent.includes("programming")) {
+            responseContent =
+                'Here\'s some mock code:\n\n```javascript\nfunction mockFunction() {\n  return "This is mock code!";\n}\n```';
+        }
+        else if (userContent.includes("long") ||
+            userContent.includes("detailed")) {
+            responseContent = this.generateLongResponse();
+        }
+        else {
+            responseContent = `You said: "${userContent}". This is a mock response from the ${this.providerId} mock adapter.`;
+        }
+        // Apply creativity based on temperature
+        responseContent = this.applyTemperatureEffects(responseContent, request.settings.temperature);
+        // Apply maxTokens constraint (rough simulation)
+        const originalLength = responseContent.length;
+        if (request.settings.maxTokens && request.settings.maxTokens < 200) {
+            const words = responseContent.split(" ");
+            const maxWords = Math.max(1, Math.floor(request.settings.maxTokens / 4));
+            if (words.length > maxWords) {
+                responseContent = words.slice(0, maxWords).join(" ") + "...";
+            }
+        }
+        // Check for stop sequences
+        if (request.settings.stopSequences.length > 0) {
+            for (const stopSeq of request.settings.stopSequences) {
+                const stopIndex = responseContent.indexOf(stopSeq);
+                if (stopIndex !== -1) {
+                    responseContent = responseContent.substring(0, stopIndex);
+                    break;
+                }
+            }
+        }
+        const mockTokenCount = Math.floor(responseContent.length / 4); // Rough token estimation
+        const promptTokenCount = Math.floor(request.messages.reduce((acc, msg) => acc + msg.content.length, 0) / 4);
+        // Determine finish reason
+        let finishReason = "stop";
+        if (originalLength > responseContent.length &&
+            request.settings.maxTokens &&
+            mockTokenCount >= request.settings.maxTokens) {
+            finishReason = "length";
+        }
+        else if (request.settings.stopSequences.some((seq) => responseContent.includes(seq))) {
+            finishReason = "stop";
+        }
+        return {
+            id: `mock-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            provider: request.providerId,
+            model: request.modelId,
+            created: Math.floor(Date.now() / 1000),
+            choices: [
+                {
+                    message: {
+                        role: "assistant",
+                        content: responseContent,
+                    },
+                    finish_reason: finishReason,
+                    index: 0,
+                },
+            ],
+            usage: {
+                prompt_tokens: promptTokenCount,
+                completion_tokens: mockTokenCount,
+                total_tokens: promptTokenCount + mockTokenCount,
+            },
+            object: "chat.completion",
+        };
+    }
+    /**
+     * Generates a response that demonstrates temperature effects
+     */
+    generateTemperatureTestResponse(temperature) {
+        if (temperature < 0.3) {
+            return "Low temperature setting detected. This response should be more deterministic and focused.";
+        }
+        else if (temperature > 0.8) {
+            return "High temperature setting detected! This response should be more creative, varied, and potentially surprising in its word choices and structure.";
+        }
+        else {
+            return "Moderate temperature setting detected. This response balances consistency with some creative variation.";
+        }
+    }
+    /**
+     * Generates a response that shows current settings
+     */
+    generateSettingsTestResponse(settings) {
+        return `Current mock settings:
+- Temperature: ${settings.temperature}
+- Max Tokens: ${settings.maxTokens}
+- Top P: ${settings.topP}
+- Stop Sequences: ${settings.stopSequences.length > 0
+            ? settings.stopSequences.join(", ")
+            : "none"}
+- Frequency Penalty: ${settings.frequencyPenalty}
+- Presence Penalty: ${settings.presencePenalty}
+- User: ${settings.user || "not set"}`;
+    }
+    /**
+     * Applies mock temperature effects to response content
+     */
+    applyTemperatureEffects(content, temperature) {
+        // At very low temperatures, make responses more formal
+        if (temperature < 0.2) {
+            return content.replace(/!/g, ".").replace(/\?/g, ".");
+        }
+        // At high temperatures, add some creative variations
+        if (temperature > 0.8) {
+            const variations = [
+                content + " 🎯",
+                content + " (with creative flair!)",
+                "✨ " + content,
+                content + " — quite interesting, isn't it?",
+            ];
+            return variations[Math.floor(Math.random() * variations.length)];
+        }
+        return content;
+    }
+    /**
+     * Creates an error response
+     */
+    createErrorResponse(message, code, status, request) {
+        return {
+            provider: request.providerId,
+            model: request.modelId,
+            error: {
+                message,
+                code,
+                type: this.getErrorType(code),
+                ...(status > 0 && { status }),
+            },
+            object: "error",
+        };
+    }
+    /**
+     * Maps error codes to error types
+     */
+    getErrorType(code) {
+        switch (code) {
+            case types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY:
+                return "authentication_error";
+            case types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED:
+            case types_1.ADAPTER_ERROR_CODES.INSUFFICIENT_CREDITS:
+                return "rate_limit_error";
+            case types_1.ADAPTER_ERROR_CODES.MODEL_NOT_FOUND:
+            case types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED:
+                return "invalid_request_error";
+            case types_1.ADAPTER_ERROR_CODES.CONTENT_FILTER:
+                return "content_filter_error";
+            case types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR:
+                return "connection_error";
+            default:
+                return "server_error";
+        }
+    }
+    /**
+     * Generates a longer mock response for testing
+     */
+    generateLongResponse() {
+        return `This is a detailed mock response from the ${this.providerId} adapter. 
+    
+I can simulate various types of responses based on your input. Here are some features:
+
+1. **Error Simulation**: Include phrases like "error_rate_limit" to test error handling
+2. **Variable Length**: Request "long" responses to test token limits
+3. **Code Generation**: Ask about "programming" to get mock code snippets
+4. **Conversational**: Simple greetings work too
+
+The mock adapter is useful for testing the LLM integration without making real API calls. It simulates realistic response times, token usage, and various error conditions that you might encounter with real LLM providers.
+
+This response demonstrates how the adapter can generate longer content while still respecting the maxTokens parameter if specified in the request settings.`;
+    }
+    /**
+     * Simulates network delay with random variation
+     */
+    async simulateDelay(minMs, maxMs) {
+        const delay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+        return new Promise((resolve) => setTimeout(resolve, delay));
+    }
+}
+exports.MockClientAdapter = MockClientAdapter;

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

@@ -0,0 +1,69 @@
+import type { LLMResponse, LLMFailureResponse } from "../types";
+import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+/**
+ * Client adapter for OpenAI API integration
+ *
+ * This adapter:
+ * - Formats requests according to OpenAI's chat completions API
+ * - Handles OpenAI-specific authentication and headers
+ * - Maps OpenAI responses to standardized LLMResponse format
+ * - Converts OpenAI errors to standardized LLMFailureResponse format
+ */
+export declare class OpenAIClientAdapter implements ILLMClientAdapter {
+    private baseURL?;
+    /**
+     * Creates a new OpenAI client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL for OpenAI-compatible APIs
+     */
+    constructor(config?: {
+        baseURL?: string;
+    });
+    /**
+     * Sends a chat message to OpenAI's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted OpenAI API key
+     * @returns Promise resolving to success or failure response
+     */
+    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    /**
+     * Validates OpenAI 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: "openai";
+        name: string;
+        version: string;
+    };
+    /**
+     * Formats messages for OpenAI API
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted messages array for OpenAI
+     */
+    private formatMessages;
+    /**
+     * Creates a standardized success response from OpenAI's response
+     *
+     * @param completion - Raw OpenAI completion response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    private createSuccessResponse;
+    /**
+     * Creates a standardized error response from OpenAI errors
+     *
+     * @param error - The error from OpenAI API
+     * @param request - Original request for context
+     * @returns Standardized LLM failure response
+     */
+    private createErrorResponse;
+}

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -0,0 +1,227 @@
+"use strict";
+// AI Summary: OpenAI client adapter for making real API calls to OpenAI's chat completions endpoint.
+// Handles 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.OpenAIClientAdapter = void 0;
+const openai_1 = __importDefault(require("openai"));
+const types_1 = require("./types");
+const adapterErrorUtils_1 = require("./adapterErrorUtils");
+/**
+ * Client adapter for OpenAI API integration
+ *
+ * This adapter:
+ * - Formats requests according to OpenAI's chat completions API
+ * - Handles OpenAI-specific authentication and headers
+ * - Maps OpenAI responses to standardized LLMResponse format
+ * - Converts OpenAI errors to standardized LLMFailureResponse format
+ */
+class OpenAIClientAdapter {
+    /**
+     * Creates a new OpenAI client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL for OpenAI-compatible APIs
+     */
+    constructor(config) {
+        this.baseURL = config?.baseURL;
+    }
+    /**
+     * Sends a chat message to OpenAI's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted OpenAI API key
+     * @returns Promise resolving to success or failure response
+     */
+    async sendMessage(request, apiKey) {
+        try {
+            // Initialize OpenAI client
+            const openai = new openai_1.default({
+                apiKey,
+                ...(this.baseURL && { baseURL: this.baseURL }),
+            });
+            // Format messages for OpenAI API
+            const messages = this.formatMessages(request);
+            // Prepare API call parameters
+            const completionParams = {
+                model: request.modelId,
+                messages: messages,
+                temperature: request.settings.temperature,
+                max_completion_tokens: request.settings.maxTokens,
+                top_p: request.settings.topP,
+                ...(request.settings.stopSequences.length > 0 && {
+                    stop: request.settings.stopSequences,
+                }),
+                ...(request.settings.frequencyPenalty !== 0 && {
+                    frequency_penalty: request.settings.frequencyPenalty,
+                }),
+                ...(request.settings.presencePenalty !== 0 && {
+                    presence_penalty: request.settings.presencePenalty,
+                }),
+                ...(request.settings.user && {
+                    user: request.settings.user,
+                }),
+            };
+            console.log(`OpenAI API parameters:`, {
+                model: completionParams.model,
+                temperature: completionParams.temperature,
+                max_completion_tokens: completionParams.max_completion_tokens,
+                top_p: completionParams.top_p,
+                hasStop: !!completionParams.stop,
+                frequency_penalty: completionParams.frequency_penalty,
+                presence_penalty: completionParams.presence_penalty,
+                hasUser: !!completionParams.user,
+            });
+            console.log(`Making OpenAI API call for model: ${request.modelId}`);
+            // Make the API call
+            const completion = await openai.chat.completions.create(completionParams);
+            // Type guard to ensure we have a non-streaming response
+            if ('id' in completion && 'choices' in completion) {
+                console.log(`OpenAI API call successful, response ID: ${completion.id}`);
+                // Convert to standardized response format
+                return this.createSuccessResponse(completion, request);
+            }
+            else {
+                throw new Error('Unexpected streaming response from OpenAI API');
+            }
+        }
+        catch (error) {
+            console.error("OpenAI API error:", error);
+            return this.createErrorResponse(error, request);
+        }
+    }
+    /**
+     * Validates OpenAI API key format
+     *
+     * @param apiKey - The API key to validate
+     * @returns True if the key format appears valid
+     */
+    validateApiKey(apiKey) {
+        // OpenAI API keys typically start with 'sk-' and are at least 20 characters
+        return apiKey.startsWith("sk-") && apiKey.length >= 20;
+    }
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo() {
+        return {
+            providerId: "openai",
+            name: "OpenAI Client Adapter",
+            version: "1.0.0",
+        };
+    }
+    /**
+     * Formats messages for OpenAI API
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted messages array for OpenAI
+     */
+    formatMessages(request) {
+        const messages = [];
+        // Add system message if provided
+        if (request.systemMessage) {
+            messages.push({
+                role: "system",
+                content: request.systemMessage,
+            });
+        }
+        // Add conversation messages
+        for (const message of request.messages) {
+            if (message.role === "system") {
+                // Handle system messages in conversation
+                messages.push({
+                    role: "system",
+                    content: 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,
+                });
+            }
+        }
+        return messages;
+    }
+    /**
+     * Creates a standardized success response from OpenAI's response
+     *
+     * @param completion - Raw OpenAI completion response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    createSuccessResponse(completion, request) {
+        const choice = completion.choices[0];
+        if (!choice || !choice.message) {
+            throw new Error("Invalid completion structure from OpenAI API");
+        }
+        return {
+            id: completion.id,
+            provider: request.providerId,
+            model: completion.model || request.modelId,
+            created: completion.created,
+            choices: [
+                {
+                    message: {
+                        role: choice.message.role,
+                        content: choice.message.content || "",
+                    },
+                    finish_reason: choice.finish_reason,
+                    index: choice.index,
+                },
+            ],
+            usage: completion.usage
+                ? {
+                    prompt_tokens: completion.usage.prompt_tokens,
+                    completion_tokens: completion.usage.completion_tokens,
+                    total_tokens: completion.usage.total_tokens,
+                }
+                : undefined,
+            object: "chat.completion",
+        };
+    }
+    /**
+     * Creates a standardized error response from OpenAI errors
+     *
+     * @param error - The error from OpenAI 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 openai_1.default.APIError ? error.message : undefined;
+        let { errorCode, errorMessage, errorType, status } = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
+        // Apply OpenAI-specific refinements for 400 errors based on message content
+        if (error instanceof openai_1.default.APIError && status === 400) {
+            if (error.message.toLowerCase().includes("context length")) {
+                errorCode = types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED;
+            }
+            else if (error.message.toLowerCase().includes("content policy")) {
+                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.OpenAIClientAdapter = OpenAIClientAdapter;

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

@@ -0,0 +1,26 @@
+import { type AdapterErrorCode } from './types';
+/**
+ * Mapped error details returned by the utility function
+ */
+export interface MappedErrorDetails {
+    errorCode: AdapterErrorCode;
+    errorMessage: string;
+    errorType: string;
+    status?: number;
+}
+/**
+ * Maps common error patterns to standardized error codes and types
+ *
+ * This utility handles:
+ * - Common HTTP status codes (401, 402, 404, 429, 4xx, 5xx)
+ * - Network connection errors (ENOTFOUND, ECONNREFUSED, timeouts)
+ * - Generic JavaScript errors
+ *
+ * Individual adapters can further refine the mappings for provider-specific cases,
+ * particularly for 400 errors where message content determines the specific error type.
+ *
+ * @param error - The error object from the provider SDK or network layer
+ * @param providerMessageOverride - Optional override for the error message (e.g., from provider SDK)
+ * @returns Mapped error details with standardized codes and types
+ */
+export declare function getCommonMappedErrorDetails(error: any, providerMessageOverride?: string): MappedErrorDetails;