genai-lite 0.8.2 → 0.9.0

package/dist/llm/services/ModelResolver.d.ts

@@ -38,4 +38,10 @@ export declare class ModelResolver {
      * @returns Resolved model info and settings or error response
      */
     resolve(options: ModelSelectionOptions): Promise<ModelResolution>;
+    /**
+     * Asks the llama.cpp adapter which GGUF model the server has loaded and returns
+     * its detected capabilities (cached inside the adapter). Returns undefined when
+     * the server is unreachable or the model is not recognized.
+     */
+    private detectLlamaCppCapabilities;
 }

package/dist/llm/services/ModelResolver.js

@@ -36,7 +36,7 @@ class ModelResolver {
                     }
                 };
             }
-            const modelInfo = (0, config_1.getModelById)(preset.modelId, preset.providerId);
+            let modelInfo = (0, config_1.getModelById)(preset.modelId, preset.providerId);
             if (!modelInfo) {
                 return {
                     error: {
@@ -51,6 +51,14 @@ class ModelResolver {
                     }
                 };
             }
+            // Overlay detected GGUF capabilities for llama.cpp presets (the server decides
+            // which model is actually loaded, regardless of the preset's modelId)
+            if (preset.providerId === 'llamacpp') {
+                const detected = await this.detectLlamaCppCapabilities();
+                if (detected) {
+                    modelInfo = { ...modelInfo, ...detected };
+                }
+            }
             // Merge preset settings with user settings
             const settings = {
                 ...preset.settings,
@@ -94,24 +102,36 @@ class ModelResolver {
             };
         }
         let modelInfo = (0, config_1.getModelById)(options.modelId, options.providerId);
-        if (!modelInfo) {
+        // For llamacpp, try to detect the loaded GGUF model's capabilities from the
+        // adapter. This runs even when the registry lookup succeeded (the documented
+        // `modelId: 'llamacpp'` usage matches the generic registry entry): the server
+        // decides which model is actually loaded, so detected capabilities and vendor
+        // default settings must overlay whatever the registry says.
+        let detectedCapabilities;
+        if (options.providerId === 'llamacpp') {
+            detectedCapabilities = await this.detectLlamaCppCapabilities();
+        }
+        if (modelInfo) {
+            if (detectedCapabilities) {
+                // Overlay detected capabilities onto the registry entry (detection wins:
+                // it reflects the model actually loaded on the server)
+                modelInfo = { ...modelInfo, ...detectedCapabilities };
+            }
+        }
+        else {
             // Check if provider allows unknown models
             const provider = (0, config_1.getProviderById)(options.providerId);
-            // For llamacpp, try to detect capabilities from the adapter's cache
-            let detectedCapabilities;
-            if (options.providerId === 'llamacpp') {
-                try {
-                    const adapter = this.adapterRegistry.getAdapter('llamacpp');
-                    // Check if adapter has the getModelCapabilities method
-                    if (adapter && typeof adapter.getModelCapabilities === 'function') {
-                        const capabilities = await adapter.getModelCapabilities();
-                        detectedCapabilities = capabilities || undefined;
-                    }
-                }
-                catch (error) {
-                    this.logger.warn('Failed to detect GGUF model capabilities:', error);
-                    // Continue with fallback
-                }
+            // Unknown OpenRouter models: assume reasoning-capable (optimistic). OpenRouter
+            // ignores the reasoning param for models that don't support it, and rejecting
+            // here would block reasoning on all unregistered OpenRouter models.
+            if (options.providerId === 'openrouter' && !detectedCapabilities) {
+                detectedCapabilities = {
+                    reasoning: {
+                        supported: true,
+                        enabledByDefault: false,
+                        canDisable: true,
+                    },
+                };
             }
             if (provider?.allowUnknownModels) {
                 // Flexible provider (e.g., llamacpp) - silent fallback with detected capabilities
@@ -131,5 +151,25 @@ class ModelResolver {
             settings: options.settings
         };
     }
+    /**
+     * Asks the llama.cpp adapter which GGUF model the server has loaded and returns
+     * its detected capabilities (cached inside the adapter). Returns undefined when
+     * the server is unreachable or the model is not recognized.
+     */
+    async detectLlamaCppCapabilities() {
+        try {
+            const adapter = this.adapterRegistry.getAdapter('llamacpp');
+            // Check if adapter has the getModelCapabilities method
+            if (adapter && typeof adapter.getModelCapabilities === 'function') {
+                const capabilities = await adapter.getModelCapabilities();
+                return capabilities || undefined;
+            }
+        }
+        catch (error) {
+            this.logger.warn('Failed to detect GGUF model capabilities:', error);
+            // Continue with fallback
+        }
+        return undefined;
+    }
 }
 exports.ModelResolver = ModelResolver;

package/dist/llm/services/RequestValidator.d.ts

@@ -1,8 +1,16 @@
 import type { LLMChatRequest, LLMChatRequestWithPreset, LLMFailureResponse, LLMSettings, ModelInfo, StructuredOutputSettings } from "../types";
+import type { Logger } from "../../logging/types";
 /**
  * Validates LLM requests including structure, messages, and settings
  */
 export declare class RequestValidator {
+    private logger;
+    /**
+     * Creates a new RequestValidator
+     *
+     * @param logger Optional logger instance
+     */
+    constructor(logger?: Logger);
     /**
      * Validates basic LLM request structure
      *

package/dist/llm/services/RequestValidator.js

@@ -2,12 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestValidator = void 0;
 const defaultLogger_1 = require("../../logging/defaultLogger");
-const logger = (0, defaultLogger_1.createDefaultLogger)();
 const config_1 = require("../config");
 /**
  * Validates LLM requests including structure, messages, and settings
  */
 class RequestValidator {
+    /**
+     * Creates a new RequestValidator
+     *
+     * @param logger Optional logger instance
+     */
+    constructor(logger) {
+        this.logger = logger ?? (0, defaultLogger_1.createDefaultLogger)();
+    }
     /**
      * Validates basic LLM request structure
      *
@@ -156,7 +163,7 @@ class RequestValidator {
             }
             // Warn (but don't error) if strict mode requested but not supported
             if (structuredOutput.strict !== false && modelInfo.structuredOutput.strictMode === false) {
-                logger.warn(`Model ${request.modelId} does not support strict mode for structured output. ` +
+                this.logger.warn(`Model ${request.modelId} does not support strict mode for structured output. ` +
                     `Schema validation will be client-side only.`);
             }
         }

package/dist/llm/services/SettingsManager.d.ts

@@ -14,7 +14,7 @@ export declare class SettingsManager {
      * @param requestSettings - Settings from the request
      * @returns Complete settings object with all required fields
      */
-    mergeSettingsForModel(modelId: string, providerId: ApiProviderId, requestSettings?: Partial<LLMSettings>): Required<LLMSettings>;
+    mergeSettingsForModel(modelId: string, providerId: ApiProviderId, requestSettings?: Partial<LLMSettings>, modelInfo?: ModelInfo): Required<LLMSettings>;
     /**
      * Filters out unsupported parameters based on model and provider configuration
      *

package/dist/llm/services/SettingsManager.js

@@ -18,9 +18,20 @@ class SettingsManager {
      * @param requestSettings - Settings from the request
      * @returns Complete settings object with all required fields
      */
-    mergeSettingsForModel(modelId, providerId, requestSettings) {
-        // Get model-specific defaults
-        const modelDefaults = (0, config_1.getDefaultSettingsForModel)(modelId, providerId);
+    mergeSettingsForModel(modelId, providerId, requestSettings, modelInfo) {
+        // Get model-specific defaults (threading the resolved ModelInfo lets detected
+        // GGUF/unknown models contribute capabilities and vendor default settings)
+        let modelDefaults = (0, config_1.getDefaultSettingsForModel)(modelId, providerId, modelInfo);
+        // Apply the reasoning-mode default overlay when reasoning is effectively on for
+        // this request (either explicitly requested or enabled by model default).
+        // Per-key precedence: request > reasoningDefaultSettings > defaultSettings.
+        const reasoningOn = requestSettings?.reasoning?.enabled ?? modelDefaults.reasoning?.enabled;
+        if (reasoningOn === true && modelInfo?.reasoningDefaultSettings) {
+            modelDefaults = {
+                ...modelDefaults,
+                ...modelInfo.reasoningDefaultSettings,
+            };
+        }
         // Merge with user-provided settings (user settings take precedence)
         const mergedSettings = {
             temperature: requestSettings?.temperature ?? modelDefaults.temperature,
@@ -29,6 +40,10 @@ class SettingsManager {
             stopSequences: requestSettings?.stopSequences ?? modelDefaults.stopSequences,
             frequencyPenalty: requestSettings?.frequencyPenalty ?? modelDefaults.frequencyPenalty,
             presencePenalty: requestSettings?.presencePenalty ?? modelDefaults.presencePenalty,
+            topK: requestSettings?.topK ?? modelDefaults.topK,
+            minP: requestSettings?.minP ?? modelDefaults.minP,
+            repeatPenalty: requestSettings?.repeatPenalty ?? modelDefaults.repeatPenalty,
+            seed: requestSettings?.seed ?? modelDefaults.seed,
             user: requestSettings?.user ?? modelDefaults.user,
             supportsSystemMessage: requestSettings?.supportsSystemMessage ??
                 modelDefaults.supportsSystemMessage,
@@ -48,6 +63,14 @@ class SettingsManager {
             },
             openRouterProvider: requestSettings?.openRouterProvider ?? modelDefaults.openRouterProvider,
             structuredOutput: requestSettings?.structuredOutput ?? modelDefaults.structuredOutput,
+            logprobs: requestSettings?.logprobs ?? modelDefaults.logprobs,
+            topLogprobs: requestSettings?.topLogprobs ?? modelDefaults.topLogprobs,
+            llamacpp: requestSettings?.llamacpp || modelDefaults.llamacpp
+                ? {
+                    ...modelDefaults.llamacpp,
+                    ...requestSettings?.llamacpp,
+                }
+                : undefined,
         };
         // Log the final settings for debugging
         this.logger.debug(`Merged settings for ${providerId}/${modelId}:`, {
@@ -121,12 +144,19 @@ class SettingsManager {
             'stopSequences',
             'frequencyPenalty',
             'presencePenalty',
+            'topK',
+            'minP',
+            'repeatPenalty',
+            'seed',
             'user',
             'supportsSystemMessage',
             'geminiSafetySettings',
             'reasoning',
             'thinkingTagFallback',
-            'structuredOutput'
+            'structuredOutput',
+            'logprobs',
+            'topLogprobs',
+            'llamacpp'
         ];
         // Check each setting field
         for (const [key, value] of Object.entries(settings)) {
@@ -166,6 +196,64 @@ class SettingsManager {
                     continue;
                 }
             }
+            if (key === 'topK') {
+                if (typeof value !== 'number' || !Number.isInteger(value) || value < 0) {
+                    this.logger.warn(`Invalid topK value in template: ${value}. Must be a non-negative integer.`);
+                    continue;
+                }
+            }
+            if (key === 'minP') {
+                if (typeof value !== 'number' || value < 0 || value > 1) {
+                    this.logger.warn(`Invalid minP value in template: ${value}. Must be a number between 0 and 1.`);
+                    continue;
+                }
+            }
+            if (key === 'repeatPenalty') {
+                if (typeof value !== 'number' || value <= 0) {
+                    this.logger.warn(`Invalid repeatPenalty value in template: ${value}. Must be a positive number.`);
+                    continue;
+                }
+            }
+            if (key === 'seed') {
+                if (typeof value !== 'number' || !Number.isInteger(value)) {
+                    this.logger.warn(`Invalid seed value in template: ${value}. Must be an integer.`);
+                    continue;
+                }
+            }
+            if (key === 'logprobs' && typeof value !== 'boolean') {
+                this.logger.warn(`Invalid logprobs value in template. Must be a boolean.`);
+                continue;
+            }
+            if (key === 'topLogprobs') {
+                if (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 20) {
+                    this.logger.warn(`Invalid topLogprobs value in template: ${value}. Must be an integer between 0 and 20.`);
+                    continue;
+                }
+            }
+            if (key === 'llamacpp' && typeof value === 'object' && value !== null) {
+                const llamacppValidated = {};
+                const v = value;
+                if ('grammar' in v && typeof v.grammar !== 'string') {
+                    this.logger.warn(`Invalid llamacpp.grammar value in template. Must be a string.`);
+                }
+                else if ('grammar' in v) {
+                    llamacppValidated.grammar = v.grammar;
+                }
+                if ('chatTemplateKwargs' in v) {
+                    if (typeof v.chatTemplateKwargs !== 'object' ||
+                        v.chatTemplateKwargs === null ||
+                        Array.isArray(v.chatTemplateKwargs)) {
+                        this.logger.warn(`Invalid llamacpp.chatTemplateKwargs value in template. Must be an object.`);
+                    }
+                    else {
+                        llamacppValidated.chatTemplateKwargs = v.chatTemplateKwargs;
+                    }
+                }
+                if (Object.keys(llamacppValidated).length > 0) {
+                    validated.llamacpp = llamacppValidated;
+                }
+                continue;
+            }
             if (key === 'user' && typeof value !== 'string') {
                 this.logger.warn(`Invalid user value in template. Must be a string.`);
                 continue;

package/dist/llm/types.d.ts

@@ -284,6 +284,32 @@ export interface LLMSettings {
     frequencyPenalty?: number;
     /** Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far */
     presencePenalty?: number;
+    /**
+     * Limits sampling to the K most likely tokens (integer >= 0; 0 disables top-k filtering).
+     * Supported by: Anthropic (top_k), Gemini (topK), llama.cpp (top_k), OpenRouter (top_k).
+     * Not supported by OpenAI or Mistral (stripped automatically).
+     */
+    topK?: number;
+    /**
+     * Minimum probability threshold relative to the most likely token (0.0 to 1.0; 0 disables).
+     * Note: llama.cpp's server default is 0.05, which matches no vendor recommendation —
+     * detected GGUF models get an explicit 0 by default.
+     * Supported by: llama.cpp (min_p), OpenRouter (min_p). Stripped for other providers.
+     */
+    minP?: number;
+    /**
+     * Multiplicative repetition penalty over prompt + output tokens (1.0 = disabled).
+     * Distinct from presencePenalty (additive, output-only). For Qwen models prefer
+     * presencePenalty and keep repeatPenalty at 1.0 (vendor guidance).
+     * Supported by: llama.cpp (repeat_penalty), OpenRouter (repetition_penalty). Stripped elsewhere.
+     */
+    repeatPenalty?: number;
+    /**
+     * Seed for (best-effort) deterministic sampling. Integer; llama.cpp treats -1 as random.
+     * Supported by: OpenAI (beta; ignored by reasoning models), Gemini, Mistral (randomSeed),
+     * llama.cpp, OpenRouter. Not supported by Anthropic (stripped automatically).
+     */
+    seed?: number;
     /** A unique identifier representing your end-user, which can help monitor and detect abuse */
     user?: string;
     /** Whether the LLM supports system message (almost all LLMs do nowadays) */
@@ -328,6 +354,57 @@ export interface LLMSettings {
      * @see StructuredOutputSettings
      */
     structuredOutput?: StructuredOutputSettings;
+    /**
+     * Request per-token log probabilities on the response.
+     * Supported by: llama.cpp, OpenAI, OpenRouter (pass-through; model-dependent).
+     * Stripped for Anthropic/Gemini/Mistral. Results land on `choice.logprobs`.
+     */
+    logprobs?: boolean;
+    /**
+     * Number of most-likely alternatives to return per token (0-20).
+     * Requires `logprobs: true`.
+     */
+    topLogprobs?: number;
+    /**
+     * llama.cpp-specific settings.
+     * Only used when providerId is 'llamacpp'; ignored by other adapters.
+     * @see LlamaCppSettings
+     */
+    llamacpp?: LlamaCppSettings;
+}
+/**
+ * llama.cpp-specific request settings
+ */
+export interface LlamaCppSettings {
+    /**
+     * Raw GBNF grammar string for constrained decoding.
+     * Mutually exclusive with `structuredOutput` (llama-server rejects both:
+     * "Either 'json_schema' or 'grammar' can be specified, but not both").
+     * Caveat: current llama.cpp builds may not apply the grammar while thinking
+     * is active — prefer grammar with reasoning disabled.
+     */
+    grammar?: string;
+    /**
+     * Extra chat-template kwargs forwarded verbatim to llama-server (requires --jinja).
+     * Merged over any library-derived kwargs (e.g. the reasoning toggle's
+     * enable_thinking), so explicit values here always win.
+     */
+    chatTemplateKwargs?: Record<string, string | number | boolean>;
+}
+/**
+ * Per-token log probability entry (OpenAI-compatible shape, also produced by
+ * llama.cpp's chat completions endpoint).
+ */
+export interface TokenLogprob {
+    /** The generated token text */
+    token: string;
+    /** Log probability of the token */
+    logprob: number;
+    /** Most-likely alternative tokens at this position (when topLogprobs requested) */
+    topLogprobs?: Array<{
+        token: string;
+        logprob: number;
+    }>;
 }
 /**
  * Request structure for chat completion
@@ -361,6 +438,8 @@ export interface LLMChoice {
     reasoning?: string;
     /** Provider-specific reasoning details that need to be preserved */
     reasoning_details?: any;
+    /** Per-token log probabilities (when settings.logprobs was requested and supported) */
+    logprobs?: TokenLogprob[];
     /**
      * Parsed JSON content when structuredOutput is enabled and autoParse is true.
      * Contains the parsed object/array from the JSON response.
@@ -400,6 +479,10 @@ export interface LLMError {
     code?: string | number;
     type?: string;
     param?: string;
+    /** HTTP status code from the provider, when available */
+    status?: number;
+    /** Provider-suggested wait before retrying in ms (from a Retry-After header) */
+    retryAfterMs?: number;
     providerError?: any;
 }
 /**
@@ -482,6 +565,50 @@ export interface ModelInfo {
     unsupportedParameters?: (keyof LLMSettings)[];
     /** Structured output capabilities */
     structuredOutput?: ModelStructuredOutputCapabilities;
+    /**
+     * Model-specific default settings (e.g. vendor-recommended sampling parameters).
+     * Merged below request settings: DEFAULT < provider < MODEL_DEFAULT_SETTINGS <
+     * defaultSettings < request. Used heavily by detected GGUF models, whose vendors
+     * publish sampling profiles that differ from llama.cpp's server defaults.
+     */
+    defaultSettings?: Partial<LLMSettings>;
+    /**
+     * Additional default-settings overlay applied only when reasoning/thinking is
+     * active for the request (e.g. Qwen recommends a different sampling profile in
+     * thinking mode). Per-key precedence: request > reasoningDefaultSettings > defaultSettings.
+     */
+    reasoningDefaultSettings?: Partial<LLMSettings>;
+    /**
+     * Local-model (llama.cpp) reasoning-toggle and output-cleanup metadata.
+     * Battle-tested constants sourced from real chat-template behavior.
+     */
+    localReasoning?: LocalReasoningMetadata;
+}
+/**
+ * Metadata describing how a local (GGUF/llama.cpp) model's chat template handles
+ * thinking mode, and how to clean its output.
+ */
+export interface LocalReasoningMetadata {
+    /**
+     * Name of the chat-template kwarg that toggles thinking (e.g. "enable_thinking").
+     * When set, the llama.cpp adapter sends `chat_template_kwargs: { [toggleKwarg]: <bool> }`
+     * derived from `settings.reasoning.enabled` (explicitly false when reasoning is not
+     * requested). Requires the server to run with `--jinja`. Omit for models whose
+     * thinking cannot be toggled (always-on reasoning models).
+     */
+    toggleKwarg?: string;
+    /**
+     * Exact prefix some chat templates inject into response content when thinking is
+     * disabled (e.g. Qwen's "<think>\n\n</think>\n\n"). Stripped verbatim (exact
+     * startsWith match) from message content before the response is returned.
+     */
+    nothinkPrefix?: string;
+    /**
+     * Open/close marker pair used to extract a reasoning trace from message content
+     * when the server does not populate `reasoning_content` (model/template dependent).
+     * Only fully-closed pairs are extracted.
+     */
+    markers?: [string, string];
 }
 /**
  * IPC channel names for LLM operations

package/dist/prompting/index.d.ts

@@ -8,5 +8,5 @@
  */
 export { renderTemplate } from './template';
 export { countTokens, getSmartPreview, extractRandomVariables } from './content';
-export { parseStructuredContent, extractInitialTaggedContent, parseRoleTags, parseTemplateWithMetadata } from './parser';
+export { parseStructuredContent, extractInitialTaggedContent, extractMarkerDelimitedContent, parseRoleTags, parseTemplateWithMetadata } from './parser';
 export type { TemplateMetadata } from './parser';

package/dist/prompting/index.js

@@ -8,7 +8,7 @@
  * - Response parsing for extracting structured data from LLM outputs
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTemplateWithMetadata = exports.parseRoleTags = exports.extractInitialTaggedContent = exports.parseStructuredContent = exports.extractRandomVariables = exports.getSmartPreview = exports.countTokens = exports.renderTemplate = void 0;
+exports.parseTemplateWithMetadata = exports.parseRoleTags = exports.extractMarkerDelimitedContent = exports.extractInitialTaggedContent = exports.parseStructuredContent = exports.extractRandomVariables = exports.getSmartPreview = exports.countTokens = exports.renderTemplate = void 0;
 // Template rendering
 var template_1 = require("./template");
 Object.defineProperty(exports, "renderTemplate", { enumerable: true, get: function () { return template_1.renderTemplate; } });
@@ -21,5 +21,6 @@ Object.defineProperty(exports, "extractRandomVariables", { enumerable: true, get
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "parseStructuredContent", { enumerable: true, get: function () { return parser_1.parseStructuredContent; } });
 Object.defineProperty(exports, "extractInitialTaggedContent", { enumerable: true, get: function () { return parser_1.extractInitialTaggedContent; } });
+Object.defineProperty(exports, "extractMarkerDelimitedContent", { enumerable: true, get: function () { return parser_1.extractMarkerDelimitedContent; } });
 Object.defineProperty(exports, "parseRoleTags", { enumerable: true, get: function () { return parser_1.parseRoleTags; } });
 Object.defineProperty(exports, "parseTemplateWithMetadata", { enumerable: true, get: function () { return parser_1.parseTemplateWithMetadata; } });

package/dist/prompting/parser.d.ts

@@ -59,6 +59,29 @@ export declare function extractInitialTaggedContent(content: string, tagName: st
     extracted: string | null;
     remaining: string;
 };
+/**
+ * Extracts content delimited by an arbitrary open/close marker pair from anywhere
+ * in a string.
+ *
+ * Unlike {@link extractInitialTaggedContent}, the markers are free-form strings
+ * (not derived from an XML tag name) and may appear anywhere in the content —
+ * useful for local-model thinking traces whose markers aren't XML-shaped
+ * (e.g. Gemma 4's `<|channel>thought` … `<channel|>`).
+ *
+ * Only a fully-closed pair is extracted: if either marker is missing, the
+ * original content is returned untouched and `extracted` is null. Extracted
+ * content that is empty after trimming also yields null.
+ *
+ * @param content The string to parse.
+ * @param openMarker The opening marker (exact match).
+ * @param closeMarker The closing marker (exact match, searched after the opener).
+ * @returns The content with the delimited block removed (leading whitespace
+ *          trimmed), and the extracted inner text (or null).
+ */
+export declare function extractMarkerDelimitedContent(content: string, openMarker: string, closeMarker: string): {
+    content: string;
+    extracted: string | null;
+};
 /**
  * Parses role tags from a template string without rendering variables.
  *

package/dist/prompting/parser.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStructuredContent = parseStructuredContent;
 exports.extractInitialTaggedContent = extractInitialTaggedContent;
+exports.extractMarkerDelimitedContent = extractMarkerDelimitedContent;
 exports.parseRoleTags = parseRoleTags;
 exports.parseTemplateWithMetadata = parseTemplateWithMetadata;
 const defaultLogger_1 = require("../logging/defaultLogger");
@@ -84,6 +85,38 @@ function extractInitialTaggedContent(content, tagName) {
     // If the tag pattern is not found at the start, return the original content.
     return { extracted: null, remaining: content };
 }
+/**
+ * Extracts content delimited by an arbitrary open/close marker pair from anywhere
+ * in a string.
+ *
+ * Unlike {@link extractInitialTaggedContent}, the markers are free-form strings
+ * (not derived from an XML tag name) and may appear anywhere in the content —
+ * useful for local-model thinking traces whose markers aren't XML-shaped
+ * (e.g. Gemma 4's `<|channel>thought` … `<channel|>`).
+ *
+ * Only a fully-closed pair is extracted: if either marker is missing, the
+ * original content is returned untouched and `extracted` is null. Extracted
+ * content that is empty after trimming also yields null.
+ *
+ * @param content The string to parse.
+ * @param openMarker The opening marker (exact match).
+ * @param closeMarker The closing marker (exact match, searched after the opener).
+ * @returns The content with the delimited block removed (leading whitespace
+ *          trimmed), and the extracted inner text (or null).
+ */
+function extractMarkerDelimitedContent(content, openMarker, closeMarker) {
+    const start = content.indexOf(openMarker);
+    if (start === -1) {
+        return { content, extracted: null };
+    }
+    const end = content.indexOf(closeMarker, start + openMarker.length);
+    if (end === -1) {
+        return { content, extracted: null };
+    }
+    const inner = content.substring(start + openMarker.length, end).trim();
+    const cleaned = (content.substring(0, start) + content.substring(end + closeMarker.length)).trimStart();
+    return { content: cleaned, extracted: inner || null };
+}
 /**
  * Parses role tags from a template string without rendering variables.
  *

package/dist/shared/adapters/errorUtils.d.ts

@@ -7,7 +7,22 @@ export interface MappedErrorDetails {
     errorMessage: string;
     errorType: string;
     status?: number;
+    /** Provider-suggested wait before retrying (parsed from a Retry-After header) */
+    retryAfterMs?: number;
 }
+/**
+ * Parses a Retry-After header value (delta-seconds or HTTP-date) into milliseconds.
+ *
+ * @param value - The raw header value
+ * @returns Milliseconds to wait, or undefined when unparseable/negative
+ */
+export declare function parseRetryAfterMs(value: string | null | undefined): number | undefined;
+/**
+ * Extracts a Retry-After value in ms from an SDK error object, tolerating the
+ * different places SDKs keep response headers (openai/anthropic `error.headers`
+ * as a Headers instance or plain object; Speakeasy-style `error.rawResponse`).
+ */
+export declare function extractRetryAfterMs(error: any): number | undefined;
 /**
  * Maps common error patterns to standardized error codes and types
  *