genai-lite 0.8.3 → 0.9.1

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,5 @@
 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
@@ -31,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
      *

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -9,6 +9,7 @@ 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");
 /**
@@ -39,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);
@@ -64,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,
                 }),
@@ -108,7 +119,13 @@ class OpenAIClientAdapter {
             });
             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) {
                 this.logger.info(`OpenAI API call successful, response ID: ${completion.id}`);
@@ -256,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,
@@ -282,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")) {
@@ -302,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,5 @@
 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
@@ -62,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,6 +9,7 @@ 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");
 /**
@@ -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,6 +148,30 @@ class OpenRouterClientAdapter {
                     }
                 };
             }
+            // 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,
@@ -136,7 +182,13 @@ class OpenRouterClientAdapter {
             });
             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) {
                 this.logger.info(`OpenRouter API call successful, response ID: ${completion.id}`);
@@ -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
  *