genai-lite 0.1.0

package/dist/llm/config.js

@@ -0,0 +1,508 @@
+"use strict";
+// AI Summary: Configuration for LLM module including default settings, supported providers, and models.
+// Defines operational parameters and available LLM options for the application.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_MODELS = exports.SUPPORTED_PROVIDERS = exports.MODEL_DEFAULT_SETTINGS = exports.PROVIDER_DEFAULT_SETTINGS = exports.DEFAULT_LLM_SETTINGS = exports.ADAPTER_CONFIGS = exports.ADAPTER_CONSTRUCTORS = void 0;
+exports.getProviderById = getProviderById;
+exports.getModelById = getModelById;
+exports.getModelsByProvider = getModelsByProvider;
+exports.isProviderSupported = isProviderSupported;
+exports.isModelSupported = isModelSupported;
+exports.getDefaultSettingsForModel = getDefaultSettingsForModel;
+exports.validateLLMSettings = validateLLMSettings;
+const OpenAIClientAdapter_1 = require("./clients/OpenAIClientAdapter");
+const AnthropicClientAdapter_1 = require("./clients/AnthropicClientAdapter");
+const GeminiClientAdapter_1 = require("./clients/GeminiClientAdapter");
+// Placeholder for future imports:
+// import { MistralClientAdapter } from './clients/MistralClientAdapter';
+/**
+ * Mapping from provider IDs to their corresponding adapter constructor classes
+ * This enables dynamic registration of client adapters in LLMServiceMain
+ */
+exports.ADAPTER_CONSTRUCTORS = {
+    openai: OpenAIClientAdapter_1.OpenAIClientAdapter,
+    anthropic: AnthropicClientAdapter_1.AnthropicClientAdapter,
+    gemini: GeminiClientAdapter_1.GeminiClientAdapter,
+    // 'mistral': MistralClientAdapter, // Uncomment and add when Mistral adapter is ready
+};
+/**
+ * Optional configuration objects for each adapter
+ * Allows passing parameters like baseURL during instantiation
+ */
+exports.ADAPTER_CONFIGS = {
+    openai: {
+        baseURL: process.env.OPENAI_API_BASE_URL || undefined,
+    },
+    anthropic: {
+        baseURL: process.env.ANTHROPIC_API_BASE_URL || undefined,
+    },
+    // 'gemini': { /* ... Gemini specific config ... */ },
+    // 'mistral': { /* ... Mistral specific config ... */ },
+};
+/**
+ * Default settings applied to all LLM requests unless overridden
+ */
+exports.DEFAULT_LLM_SETTINGS = {
+    temperature: 0.5,
+    maxTokens: 4096,
+    topP: 0.95,
+    stopSequences: [],
+    frequencyPenalty: 0.0,
+    presencePenalty: 0.0,
+    supportsSystemMessage: true,
+    user: undefined, // Will be filtered out when undefined
+    geminiSafetySettings: [
+        { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
+        { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
+        { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
+        { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
+    ],
+};
+/**
+ * Per-provider default setting overrides
+ */
+exports.PROVIDER_DEFAULT_SETTINGS = {
+    openai: {},
+    anthropic: {},
+    gemini: {
+        geminiSafetySettings: [
+            { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "BLOCK_NONE" },
+            { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
+            { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
+            { category: "HARM_CATEGORY_HARASSMENT", threshold: "BLOCK_NONE" },
+        ],
+    },
+    mistral: {},
+};
+/**
+ * Per-model default setting overrides (takes precedence over provider defaults)
+ */
+exports.MODEL_DEFAULT_SETTINGS = {
+    // OpenAI model-specific overrides
+    "o4-mini": { temperature: 1.0 },
+    // Anthropic model-specific overrides
+    // Gemini model-specific overrides
+    // Mistral model-specific overrides
+};
+/**
+ * Supported LLM providers
+ */
+exports.SUPPORTED_PROVIDERS = [
+    {
+        id: "openai",
+        name: "OpenAI",
+        unsupportedParameters: ["frequencyPenalty"],
+    },
+    {
+        id: "anthropic",
+        name: "Anthropic",
+    },
+    {
+        id: "gemini",
+        name: "Google Gemini",
+    },
+    {
+        id: "mistral",
+        name: "Mistral AI",
+    },
+];
+/**
+ * Supported LLM models with their configurations
+ * ModelInfo is similar to Cline model info
+ * See: https://github.com/cline/cline/blob/main/src/shared/api.ts
+ */
+exports.SUPPORTED_MODELS = [
+    // Anthropic Models
+    {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        providerId: "anthropic",
+        contextWindow: 200000,
+        inputPrice: 3.0,
+        outputPrice: 15.0,
+        description: "Latest Claude Sonnet model with enhanced capabilities",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheWritesPrice: 3.75,
+        cacheReadsPrice: 0.3,
+    },
+    {
+        id: "claude-opus-4-20250514",
+        name: "Claude Opus 4",
+        providerId: "anthropic",
+        contextWindow: 200000,
+        inputPrice: 15.0,
+        outputPrice: 75.0,
+        description: "Most powerful Claude model for highly complex tasks",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheWritesPrice: 18.75,
+        cacheReadsPrice: 1.5,
+    },
+    {
+        id: "claude-3-7-sonnet-20250219",
+        name: "Claude 3.7 Sonnet",
+        providerId: "anthropic",
+        contextWindow: 200000,
+        inputPrice: 3.0,
+        outputPrice: 15.0,
+        description: "Advanced Claude model with improved reasoning",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheWritesPrice: 3.75,
+        cacheReadsPrice: 0.3,
+    },
+    {
+        id: "claude-3-5-sonnet-20241022",
+        name: "Claude 3.5 Sonnet",
+        providerId: "anthropic",
+        contextWindow: 200000,
+        inputPrice: 3.0,
+        outputPrice: 15.0,
+        description: "Best balance of intelligence, speed, and cost",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheWritesPrice: 3.75,
+        cacheReadsPrice: 0.3,
+    },
+    {
+        id: "claude-3-5-haiku-20241022",
+        name: "Claude 3.5 Haiku",
+        providerId: "anthropic",
+        contextWindow: 200000,
+        inputPrice: 0.8,
+        outputPrice: 4.0,
+        description: "Fastest and most cost-effective Claude model",
+        maxTokens: 8192,
+        supportsImages: false,
+        supportsPromptCache: true,
+        cacheWritesPrice: 1.0,
+        cacheReadsPrice: 0.08,
+    },
+    // Google Gemini Models
+    {
+        id: "gemini-2.5-pro",
+        name: "Gemini 2.5 Pro",
+        providerId: "gemini",
+        contextWindow: 1048576,
+        inputPrice: 1.25,
+        outputPrice: 10,
+        description: "Most advanced Gemini model for complex reasoning and multimodal tasks",
+        maxTokens: 65536,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.31,
+    },
+    {
+        id: "gemini-2.5-flash",
+        name: "Gemini 2.5 Flash",
+        providerId: "gemini",
+        contextWindow: 1048576,
+        inputPrice: 0.3,
+        outputPrice: 2.5,
+        description: "Fast, efficient model with large context and reasoning capabilities",
+        maxTokens: 65536,
+        supportsImages: true,
+        supportsPromptCache: true,
+        thinkingConfig: {
+            maxBudget: 24576,
+            outputPrice: 2.5,
+        },
+    },
+    {
+        id: "gemini-2.5-flash-lite-preview-06-17",
+        name: "Gemini 2.5 Flash-Lite Preview",
+        providerId: "gemini",
+        contextWindow: 1000000,
+        inputPrice: 0.1,
+        outputPrice: 0.4,
+        description: "Smallest and most cost effective model, built for at scale usage",
+        maxTokens: 64000,
+        supportsImages: true,
+        supportsPromptCache: true,
+    },
+    {
+        id: "gemini-2.0-flash",
+        name: "Gemini 2.0 Flash",
+        providerId: "gemini",
+        contextWindow: 1048576,
+        inputPrice: 0.1,
+        outputPrice: 0.4,
+        description: "High-performance model with multimodal capabilities",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.025,
+        cacheWritesPrice: 1.0,
+    },
+    {
+        id: "gemini-2.0-flash-lite",
+        name: "Gemini 2.0 Flash Lite",
+        providerId: "gemini",
+        contextWindow: 1048576,
+        inputPrice: 0.075,
+        outputPrice: 0.3,
+        description: "Lightweight version of Gemini 2.0 Flash",
+        maxTokens: 8192,
+        supportsImages: true,
+        supportsPromptCache: false,
+    },
+    // OpenAI Models
+    {
+        id: "o4-mini",
+        name: "o4-mini",
+        providerId: "openai",
+        contextWindow: 200000,
+        inputPrice: 1.1,
+        outputPrice: 4.4,
+        description: "Advanced reasoning model with high token capacity",
+        maxTokens: 100000,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.275,
+        unsupportedParameters: ["topP"],
+    },
+    {
+        id: "gpt-4.1",
+        name: "GPT-4.1",
+        providerId: "openai",
+        contextWindow: 1047576,
+        inputPrice: 2,
+        outputPrice: 8,
+        description: "Latest GPT-4 model with enhanced capabilities",
+        maxTokens: 32768,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.5,
+    },
+    {
+        id: "gpt-4.1-mini",
+        name: "GPT-4.1 Mini",
+        providerId: "openai",
+        contextWindow: 1047576,
+        inputPrice: 0.4,
+        outputPrice: 1.6,
+        description: "Smaller version of GPT-4.1 for cost-effective tasks",
+        maxTokens: 32768,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.1,
+    },
+    {
+        id: "gpt-4.1-nano",
+        name: "GPT-4.1 Nano",
+        providerId: "openai",
+        contextWindow: 1047576,
+        inputPrice: 0.1,
+        outputPrice: 0.4,
+        description: "Ultra-efficient version of GPT-4.1",
+        maxTokens: 32768,
+        supportsImages: true,
+        supportsPromptCache: true,
+        cacheReadsPrice: 0.025,
+    },
+    // Mistral AI Models
+    {
+        id: "codestral-2501",
+        name: "Codestral",
+        providerId: "mistral",
+        contextWindow: 256000,
+        inputPrice: 0.3,
+        outputPrice: 0.9,
+        description: "Specialized model for code generation and programming tasks",
+        maxTokens: 256000,
+        supportsImages: false,
+        supportsPromptCache: false,
+    },
+    {
+        id: "devstral-small-2505",
+        name: "Devstral Small",
+        providerId: "mistral",
+        contextWindow: 131072,
+        inputPrice: 0.1,
+        outputPrice: 0.3,
+        description: "Compact development-focused model",
+        maxTokens: 128000,
+        supportsImages: false,
+        supportsPromptCache: false,
+    },
+];
+/**
+ * Gets provider information by ID
+ *
+ * @param providerId - The provider ID to look up
+ * @returns The provider info or undefined if not found
+ */
+function getProviderById(providerId) {
+    return exports.SUPPORTED_PROVIDERS.find((provider) => provider.id === providerId);
+}
+/**
+ * Gets model information by ID and provider
+ *
+ * @param modelId - The model ID to look up
+ * @param providerId - The provider ID to filter by
+ * @returns The model info or undefined if not found
+ */
+function getModelById(modelId, providerId) {
+    return exports.SUPPORTED_MODELS.find((model) => model.id === modelId && (!providerId || model.providerId === providerId));
+}
+/**
+ * Gets all models for a specific provider
+ *
+ * @param providerId - The provider ID to filter by
+ * @returns Array of model info for the provider
+ */
+function getModelsByProvider(providerId) {
+    return exports.SUPPORTED_MODELS.filter((model) => model.providerId === providerId);
+}
+/**
+ * Validates if a provider is supported
+ *
+ * @param providerId - The provider ID to validate
+ * @returns True if the provider is supported
+ */
+function isProviderSupported(providerId) {
+    return exports.SUPPORTED_PROVIDERS.some((provider) => provider.id === providerId);
+}
+/**
+ * Validates if a model is supported for a given provider
+ *
+ * @param modelId - The model ID to validate
+ * @param providerId - The provider ID to validate against
+ * @returns True if the model is supported for the provider
+ */
+function isModelSupported(modelId, providerId) {
+    return exports.SUPPORTED_MODELS.some((model) => model.id === modelId && model.providerId === providerId);
+}
+/**
+ * Gets merged default settings for a specific model and provider
+ *
+ * @param modelId - The model ID
+ * @param providerId - The provider ID
+ * @returns Merged default settings with model-specific overrides applied
+ */
+function getDefaultSettingsForModel(modelId, providerId) {
+    // Base settings: global defaults, then provider-specific, then model-specific overrides
+    const baseDefaults = { ...exports.DEFAULT_LLM_SETTINGS };
+    const providerDefaults = exports.PROVIDER_DEFAULT_SETTINGS[providerId] || {};
+    const modelDefaults = exports.MODEL_DEFAULT_SETTINGS[modelId] || {};
+    // Merge settings in order of precedence
+    const mergedSettings = {
+        ...baseDefaults,
+        ...providerDefaults,
+        ...modelDefaults,
+    };
+    // Override maxTokens from ModelInfo if available
+    const modelInfo = getModelById(modelId, providerId);
+    if (modelInfo && modelInfo.maxTokens !== undefined) {
+        mergedSettings.maxTokens = modelInfo.maxTokens;
+    }
+    // Filter out undefined values and ensure required fields
+    return Object.fromEntries(Object.entries(mergedSettings).filter(([_, value]) => value !== undefined));
+}
+/**
+ * Valid Gemini harm categories for validation
+ * Only includes categories supported by the API for safety setting rules
+ */
+const VALID_GEMINI_HARM_CATEGORIES = [
+    "HARM_CATEGORY_HATE_SPEECH",
+    "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+    "HARM_CATEGORY_DANGEROUS_CONTENT",
+    "HARM_CATEGORY_HARASSMENT",
+    "HARM_CATEGORY_CIVIC_INTEGRITY",
+];
+/**
+ * Valid Gemini harm block thresholds for validation
+ */
+const VALID_GEMINI_HARM_BLOCK_THRESHOLDS = [
+    "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    "BLOCK_LOW_AND_ABOVE",
+    "BLOCK_MEDIUM_AND_ABOVE",
+    "BLOCK_ONLY_HIGH",
+    "BLOCK_NONE",
+];
+/**
+ * Validates LLM settings values
+ *
+ * @param settings - The settings to validate
+ * @returns Array of validation error messages, empty if valid
+ */
+function validateLLMSettings(settings) {
+    const errors = [];
+    if (settings.temperature !== undefined) {
+        if (typeof settings.temperature !== "number" ||
+            settings.temperature < 0 ||
+            settings.temperature > 2) {
+            errors.push("temperature must be a number between 0 and 2");
+        }
+    }
+    if (settings.maxTokens !== undefined) {
+        if (!Number.isInteger(settings.maxTokens) ||
+            settings.maxTokens < 1 ||
+            settings.maxTokens > 100000) {
+            errors.push("maxTokens must be an integer between 1 and 100000");
+        }
+    }
+    if (settings.topP !== undefined) {
+        if (typeof settings.topP !== "number" ||
+            settings.topP < 0 ||
+            settings.topP > 1) {
+            errors.push("topP must be a number between 0 and 1");
+        }
+    }
+    if (settings.frequencyPenalty !== undefined) {
+        if (typeof settings.frequencyPenalty !== "number" ||
+            settings.frequencyPenalty < -2 ||
+            settings.frequencyPenalty > 2) {
+            errors.push("frequencyPenalty must be a number between -2 and 2");
+        }
+    }
+    if (settings.presencePenalty !== undefined) {
+        if (typeof settings.presencePenalty !== "number" ||
+            settings.presencePenalty < -2 ||
+            settings.presencePenalty > 2) {
+            errors.push("presencePenalty must be a number between -2 and 2");
+        }
+    }
+    if (settings.stopSequences !== undefined) {
+        if (!Array.isArray(settings.stopSequences)) {
+            errors.push("stopSequences must be an array");
+        }
+        else if (settings.stopSequences.length > 4) {
+            errors.push("stopSequences can contain at most 4 sequences");
+        }
+        else if (settings.stopSequences.some((seq) => typeof seq !== "string" || seq.length === 0)) {
+            errors.push("stopSequences must contain only non-empty strings");
+        }
+    }
+    if (settings.user !== undefined && typeof settings.user !== "string") {
+        errors.push("user must be a string");
+    }
+    if (settings.geminiSafetySettings !== undefined) {
+        if (!Array.isArray(settings.geminiSafetySettings)) {
+            errors.push("geminiSafetySettings must be an array");
+        }
+        else {
+            for (let i = 0; i < settings.geminiSafetySettings.length; i++) {
+                const setting = settings.geminiSafetySettings[i];
+                if (!setting || typeof setting !== "object") {
+                    errors.push(`geminiSafetySettings[${i}] must be an object with category and threshold`);
+                    continue;
+                }
+                if (!setting.category ||
+                    !VALID_GEMINI_HARM_CATEGORIES.includes(setting.category)) {
+                    errors.push(`geminiSafetySettings[${i}].category must be a valid Gemini harm category`);
+                }
+                if (!setting.threshold ||
+                    !VALID_GEMINI_HARM_BLOCK_THRESHOLDS.includes(setting.threshold)) {
+                    errors.push(`geminiSafetySettings[${i}].threshold must be a valid Gemini harm block threshold`);
+                }
+            }
+        }
+    }
+    return errors;
+}

package/dist/llm/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * API provider ID type - represents a unique identifier for an AI provider
+ */
+export type ApiProviderId = string;
+/**
+ * Message roles supported by LLM APIs
+ */
+export type LLMMessageRole = 'user' | 'assistant' | 'system';
+/**
+ * Individual message in a conversation
+ */
+export interface LLMMessage {
+    role: LLMMessageRole;
+    content: string;
+}
+/**
+ * Gemini harm categories for safety settings
+ * Only includes categories supported by the API for safety setting rules
+ */
+export type GeminiHarmCategory = 'HARM_CATEGORY_UNSPECIFIED' | 'HARM_CATEGORY_HATE_SPEECH' | 'HARM_CATEGORY_SEXUALLY_EXPLICIT' | 'HARM_CATEGORY_DANGEROUS_CONTENT' | 'HARM_CATEGORY_HARASSMENT' | 'HARM_CATEGORY_CIVIC_INTEGRITY';
+/**
+ * Gemini harm block thresholds for safety settings
+ */
+export type GeminiHarmBlockThreshold = 'HARM_BLOCK_THRESHOLD_UNSPECIFIED' | 'BLOCK_LOW_AND_ABOVE' | 'BLOCK_MEDIUM_AND_ABOVE' | 'BLOCK_ONLY_HIGH' | 'BLOCK_NONE';
+/**
+ * Individual Gemini safety setting
+ */
+export interface GeminiSafetySetting {
+    category: GeminiHarmCategory;
+    threshold: GeminiHarmBlockThreshold;
+}
+/**
+ * Configurable settings for LLM requests
+ */
+export interface LLMSettings {
+    /** Controls randomness in the response (0.0 to 2.0, typically 0.0 to 1.0) */
+    temperature?: number;
+    /** Maximum number of tokens to generate in the response */
+    maxTokens?: number;
+    /** Controls diversity via nucleus sampling (0.0 to 1.0) */
+    topP?: number;
+    /** Sequences where the API will stop generating further tokens */
+    stopSequences?: string[];
+    /** Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency */
+    frequencyPenalty?: number;
+    /** Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far */
+    presencePenalty?: number;
+    /** A unique identifier representing your end-user, which can help monitor and detect abuse */
+    user?: string;
+    /** Whether the LLM supports system message (almost all LLMs do nowadays) */
+    supportsSystemMessage?: boolean;
+    /** Gemini-specific safety settings for content filtering */
+    geminiSafetySettings?: GeminiSafetySetting[];
+}
+/**
+ * Request structure for chat completion
+ */
+export interface LLMChatRequest {
+    providerId: ApiProviderId;
+    modelId: string;
+    messages: LLMMessage[];
+    systemMessage?: string;
+    settings?: LLMSettings;
+}
+/**
+ * Individual choice in an LLM response
+ */
+export interface LLMChoice {
+    message: LLMMessage;
+    finish_reason: string | null;
+    index?: number;
+}
+/**
+ * Token usage information from LLM APIs
+ */
+export interface LLMUsage {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+}
+/**
+ * Successful response from LLM API
+ */
+export interface LLMResponse {
+    id: string;
+    provider: ApiProviderId;
+    model: string;
+    created: number;
+    choices: LLMChoice[];
+    usage?: LLMUsage;
+    object: 'chat.completion';
+}
+/**
+ * Error information from LLM APIs
+ */
+export interface LLMError {
+    message: string;
+    code?: string | number;
+    type?: string;
+    param?: string;
+    providerError?: any;
+}
+/**
+ * Error response from LLM operations
+ */
+export interface LLMFailureResponse {
+    provider: ApiProviderId;
+    model?: string;
+    error: LLMError;
+    object: 'error';
+}
+/**
+ * Information about a supported LLM provider
+ */
+export interface ProviderInfo {
+    id: ApiProviderId;
+    name: string;
+    unsupportedParameters?: (keyof LLMSettings)[];
+}
+/**
+ * Information about a supported LLM model
+ */
+export interface ModelInfo {
+    id: string;
+    name: string;
+    providerId: ApiProviderId;
+    contextWindow?: number;
+    inputPrice?: number;
+    outputPrice?: number;
+    supportsSystemMessage?: boolean;
+    description?: string;
+    maxTokens?: number;
+    supportsImages?: boolean;
+    supportsPromptCache: boolean;
+    thinkingConfig?: {
+        maxBudget?: number;
+        outputPrice?: number;
+    };
+    cacheWritesPrice?: number;
+    cacheReadsPrice?: number;
+    unsupportedParameters?: (keyof LLMSettings)[];
+}
+/**
+ * IPC channel names for LLM operations
+ */
+export declare const LLM_IPC_CHANNELS: {
+    readonly GET_PROVIDERS: "llm:get-providers";
+    readonly GET_MODELS: "llm:get-models";
+    readonly SEND_MESSAGE: "llm:send-message";
+    readonly IS_KEY_AVAILABLE: "llm:is-key-available";
+};
+/**
+ * Type for LLM IPC channel names
+ */
+export type LLMIPCChannelName = (typeof LLM_IPC_CHANNELS)[keyof typeof LLM_IPC_CHANNELS];

package/dist/llm/types.js

@@ -0,0 +1,14 @@
+"use strict";
+// AI Summary: Core type definitions for the LLM interaction module.
+// Defines request/response structures, settings, provider/model info, and error handling types.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLM_IPC_CHANNELS = void 0;
+/**
+ * IPC channel names for LLM operations
+ */
+exports.LLM_IPC_CHANNELS = {
+    GET_PROVIDERS: 'llm:get-providers',
+    GET_MODELS: 'llm:get-models',
+    SEND_MESSAGE: 'llm:send-message',
+    IS_KEY_AVAILABLE: 'llm:is-key-available',
+};

package/dist/providers/fromEnvironment.d.ts

@@ -0,0 +1,8 @@
+import type { ApiKeyProvider } from "../types";
+/**
+ * Creates an ApiKeyProvider that sources keys from system environment variables.
+ * It looks for variables in the format: PROVIDERID_API_KEY (e.g., OPENAI_API_KEY).
+ * This is a secure and standard practice for server-side applications.
+ * Note: Provider IDs are converted to uppercase.
+ */
+export declare const fromEnvironment: ApiKeyProvider;

package/dist/providers/fromEnvironment.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromEnvironment = void 0;
+/**
+ * Creates an ApiKeyProvider that sources keys from system environment variables.
+ * It looks for variables in the format: PROVIDERID_API_KEY (e.g., OPENAI_API_KEY).
+ * This is a secure and standard practice for server-side applications.
+ * Note: Provider IDs are converted to uppercase.
+ */
+const fromEnvironment = async (providerId) => {
+    const envVarName = `${providerId.toUpperCase()}_API_KEY`;
+    return process.env[envVarName] || null;
+};
+exports.fromEnvironment = fromEnvironment;

package/dist/types.d.ts

@@ -0,0 +1 @@
+export type ApiKeyProvider = (providerId: string) => Promise<string | null>;