genai-lite 0.8.3 → 0.9.1

package/dist/llm/LLMService.js

@@ -18,6 +18,8 @@ const AdapterRegistry_1 = require("../shared/services/AdapterRegistry");
 const RequestValidator_1 = require("./services/RequestValidator");
 const SettingsManager_1 = require("./services/SettingsManager");
 const ModelResolver_1 = require("./services/ModelResolver");
+const withRetry_1 = require("../shared/services/withRetry");
+const types_1 = require("./clients/types");
 /**
  * Main process service for LLM operations
  *
@@ -32,6 +34,8 @@ const ModelResolver_1 = require("./services/ModelResolver");
 class LLMService {
     constructor(getApiKey, options = {}) {
         this.getApiKey = getApiKey;
+        this.retryOptions = options.retry;
+        this.defaultTimeoutMs = options.timeoutMs;
         // Initialize logger - custom logger takes precedence over logLevel
         this.logger = options.logger ?? (0, defaultLogger_1.createDefaultLogger)(options.logLevel);
         // Initialize services with logger
@@ -78,7 +82,7 @@ class LLMService {
      * @param request - The LLM chat request
      * @returns Promise resolving to either success or failure response
      */
-    async sendMessage(request) {
+    async sendMessage(request, callOptions) {
         this.logger.info(`LLMService.sendMessage called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
         try {
             // Resolve model information from preset or direct IDs
@@ -107,7 +111,7 @@ class LLMService {
                 }
             }
             // Apply model-specific defaults and merge with user settings
-            const finalSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, combinedSettings);
+            const finalSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, combinedSettings, modelInfo);
             // Validate reasoning settings for model capabilities
             const reasoningValidation = this.requestValidator.validateReasoningSettings(modelInfo, finalSettings.reasoning, resolvedRequest);
             if (reasoningValidation) {
@@ -175,7 +179,41 @@ class LLMService {
                     };
                 }
                 this.logger.info(`Making LLM request with ${clientAdapter.constructor.name} for provider: ${providerId}`);
-                const result = await clientAdapter.sendMessage(internalRequest, apiKey);
+                // Unified retry layer: adapters never throw, so retry decisions are made on
+                // RETURNED failure responses. SDK-internal retries are disabled (maxRetries: 0
+                // at client construction) — this loop is the single owner of retry behavior.
+                const adapterOptions = {
+                    ...(callOptions?.signal && { signal: callOptions.signal }),
+                    ...((callOptions?.timeoutMs ?? this.defaultTimeoutMs) !== undefined && {
+                        timeoutMs: callOptions?.timeoutMs ?? this.defaultTimeoutMs,
+                    }),
+                };
+                const retryOnTimeout = this.retryOptions?.retryOnTimeout ?? true;
+                const retryableCodes = new Set([
+                    types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED,
+                    types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR,
+                    ...(retryOnTimeout ? [types_1.ADAPTER_ERROR_CODES.REQUEST_TIMEOUT] : []),
+                ]);
+                const result = await (0, withRetry_1.withRetry)(() => clientAdapter.sendMessage(internalRequest, apiKey, adapterOptions), (res) => {
+                    if (res.object !== 'error') {
+                        return { retry: false };
+                    }
+                    const code = String(res.error.code);
+                    const status = res.error.status;
+                    const retryable = retryableCodes.has(code) ||
+                        (code === types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR &&
+                            typeof status === 'number' &&
+                            (status === 408 || status === 409 || status >= 500));
+                    return { retry: retryable, retryAfterMs: res.error.retryAfterMs };
+                }, {
+                    ...this.retryOptions,
+                    ...(callOptions?.maxRetries !== undefined && {
+                        maxRetries: callOptions.maxRetries,
+                    }),
+                    signal: callOptions?.signal,
+                    logger: this.logger,
+                    label: `${providerId}/${modelId}`,
+                });
                 // Post-process for thinking tag fallback
                 // This feature extracts reasoning from XML tags when native reasoning is not active.
                 // It's a fallback mechanism for models without native reasoning or when native is disabled.
@@ -375,7 +413,7 @@ class LLMService {
             else {
                 const { providerId, modelId, modelInfo, settings } = resolved;
                 // Merge settings with model defaults
-                const mergedSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, settings || {});
+                const mergedSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, settings || {}, modelInfo);
                 // Calculate native reasoning status
                 const nativeReasoningActive = !!(modelInfo.reasoning?.supported &&
                     (mergedSettings.reasoning?.enabled === true ||

package/dist/llm/clients/AnthropicClientAdapter.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 Anthropic API integration
@@ -32,7 +32,7 @@ export declare class AnthropicClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The decrypted Anthropic 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 Anthropic API key format
      *

package/dist/llm/clients/AnthropicClientAdapter.js

@@ -40,7 +40,7 @@ class AnthropicClientAdapter {
      * @param apiKey - The decrypted Anthropic API key
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
             // Check if structured output is requested - need beta API
             const useStructuredOutput = request.settings.structuredOutput?.schema &&
@@ -49,7 +49,13 @@ class AnthropicClientAdapter {
             const anthropic = new sdk_1.default({
                 apiKey,
                 ...(this.baseURL && { baseURL: this.baseURL }),
+                maxRetries: 0, // retries are owned by the unified LLMService retry layer
             });
+            // Per-request transport options (abort signal, timeout)
+            const requestTransportOptions = {
+                ...(options?.signal && { signal: options.signal }),
+                ...(options?.timeoutMs !== undefined && { timeout: options.timeoutMs }),
+            };
             // Format messages for Anthropic API (Claude has specific requirements)
             const { messages, systemMessage } = this.formatMessagesForAnthropic(request);
             // Prepare API call parameters
@@ -59,6 +65,9 @@ class AnthropicClientAdapter {
                 max_tokens: request.settings.maxTokens,
                 temperature: request.settings.temperature,
                 top_p: request.settings.topP,
+                ...(request.settings.topK !== undefined && {
+                    top_k: request.settings.topK,
+                }),
                 ...(systemMessage && { system: systemMessage }),
                 ...(request.settings.stopSequences.length > 0 && {
                     stop_sequences: request.settings.stopSequences,
@@ -135,10 +144,14 @@ class AnthropicClientAdapter {
                     headers: {
                         'anthropic-beta': 'structured-outputs-2025-11-13',
                     },
+                    ...requestTransportOptions,
                 });
             }
             else {
-                completion = await anthropic.messages.create(messageParams);
+                completion =
+                    Object.keys(requestTransportOptions).length > 0
+                        ? await anthropic.messages.create(messageParams, requestTransportOptions)
+                        : await anthropic.messages.create(messageParams);
             }
             this.logger.info(`Anthropic API call successful, response ID: ${completion.id}`);
             // Convert to standardized response format
@@ -387,7 +400,7 @@ class AnthropicClientAdapter {
     createErrorResponse(error, request) {
         // Use shared error mapping utility for common error patterns
         const initialProviderMessage = error instanceof sdk_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 Anthropic-specific refinements for 400 errors based on message content
         if (error instanceof sdk_1.default.APIError && status === 400) {
             if (error.message.toLowerCase().includes("context length") ||
@@ -409,6 +422,7 @@ class AnthropicClientAdapter {
                 code: errorCode,
                 type: errorType,
                 ...(status && { status }),
+                ...(retryAfterMs !== undefined && { retryAfterMs }),
                 providerError: error,
             },
             object: "error",

package/dist/llm/clients/GeminiClientAdapter.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 Google Gemini API integration
@@ -32,7 +32,7 @@ export declare class GeminiClientAdapter implements ILLMClientAdapter {
      * @param apiKey - The decrypted Gemini 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 Gemini API key format
      *

package/dist/llm/clients/GeminiClientAdapter.js

@@ -37,9 +37,9 @@ class GeminiClientAdapter {
      * @param apiKey - The decrypted Gemini API key
      * @returns Promise resolving to success or failure response
      */
-    async sendMessage(request, apiKey) {
+    async sendMessage(request, apiKey, options) {
         try {
-            // Initialize Gemini client
+            // Initialize Gemini client (note: @google/genai performs no automatic retries)
             const genAI = new genai_1.GoogleGenAI({ apiKey });
             // Format the request for Gemini API
             const { contents, generationConfig, safetySettings, systemInstruction } = this.formatInternalRequestToGemini(request);
@@ -60,6 +60,10 @@ class GeminiClientAdapter {
                     ...generationConfig,
                     safetySettings: safetySettings,
                     ...(systemInstruction && { systemInstruction: systemInstruction }),
+                    ...(options?.signal && { abortSignal: options.signal }),
+                    ...(options?.timeoutMs !== undefined && {
+                        httpOptions: { timeout: options.timeoutMs },
+                    }),
                 },
             });
             this.logger.info(`Gemini API call successful, processing response`);
@@ -153,6 +157,12 @@ class GeminiClientAdapter {
             maxOutputTokens: request.settings.maxTokens,
             temperature: request.settings.temperature,
             ...(request.settings.topP && { topP: request.settings.topP }),
+            ...(request.settings.topK !== undefined && {
+                topK: request.settings.topK,
+            }),
+            ...(request.settings.seed !== undefined && {
+                seed: request.settings.seed,
+            }),
             ...(request.settings.stopSequences &&
                 request.settings.stopSequences.length > 0 && {
                 stopSequences: request.settings.stopSequences,
@@ -307,7 +317,7 @@ class GeminiClientAdapter {
     createErrorResponse(error, request) {
         // Use shared error mapping utility for common error patterns
         const initialProviderMessage = error?.message;
-        let { errorCode, errorMessage, errorType, status } = (0, errorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
+        let { errorCode, errorMessage, errorType, status, retryAfterMs } = (0, errorUtils_1.getCommonMappedErrorDetails)(error, initialProviderMessage);
         // Apply Gemini-specific refinements for certain error types
         if (error && error.message) {
             const message = error.message.toLowerCase();
@@ -337,6 +347,7 @@ class GeminiClientAdapter {
                 code: errorCode,
                 type: errorType,
                 ...(status && { status }),
+                ...(retryAfterMs !== undefined && { retryAfterMs }),
                 providerError: error,
             },
             object: "error",

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

@@ -1,12 +1,12 @@
 import type { LLMResponse, LLMFailureResponse, ModelInfo } from "../types";
-import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
 import { LlamaCppServerClient } from "./LlamaCppServerClient";
 import type { Logger } from "../../logging/types";
 /**
  * Configuration options for LlamaCppClientAdapter
  */
 export interface LlamaCppClientConfig {
-    /** Base URL of the llama.cpp server (default: http://localhost:8080) */
+    /** Base URL of the llama.cpp server (default: http://127.0.0.1:8080) */
     baseURL?: string;
     /** Whether to check server health before sending requests (default: false) */
     checkHealth?: boolean;
@@ -33,7 +33,7 @@ export interface LlamaCppClientConfig {
  * ```typescript
  * // Create adapter for local server
  * const adapter = new LlamaCppClientAdapter({
- *   baseURL: 'http://localhost:8080',
+ *   baseURL: 'http://127.0.0.1:8080',
  *   checkHealth: true
  * });
  *
@@ -84,7 +84,7 @@ export declare class LlamaCppClientAdapter implements ILLMClientAdapter {
      * @param apiKey - Not used for llama.cpp (local server), but kept for interface compatibility
      * @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 API key format
      *

package/dist/llm/clients/LlamaCppClientAdapter.js

@@ -12,6 +12,8 @@ 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");
 /**
  * Client adapter for llama.cpp server integration
@@ -33,7 +35,7 @@ const defaultLogger_1 = require("../../logging/defaultLogger");
  * ```typescript
  * // Create adapter for local server
  * const adapter = new LlamaCppClientAdapter({
- *   baseURL: 'http://localhost:8080',
+ *   baseURL: 'http://127.0.0.1:8080',
  *   checkHealth: true
  * });
  *
@@ -57,7 +59,10 @@ 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)();
@@ -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) {
@@ -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,6 +202,56 @@ class LlamaCppClientAdapter {
                     schema: so.schema,
                 };
             }
+            // 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,
@@ -191,11 +261,17 @@ class LlamaCppClientAdapter {
             });
             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) {
                 this.logger.info(`llama.cpp API call successful, response ID: ${completion.id}`);
-                return this.createSuccessResponse(completion, request);
+                return this.createSuccessResponse(completion, request, detectedCaps);
             }
             else {
                 throw new Error('Unexpected streaming response from llama.cpp server');
@@ -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,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 MistralClientAdapter
@@ -52,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

@@ -51,9 +51,10 @@ 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,
@@ -78,6 +79,9 @@ 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
@@ -87,8 +91,14 @@ class MistralClientAdapter {
                 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) {
                 this.logger.info(`Mistral API call successful, response ID: ${completion.id}`);
                 return this.createSuccessResponse(completion, request);
@@ -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)
      */