genai-lite 0.8.2 → 0.9.0

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -9,9 +9,9 @@ exports.OpenAIClientAdapter = void 0;
 const openai_1 = __importDefault(require("openai"));
 const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
+const logprobsUtils_1 = require("../../shared/adapters/logprobsUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
-const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for OpenAI API integration
  *
@@ -27,9 +27,11 @@ class OpenAIClientAdapter {
      *
      * @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) {
         this.baseURL = config?.baseURL;
+        this.logger = config?.logger ?? (0, defaultLogger_1.createDefaultLogger)();
     }
     /**
      * Sends a chat message to OpenAI's API
@@ -38,12 +40,13 @@ class OpenAIClientAdapter {
      * @param apiKey - The decrypted OpenAI API key
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
             // Initialize OpenAI client
             const openai = new openai_1.default({
                 apiKey,
                 ...(this.baseURL && { baseURL: this.baseURL }),
+                maxRetries: 0, // retries are owned by the unified LLMService retry layer
             });
             // Format messages for OpenAI API
             const messages = this.formatMessages(request);
@@ -63,6 +66,15 @@ class OpenAIClientAdapter {
                 ...(request.settings.presencePenalty !== 0 && {
                     presence_penalty: request.settings.presencePenalty,
                 }),
+                ...(request.settings.seed !== undefined && {
+                    seed: request.settings.seed,
+                }),
+                ...(request.settings.logprobs === true && {
+                    logprobs: true,
+                    ...(request.settings.topLogprobs !== undefined && {
+                        top_logprobs: request.settings.topLogprobs,
+                    }),
+                }),
                 ...(request.settings.user && {
                     user: request.settings.user,
                 }),
@@ -95,7 +107,7 @@ class OpenAIClientAdapter {
                     }
                 };
             }
-            logger.debug(`OpenAI API parameters:`, {
+            this.logger.debug(`OpenAI API parameters:`, {
                 model: completionParams.model,
                 temperature: completionParams.temperature,
                 max_completion_tokens: completionParams.max_completion_tokens,
@@ -105,12 +117,18 @@ class OpenAIClientAdapter {
                 presence_penalty: completionParams.presence_penalty,
                 hasUser: !!completionParams.user,
             });
-            logger.info(`Making OpenAI API call for model: ${request.modelId}`);
+            this.logger.info(`Making OpenAI 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(`OpenAI API call successful, response ID: ${completion.id}`);
+                this.logger.info(`OpenAI API call successful, response ID: ${completion.id}`);
                 // Convert to standardized response format
                 return this.createSuccessResponse(completion, request);
             }
@@ -119,7 +137,7 @@ class OpenAIClientAdapter {
             }
         }
         catch (error) {
-            logger.error("OpenAI API error:", error);
+            this.logger.error("OpenAI API error:", error);
             return this.createErrorResponse(error, request);
         }
     }
@@ -224,7 +242,7 @@ class OpenAIClientAdapter {
                 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`);
                 }
             }
         }
@@ -255,6 +273,11 @@ class OpenAIClientAdapter {
         if (choice.reasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
             responseChoice.reasoning = choice.reasoning;
         }
+        // Per-token log probabilities (when requested via settings.logprobs)
+        const logprobs = (0, logprobsUtils_1.mapOpenAIChatLogprobs)(choice.logprobs);
+        if (logprobs) {
+            responseChoice.logprobs = logprobs;
+        }
         return {
             id: completion.id,
             provider: request.providerId,
@@ -281,7 +304,7 @@ class OpenAIClientAdapter {
     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, errorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
+        let { errorCode, errorMessage, errorType, status, retryAfterMs } = (0, errorUtils_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")) {
@@ -301,6 +324,7 @@ class OpenAIClientAdapter {
                 code: errorCode,
                 type: errorType,
                 ...(status && { status }),
+                ...(retryAfterMs !== undefined && { retryAfterMs }),
                 providerError: error,
             },
             object: "error",

package/dist/llm/clients/OpenRouterClientAdapter.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";
 /**
  * Configuration options for OpenRouterClientAdapter
  */
@@ -10,6 +11,8 @@ export interface OpenRouterClientConfig {
     httpReferer?: string;
     /** Your app's display name for rankings (optional) */
     siteTitle?: string;
+    /** Logger instance for adapter logging */
+    logger?: Logger;
 }
 /**
  * Client adapter for OpenRouter API integration
@@ -45,6 +48,7 @@ export declare class OpenRouterClientAdapter implements ILLMClientAdapter {
     private baseURL;
     private httpReferer?;
     private siteTitle?;
+    private logger;
     /**
      * Creates a new OpenRouter client adapter
      *
@@ -58,7 +62,7 @@ export declare class OpenRouterClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The OpenRouter 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 OpenRouter API key format
      *

package/dist/llm/clients/OpenRouterClientAdapter.js

@@ -9,9 +9,9 @@ exports.OpenRouterClientAdapter = void 0;
 const openai_1 = __importDefault(require("openai"));
 const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
+const logprobsUtils_1 = require("../../shared/adapters/logprobsUtils");
 const systemMessageUtils_1 = require("../../shared/adapters/systemMessageUtils");
 const defaultLogger_1 = require("../../logging/defaultLogger");
-const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for OpenRouter API integration
  *
@@ -52,6 +52,7 @@ class OpenRouterClientAdapter {
         this.baseURL = config?.baseURL || 'https://openrouter.ai/api/v1';
         this.httpReferer = config?.httpReferer || process.env.OPENROUTER_HTTP_REFERER;
         this.siteTitle = config?.siteTitle || process.env.OPENROUTER_SITE_TITLE;
+        this.logger = config?.logger ?? (0, defaultLogger_1.createDefaultLogger)();
     }
     /**
      * Sends a chat message to OpenRouter API
@@ -60,11 +61,12 @@ class OpenRouterClientAdapter {
      * @param apiKey - The OpenRouter API key
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
             // Initialize OpenAI client with OpenRouter base URL and custom headers
             const openai = new openai_1.default({
                 apiKey,
+                maxRetries: 0, // retries are owned by the unified LLMService retry layer
                 baseURL: this.baseURL,
                 defaultHeaders: {
                     ...(this.httpReferer && { 'HTTP-Referer': this.httpReferer }),
@@ -89,6 +91,26 @@ class OpenRouterClientAdapter {
                 ...(request.settings.presencePenalty !== 0 && {
                     presence_penalty: request.settings.presencePenalty,
                 }),
+                ...(request.settings.seed !== undefined && {
+                    seed: request.settings.seed,
+                }),
+                // OpenRouter pass-through sampling params (not in the OpenAI SDK types;
+                // sent as-is — OpenRouter ignores them for models that don't support them)
+                ...(request.settings.topK !== undefined && {
+                    top_k: request.settings.topK,
+                }),
+                ...(request.settings.minP !== undefined && {
+                    min_p: request.settings.minP,
+                }),
+                ...(request.settings.repeatPenalty !== undefined && {
+                    repetition_penalty: request.settings.repeatPenalty,
+                }),
+                ...(request.settings.logprobs === true && {
+                    logprobs: true,
+                    ...(request.settings.topLogprobs !== undefined && {
+                        top_logprobs: request.settings.topLogprobs,
+                    }),
+                }),
             };
             // Add OpenRouter-specific provider routing if configured
             const providerSettings = request.settings.openRouterProvider;
@@ -126,7 +148,31 @@ class OpenRouterClientAdapter {
                     }
                 };
             }
-            logger.debug(`OpenRouter API parameters:`, {
+            // Map unified reasoning settings to OpenRouter's reasoning body param.
+            // effort and max_tokens are mutually exclusive on OpenRouter; max_tokens wins
+            // when both are set (matching the Anthropic adapter's precedence). OpenRouter
+            // silently ignores the param for models without reasoning support.
+            const reasoningSettings = request.settings.reasoning;
+            if (reasoningSettings &&
+                (reasoningSettings.enabled === true ||
+                    reasoningSettings.effort !== undefined ||
+                    reasoningSettings.maxTokens !== undefined)) {
+                const reasoning = {};
+                if (reasoningSettings.maxTokens !== undefined) {
+                    reasoning.max_tokens = reasoningSettings.maxTokens;
+                }
+                else if (reasoningSettings.effort) {
+                    reasoning.effort = reasoningSettings.effort;
+                }
+                else {
+                    reasoning.enabled = true;
+                }
+                if (reasoningSettings.exclude === true) {
+                    reasoning.exclude = true;
+                }
+                completionParams.reasoning = reasoning;
+            }
+            this.logger.debug(`OpenRouter API parameters:`, {
                 baseURL: this.baseURL,
                 model: completionParams.model,
                 temperature: completionParams.temperature,
@@ -134,12 +180,18 @@ class OpenRouterClientAdapter {
                 top_p: completionParams.top_p,
                 hasProviderRouting: !!completionParams.provider,
             });
-            logger.info(`Making OpenRouter API call for model: ${request.modelId}`);
+            this.logger.info(`Making OpenRouter 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(`OpenRouter API call successful, response ID: ${completion.id}`);
+                this.logger.info(`OpenRouter API call successful, response ID: ${completion.id}`);
                 return this.createSuccessResponse(completion, request);
             }
             else {
@@ -147,7 +199,7 @@ class OpenRouterClientAdapter {
             }
         }
         catch (error) {
-            logger.error("OpenRouter API error:", error);
+            this.logger.error("OpenRouter API error:", error);
             return this.createErrorResponse(error, request);
         }
     }
@@ -223,7 +275,7 @@ class OpenRouterClientAdapter {
                 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`);
                 }
             }
         }
@@ -246,14 +298,32 @@ class OpenRouterClientAdapter {
             provider: request.providerId,
             model: completion.model || request.modelId,
             created: completion.created,
-            choices: completion.choices.map((c) => ({
-                message: {
-                    role: "assistant",
-                    content: c.message.content || "",
-                },
-                finish_reason: c.finish_reason,
-                index: c.index,
-            })),
+            choices: completion.choices.map((c) => {
+                const mappedChoice = {
+                    message: {
+                        role: "assistant",
+                        content: c.message.content || "",
+                    },
+                    finish_reason: c.finish_reason,
+                    index: c.index,
+                };
+                // OpenRouter returns the reasoning trace on message.reasoning (plus
+                // structured reasoning_details) for models that expose it
+                const messageReasoning = c.message.reasoning;
+                if (messageReasoning && request.settings.reasoning?.exclude !== true) {
+                    mappedChoice.reasoning = messageReasoning;
+                }
+                const reasoningDetails = c.message.reasoning_details;
+                if (reasoningDetails && request.settings.reasoning?.exclude !== true) {
+                    mappedChoice.reasoning_details = reasoningDetails;
+                }
+                // 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
                 ? {
                     prompt_tokens: completion.usage.prompt_tokens,
@@ -289,6 +359,7 @@ class OpenRouterClientAdapter {
                 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/types.d.ts

@@ -6,6 +6,18 @@ import type { LLMChatRequest, LLMResponse, LLMFailureResponse, LLMSettings } fro
 export interface InternalLLMChatRequest extends Omit<LLMChatRequest, "settings"> {
     settings: Required<LLMSettings>;
 }
+/**
+ * Per-request transport options passed from the service layer to adapters.
+ */
+export interface AdapterRequestOptions {
+    /**
+     * Abort signal for cancelling the in-flight request. Note that aborting only
+     * cancels the client-side wait — the provider may still process (and bill) the request.
+     */
+    signal?: AbortSignal;
+    /** Request timeout in milliseconds (mapped to each SDK's timeout mechanism) */
+    timeoutMs?: number;
+}
 /**
  * Interface that all LLM client adapters must implement
  *
@@ -22,11 +34,12 @@ export interface ILLMClientAdapter {
      *
      * @param request - The LLM request with applied default settings
      * @param apiKey - The decrypted API key for the provider
+     * @param options - Optional per-request transport options (abort signal, timeout)
      * @returns Promise resolving to either a successful response or failure response
      *
      * @throws Should not throw - all errors should be caught and returned as LLMFailureResponse
      */
-    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
     /**
      * Optional method to validate API key format before making requests
      *
@@ -58,6 +71,10 @@ export declare const ADAPTER_ERROR_CODES: {
     readonly NETWORK_ERROR: "NETWORK_ERROR";
     readonly PROVIDER_ERROR: "PROVIDER_ERROR";
     readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    /** The request exceeded its timeout (retryable by default) */
+    readonly REQUEST_TIMEOUT: "REQUEST_TIMEOUT";
+    /** The request was cancelled via AbortSignal (never retried) */
+    readonly REQUEST_ABORTED: "REQUEST_ABORTED";
 };
 /**
  * Helper type for adapter error codes

package/dist/llm/clients/types.js

@@ -16,4 +16,8 @@ exports.ADAPTER_ERROR_CODES = {
     NETWORK_ERROR: "NETWORK_ERROR",
     PROVIDER_ERROR: "PROVIDER_ERROR",
     UNKNOWN_ERROR: "UNKNOWN_ERROR",
+    /** The request exceeded its timeout (retryable by default) */
+    REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+    /** The request was cancelled via AbortSignal (never retried) */
+    REQUEST_ABORTED: "REQUEST_ABORTED",
 };

