genai-lite 0.8.2 → 0.9.0

package/dist/llm/clients/LlamaCppClientAdapter.js

@@ -12,8 +12,9 @@ const errorUtils_1 = require("../../shared/adapters/errorUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const LlamaCppServerClient_1 = require("./LlamaCppServerClient");
 const config_1 = require("../config");
+const parser_1 = require("../../prompting/parser");
+const logprobsUtils_1 = require("../../shared/adapters/logprobsUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
-const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for llama.cpp server integration
  *
@@ -34,7 +35,7 @@ const logger = (0, defaultLogger_1.createDefaultLogger)();
  * ```typescript
  * // Create adapter for local server
  * const adapter = new LlamaCppClientAdapter({
- *   baseURL: 'http://localhost:8080',
+ *   baseURL: 'http://127.0.0.1:8080',
  *   checkHealth: true
  * });
  *
@@ -58,9 +59,13 @@ class LlamaCppClientAdapter {
     constructor(config) {
         this.cachedModelCapabilities = null;
         this.detectionAttempted = false;
-        this.baseURL = config?.baseURL || 'http://localhost:8080';
+        // 127.0.0.1 rather than localhost: on Windows, localhost resolves to IPv6 (::1)
+        // first, and when llama-server listens on IPv4 only, every fresh connection waits
+        // ~2s for the IPv6 attempt to time out (~9x per-request slowdown measured).
+        this.baseURL = config?.baseURL || 'http://127.0.0.1:8080';
         this.checkHealth = config?.checkHealth || false;
         this.serverClient = new LlamaCppServerClient_1.LlamaCppServerClient(this.baseURL);
+        this.logger = config?.logger ?? (0, defaultLogger_1.createDefaultLogger)();
     }
     /**
      * Gets model capabilities by detecting the loaded GGUF model
@@ -81,10 +86,10 @@ class LlamaCppClientAdapter {
         }
         // Attempt detection
         try {
-            logger.debug(`Detecting model capabilities from llama.cpp server at ${this.baseURL}`);
+            this.logger.debug(`Detecting model capabilities from llama.cpp server at ${this.baseURL}`);
             const { data } = await this.serverClient.getModels();
             if (!data || data.length === 0) {
-                logger.warn('No models loaded in llama.cpp server');
+                this.logger.warn('No models loaded in llama.cpp server');
                 this.detectionAttempted = true;
                 return null;
             }
@@ -94,15 +99,15 @@ class LlamaCppClientAdapter {
             this.cachedModelCapabilities = capabilities;
             this.detectionAttempted = true;
             if (capabilities) {
-                logger.debug(`Cached model capabilities for: ${ggufFilename}`);
+                this.logger.debug(`Cached model capabilities for: ${ggufFilename}`);
             }
             else {
-                logger.debug(`No known pattern matched for: ${ggufFilename}`);
+                this.logger.debug(`No known pattern matched for: ${ggufFilename}`);
             }
             return capabilities;
         }
         catch (error) {
-            logger.warn('Failed to detect model capabilities:', error);
+            this.logger.warn('Failed to detect model capabilities:', error);
             this.detectionAttempted = true;
             return null;
         }
@@ -116,7 +121,7 @@ class LlamaCppClientAdapter {
     clearModelCache() {
         this.cachedModelCapabilities = null;
         this.detectionAttempted = false;
-        logger.debug('Cleared model capabilities cache');
+        this.logger.debug('Cleared model capabilities cache');
     }
     /**
      * Sends a chat message to llama.cpp server
@@ -125,7 +130,7 @@ class LlamaCppClientAdapter {
      * @param apiKey - Not used for llama.cpp (local server), but kept for interface compatibility
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
             // Optional health check before making request
             if (this.checkHealth) {
@@ -145,7 +150,7 @@ class LlamaCppClientAdapter {
                     }
                 }
                 catch (healthError) {
-                    logger.warn('Health check failed, proceeding with request anyway:', healthError);
+                    this.logger.warn('Health check failed, proceeding with request anyway:', healthError);
                 }
             }
             // Initialize OpenAI client with llama.cpp base URL
@@ -153,6 +158,7 @@ class LlamaCppClientAdapter {
             const openai = new openai_1.default({
                 apiKey: apiKey || 'not-needed',
                 baseURL: `${this.baseURL}/v1`,
+                maxRetries: 0, // retries are owned by the unified LLMService retry layer
             });
             // Format messages for OpenAI-compatible API
             const messages = this.formatMessages(request);
@@ -172,6 +178,20 @@ class LlamaCppClientAdapter {
                 ...(request.settings.presencePenalty !== 0 && {
                     presence_penalty: request.settings.presencePenalty,
                 }),
+                ...(request.settings.seed !== undefined && {
+                    seed: request.settings.seed,
+                }),
+                // llama.cpp-native sampling params (not in the OpenAI SDK types, but the
+                // SDK sends extra body fields as-is and llama-server reads them top-level)
+                ...(request.settings.topK !== undefined && {
+                    top_k: request.settings.topK,
+                }),
+                ...(request.settings.minP !== undefined && {
+                    min_p: request.settings.minP,
+                }),
+                ...(request.settings.repeatPenalty !== undefined && {
+                    repeat_penalty: request.settings.repeatPenalty,
+                }),
             };
             // Handle structured output configuration for llama.cpp
             // llama.cpp uses response_format with type: 'json_object' and optional schema
@@ -182,27 +202,83 @@ class LlamaCppClientAdapter {
                     schema: so.schema,
                 };
             }
-            logger.debug(`llama.cpp API parameters:`, {
+            // Reasoning toggle for detected hybrid GGUF models (Qwen 3.x, Gemma 4, ...).
+            // The chat template's thinking flag is sent explicitly — false unless reasoning
+            // was requested — so hybrid models don't silently burn thinking tokens.
+            // Requires llama-server running with --jinja; servers without it ignore the kwarg.
+            const detectedCaps = await this.getModelCapabilities();
+            const localReasoning = detectedCaps?.localReasoning;
+            const derivedKwargs = {};
+            if (localReasoning?.toggleKwarg) {
+                derivedKwargs[localReasoning.toggleKwarg] =
+                    request.settings.reasoning?.enabled === true;
+            }
+            // User-supplied chat-template kwargs (escape hatch) win over derived ones
+            const chatTemplateKwargs = {
+                ...derivedKwargs,
+                ...(request.settings.llamacpp?.chatTemplateKwargs || {}),
+            };
+            if (Object.keys(chatTemplateKwargs).length > 0) {
+                // llama-server rejects assistant prefill together with enable_thinking=true
+                // (HTTP 400: "Assistant response prefill is incompatible with enable_thinking.")
+                // Fail fast with a clear message instead of surfacing the raw server error.
+                const thinkingKwarg = localReasoning?.toggleKwarg ?? 'enable_thinking';
+                const effectiveThinking = chatTemplateKwargs[thinkingKwarg] === true;
+                const lastMessage = messages[messages.length - 1];
+                if (effectiveThinking && lastMessage?.role === 'assistant') {
+                    return {
+                        provider: request.providerId,
+                        model: request.modelId,
+                        error: {
+                            message: 'llama.cpp does not support assistant prefill (a trailing assistant message) ' +
+                                'while thinking is enabled. Remove the trailing assistant message or disable reasoning.',
+                            code: types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR,
+                            type: 'invalid_request_error',
+                        },
+                        object: 'error',
+                    };
+                }
+                completionParams.chat_template_kwargs = chatTemplateKwargs;
+            }
+            // GBNF grammar for constrained decoding (validated as mutually exclusive
+            // with structuredOutput upstream)
+            if (request.settings.llamacpp?.grammar) {
+                completionParams.grammar = request.settings.llamacpp.grammar;
+            }
+            // Per-token log probabilities (OpenAI-compatible request/response shape)
+            if (request.settings.logprobs === true) {
+                completionParams.logprobs = true;
+                if (request.settings.topLogprobs !== undefined) {
+                    completionParams.top_logprobs = request.settings.topLogprobs;
+                }
+            }
+            this.logger.debug(`llama.cpp API parameters:`, {
                 baseURL: this.baseURL,
                 model: completionParams.model,
                 temperature: completionParams.temperature,
                 max_tokens: completionParams.max_tokens,
                 top_p: completionParams.top_p,
             });
-            logger.info(`Making llama.cpp API call for model: ${request.modelId}`);
+            this.logger.info(`Making llama.cpp API call for model: ${request.modelId}`);
             // Make the API call
-            const completion = await openai.chat.completions.create(completionParams);
+            const transportOptions = {
+                ...(options?.signal && { signal: options.signal }),
+                ...(options?.timeoutMs !== undefined && { timeout: options.timeoutMs }),
+            };
+            const completion = Object.keys(transportOptions).length > 0
+                ? await openai.chat.completions.create(completionParams, transportOptions)
+                : await openai.chat.completions.create(completionParams);
             // Type guard to ensure we have a non-streaming response
             if ('id' in completion && 'choices' in completion) {
-                logger.info(`llama.cpp API call successful, response ID: ${completion.id}`);
-                return this.createSuccessResponse(completion, request);
+                this.logger.info(`llama.cpp API call successful, response ID: ${completion.id}`);
+                return this.createSuccessResponse(completion, request, detectedCaps);
             }
             else {
                 throw new Error('Unexpected streaming response from llama.cpp server');
             }
         }
         catch (error) {
-            logger.error("llama.cpp API error:", error);
+            this.logger.error("llama.cpp API error:", error);
             // Clear cache on connection errors so we re-detect on next request
             const errorMessage = error?.message || String(error);
             if (errorMessage.includes("ECONNREFUSED") ||
@@ -296,7 +372,7 @@ class LlamaCppClientAdapter {
                 const modifiedIndex = (0, systemMessageUtils_1.prependSystemToFirstUserMessage)(simpleMessages, combinedSystemContent, request.settings.systemMessageFallback);
                 if (modifiedIndex !== -1) {
                     messages[modifiedIndex].content = simpleMessages[modifiedIndex].content;
-                    logger.debug(`Model ${request.modelId} doesn't support system messages - prepended to first user message`);
+                    this.logger.debug(`Model ${request.modelId} doesn't support system messages - prepended to first user message`);
                 }
             }
         }