package/dist/llm/config.d.ts

@@ -50,7 +50,11 @@ export interface GgufModelPattern {
  * Order matters: more specific patterns should come before generic ones.
  * First matching pattern wins.
  *
- * Example: "Qwen3-0.6B-0522" should be before "Qwen3-0.6B"
+ * Ordering rules (see docs/dev/adding-models-and-providers.md):
+ * - Specific before generic: "qwen3-4b-instruct-2507" before "qwen3-4b"
+ * - Newer family names before older substrings they contain: "qwen3.5" contains no
+ *   "qwen3-" (the dot breaks the match) but is listed first anyway for clarity
+ * - Quantization agnostic: never embed Q4_K_M/Q8_0 in patterns
  */
 export declare const KNOWN_GGUF_MODELS: GgufModelPattern[];
 /**
@@ -131,9 +135,12 @@ export declare function createFallbackModelInfo(modelId: string, providerId: str
  *
  * @param modelId - The model ID
  * @param providerId - The provider ID
+ * @param resolvedModelInfo - Optional already-resolved ModelInfo (e.g. a detected GGUF
+ *   model's fallback info). When provided it is used instead of a registry lookup, so
+ *   capabilities and defaultSettings of dynamically-detected models flow into settings.
  * @returns Merged default settings with model-specific overrides applied
  */
-export declare function getDefaultSettingsForModel(modelId: string, providerId: ApiProviderId): Required<LLMSettings>;
+export declare function getDefaultSettingsForModel(modelId: string, providerId: ApiProviderId, resolvedModelInfo?: ModelInfo): Required<LLMSettings>;
 /**
  * Validates LLM settings values
  *