@@ -309,36 +385,62 @@ class LlamaCppClientAdapter {
      * @param request - Original request for context
      * @returns Standardized LLM response
      */
-    createSuccessResponse(completion, request) {
+    createSuccessResponse(completion, request, detectedCaps) {
         const choice = completion.choices[0];
         if (!choice || !choice.message) {
             throw new Error("No valid choices in llama.cpp completion response");
         }
-        // Extract reasoning content if available
-        // llama.cpp returns reasoning in reasoning_content field when using --reasoning-format
-        let reasoning;
-        if (choice.message.reasoning_content) {
-            reasoning = choice.message.reasoning_content;
-        }
+        const local = detectedCaps?.localReasoning;
+        // Whether thinking is active for this request: explicitly requested, or the
+        // detected model reasons unconditionally (always-on models like GPT-OSS,
+        // Thinking-2507 checkpoints, DeepSeek R1).
+        const reasoningActive = request.settings.reasoning?.enabled === true ||
+            detectedCaps?.reasoning?.enabledByDefault === true ||
+            detectedCaps?.reasoning?.canDisable === false;
+        const excludeReasoning = request.settings.reasoning?.exclude === true;
         return {
             id: completion.id,
             provider: request.providerId,
             model: completion.model || request.modelId,
             created: completion.created,
             choices: completion.choices.map((c) => {
+                let content = c.message.content || "";
+                // Strip the template-injected "nothink" prefix (some chat templates leak an
+                // empty think block into content when thinking is disabled). Exact match.
+                if (local?.nothinkPrefix && content.startsWith(local.nothinkPrefix)) {
+                    content = content.slice(local.nothinkPrefix.length);
+                }
                 const mappedChoice = {
                     message: {
                         role: "assistant",
-                        content: c.message.content || "",
+                        content,
                     },
                     finish_reason: c.finish_reason,
                     index: c.index,
                 };
-                // Include reasoning if available and not excluded
+                // Two-tier reasoning extraction:
+                // 1. Prefer the server-separated reasoning_content field (populated when
+                //    llama-server's --reasoning-format handling recognizes the template).
+                // 2. Fall back to marker extraction from content — reasoning_content
+                //    population is model/template-dependent, not guaranteed.
                 const messageReasoning = c.message.reasoning_content;
-                if (messageReasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
+                if (messageReasoning && request.settings.reasoning && !excludeReasoning) {
                     mappedChoice.reasoning = messageReasoning;
                 }
+                else if (!messageReasoning && reasoningActive && local?.markers) {
+                    const { content: cleaned, extracted } = (0, parser_1.extractMarkerDelimitedContent)(content, local.markers[0], local.markers[1]);
+                    if (extracted) {
+                        mappedChoice.message.content = cleaned;
+                        if (!excludeReasoning) {
+                            mappedChoice.reasoning = extracted;
+                        }
+                    }
+                }
+                // Per-token log probabilities (OpenAI-compatible shape)
+                const logprobs = (0, logprobsUtils_1.mapOpenAIChatLogprobs)(c.logprobs);
+                if (logprobs) {
+                    mappedChoice.logprobs = logprobs;
+                }
                 return mappedChoice;
             }),
             usage: completion.usage
@@ -389,6 +491,7 @@ class LlamaCppClientAdapter {
                 code: mappedError.errorCode,
                 type: mappedError.errorType,
                 ...(mappedError.status && { status: mappedError.status }),
+                ...(mappedError.retryAfterMs !== undefined && { retryAfterMs: mappedError.retryAfterMs }),
                 providerError: error,
             },
             object: "error",

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

@@ -1,11 +1,14 @@
 import type { LLMResponse, LLMFailureResponse } from "../types";
-import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
+import type { Logger } from "../../logging/types";
 /**
  * Configuration options for MistralClientAdapter
  */
 export interface MistralClientConfig {
     /** Base URL of the Mistral API (default: https://api.mistral.ai) */
     baseURL?: string;
+    /** Logger instance for adapter logging */
+    logger?: Logger;
 }
 /**
  * Client adapter for Mistral AI API integration
@@ -35,6 +38,7 @@ export interface MistralClientConfig {
  */
 export declare class MistralClientAdapter implements ILLMClientAdapter {
     private baseURL;
+    private logger;
     /**
      * Creates a new Mistral client adapter
      *
@@ -48,7 +52,7 @@ export declare class MistralClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The Mistral API key
      * @returns Promise resolving to success or failure response
      */
-    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
     /**
      * Validates Mistral API key format
      *

package/dist/llm/clients/MistralClientAdapter.js

@@ -8,7 +8,6 @@ const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
-const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for Mistral AI API integration
  *
@@ -43,6 +42,7 @@ class MistralClientAdapter {
      */
     constructor(config) {
         this.baseURL = config?.baseURL || process.env.MISTRAL_API_BASE_URL || 'https://api.mistral.ai';
+        this.logger = config?.logger ?? (0, defaultLogger_1.createDefaultLogger)();
     }
     /**
      * Sends a chat message to Mistral API
@@ -51,23 +51,24 @@ class MistralClientAdapter {
      * @param apiKey - The Mistral API key
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
-            // Initialize Mistral client
+            // Initialize Mistral client (Speakeasy SDK retry default is "none" — retries
+            // are owned by the unified LLMService retry layer)
             const mistral = new mistralai_1.Mistral({
                 apiKey,
                 serverURL: this.baseURL !== 'https://api.mistral.ai' ? this.baseURL : undefined,
             });
             // Format messages for Mistral API
             const messages = this.formatMessages(request);
-            logger.debug(`Mistral API parameters:`, {
+            this.logger.debug(`Mistral API parameters:`, {
                 baseURL: this.baseURL,
                 model: request.modelId,
                 temperature: request.settings.temperature,
                 max_tokens: request.settings.maxTokens,
                 top_p: request.settings.topP,
             });
-            logger.info(`Making Mistral API call for model: ${request.modelId}`);
+            this.logger.info(`Making Mistral API call for model: ${request.modelId}`);
             // Build request options
             const requestOptions = {
                 model: request.modelId,
@@ -78,19 +79,28 @@ class MistralClientAdapter {
                 ...(request.settings.stopSequences.length > 0 && {
                     stop: request.settings.stopSequences,
                 }),
+                ...(request.settings.seed !== undefined && {
+                    randomSeed: request.settings.seed,
+                }),
                 // Note: Mistral does not support frequency_penalty or presence_penalty
             };
             // Handle structured output configuration for Mistral
             // Mistral only supports json_object mode, no schema validation
             if (request.settings.structuredOutput?.schema && request.settings.structuredOutput.enabled !== false) {
                 requestOptions.responseFormat = { type: 'json_object' };
-                logger.warn(`Mistral does not support JSON schema validation. ` +
+                this.logger.warn(`Mistral does not support JSON schema validation. ` +
                     `Using json_object mode - schema validation will be client-side only.`);
             }
-            // Make the API call
-            const completion = await mistral.chat.complete(requestOptions);
+            // Make the API call (per-request transport options: timeout + abort signal)
+            const transportOptions = {
+                ...(options?.timeoutMs !== undefined && { timeoutMs: options.timeoutMs }),
+                ...(options?.signal && { fetchOptions: { signal: options.signal } }),
+            };
+            const completion = Object.keys(transportOptions).length > 0
+                ? await mistral.chat.complete(requestOptions, transportOptions)
+                : await mistral.chat.complete(requestOptions);
             if (completion && completion.choices && completion.choices.length > 0) {
-                logger.info(`Mistral API call successful, response ID: ${completion.id}`);
+                this.logger.info(`Mistral API call successful, response ID: ${completion.id}`);
                 return this.createSuccessResponse(completion, request);
             }
             else {
@@ -98,7 +108,7 @@ class MistralClientAdapter {
             }
         }
         catch (error) {
-            logger.error("Mistral API error:", error);
+            this.logger.error("Mistral API error:", error);
             return this.createErrorResponse(error, request);
         }
     }
@@ -170,7 +180,7 @@ class MistralClientAdapter {
                 // Model doesn't support system messages - prepend to first user message
                 const modifiedIndex = (0, systemMessageUtils_1.prependSystemToFirstUserMessage)(messages, combinedSystemContent, request.settings.systemMessageFallback);
                 if (modifiedIndex !== -1) {
-                    logger.debug(`Model ${request.modelId} doesn't support system messages - prepended to first user message`);
+                    this.logger.debug(`Model ${request.modelId} doesn't support system messages - prepended to first user message`);
                 }
             }
         }
@@ -239,6 +249,7 @@ class MistralClientAdapter {
                 code: mappedError.errorCode,
                 type: mappedError.errorType,
                 ...(mappedError.status && { status: mappedError.status }),
+                ...(mappedError.retryAfterMs !== undefined && { retryAfterMs: mappedError.retryAfterMs }),
                 providerError: error,
             },
             object: "error",

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

@@ -1,5 +1,5 @@
 import type { LLMResponse, LLMFailureResponse, ApiProviderId } from "../types";
-import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
 /**
  * Mock client adapter for testing LLM functionality
  *
@@ -20,7 +20,7 @@ export declare class MockClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The API key (ignored for mock)
      * @returns Promise resolving to mock response
      */
-    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
     /**
      * Validates API key format (always returns true for mock)
      */

package/dist/llm/clients/MockClientAdapter.js

@@ -25,7 +25,20 @@ class MockClientAdapter {
      * @param apiKey - The API key (ignored for mock)
      * @returns Promise resolving to mock response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
+        // Honor abort signals like a real adapter would
+        if (options?.signal?.aborted) {
+            return {
+                provider: request.providerId,
+                model: request.modelId,
+                error: {
+                    message: "Request was aborted",
+                    code: types_1.ADAPTER_ERROR_CODES.REQUEST_ABORTED,
+                    type: "abort_error",
+                },
+                object: "error",
+            };
+        }
         // Simulate network delay
         await this.simulateDelay(100, 500);
         try {
@@ -213,15 +226,19 @@ class MockClientAdapter {
      * Generates a response that shows current settings
      */
     generateSettingsTestResponse(settings) {
-        return `Current mock settings:
-- Temperature: ${settings.temperature}
-- Max Tokens: ${settings.maxTokens}
-- Top P: ${settings.topP}
+        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}
+            : "none"}
+- Frequency Penalty: ${settings.frequencyPenalty}
+- Presence Penalty: ${settings.presencePenalty}
+- Top K: ${settings.topK ?? "not set"}
+- Min P: ${settings.minP ?? "not set"}
+- Repeat Penalty: ${settings.repeatPenalty ?? "not set"}
+- Seed: ${settings.seed ?? "not set"}
 - User: ${settings.user || "not set"}`;
     }
     /**
@@ -285,17 +302,17 @@ class MockClientAdapter {
      * 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.
-
+        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.`;
     }
     /**

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

@@ -1,5 +1,6 @@
 import type { LLMResponse, LLMFailureResponse } from "../types";
-import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
+import type { Logger } from "../../logging/types";
 /**
  * Client adapter for OpenAI API integration
  *
@@ -11,14 +12,17 @@ import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
  */
 export declare class OpenAIClientAdapter implements ILLMClientAdapter {
     private baseURL?;
+    private logger;
     /**
      * Creates a new OpenAI client adapter
      *
      * @param config Optional configuration for the adapter
      * @param config.baseURL Custom base URL for OpenAI-compatible APIs
+     * @param config.logger Custom logger instance
      */
     constructor(config?: {
         baseURL?: string;
+        logger?: Logger;
     });
     /**
      * Sends a chat message to OpenAI's API
@@ -27,7 +31,7 @@ export declare class OpenAIClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The decrypted OpenAI API key
      * @returns Promise resolving to success or failure response
      */
-    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
     /**
      * Validates OpenAI API key format
      *