genai-lite 0.11.0 → 0.12.0

package/README.md

@@ -6,6 +6,7 @@ A lightweight, portable Node.js/TypeScript library providing a unified interface
 
 - 🔌 **Unified API** - Single interface for multiple AI providers
 - 🏠 **Local & Cloud Models** - Run models locally with llama.cpp or use cloud APIs
+- ⚡ **Text Streaming** - Async iterable token deltas for OpenAI, Anthropic, Gemini, Mistral, OpenRouter, and llama.cpp
 - 🖼️ **Image Generation** - First-class support for AI image generation (OpenAI, local diffusion)
 - 🔐 **Flexible API Key Management** - Bring your own key storage solution
 - 📦 **Zero Electron Dependencies** - Works in any Node.js environment
@@ -77,6 +78,33 @@ if (response.object === 'chat.completion') {
 }
 ```
 
+### Streaming Text
+
+```typescript
+import { LLMService } from 'genai-lite';
+
+const llmService = new LLMService(async () => 'not-needed');
+
+for await (const event of llmService.streamMessage({
+  providerId: 'llamacpp',
+  modelId: 'llamacpp',
+  messages: [{ role: 'user', content: 'Say hello in five words.' }],
+  settings: { maxTokens: 32 }
+})) {
+  if (event.type === 'content_delta') {
+    process.stdout.write(event.delta);
+  } else if (event.type === 'reasoning_delta') {
+    process.stderr.write(event.delta);
+  } else if (event.type === 'complete') {
+    console.log('\nTokens:', event.response.usage?.total_tokens);
+  } else if (event.type === 'error') {
+    console.error(event.error.error.message);
+  }
+}
+```
+
+Streaming is implemented for all text providers: `openai`, `anthropic`, `gemini`, `mistral`, `openrouter`, and `llamacpp`. The final `complete.response` event contains the same normalized response shape returned by `sendMessage()`.
+
 ### Image Generation
 
 ```typescript
@@ -134,7 +162,7 @@ Comprehensive documentation is available in the **[`genai-lite-docs`](./genai-li
 - **Google Gemini** - Gemini 3 (Pro, Flash preview), Gemini 2.5, Gemma 3 & 4 (free)
 - **Mistral** - Codestral, Devstral
 - **OpenRouter** - Unified gateway to 100+ models (unknown models assumed reasoning-capable)
-- **llama.cpp** - Run any GGUF model locally (no API keys required); local reasoning toggle for detected models
+- **llama.cpp** - Run any GGUF model locally (no API keys required); streaming and local reasoning toggle for detected models
 
 ### Image Providers
 - **OpenAI Images** - gpt-image-1, dall-e-3, dall-e-2

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export type { ApiKeyProvider, PresetMode } from "./types";
 export { LLMService } from "./llm/LLMService";
-export type { LLMServiceOptions, SendMessageOptions, CreateMessagesResult } from "./llm/LLMService";
+export type { LLMServiceOptions, SendMessageOptions, StreamMessageOptions, CreateMessagesResult } from "./llm/LLMService";
 export { withRetry, DEFAULT_RETRY_POLICY } from "./shared/services/withRetry";
 export type { RetryPolicy, RetryVerdict, WithRetryOptions } from "./shared/services/withRetry";
 export type { ModelPreset } from "./types/presets";

package/dist/llm/LLMService.d.ts

@@ -1,6 +1,6 @@
 import type { ApiKeyProvider, PresetMode } from '../types';
 import type { Logger, LogLevel } from '../logging/types';
-import type { LLMChatRequest, LLMChatRequestWithPreset, LLMResponse, LLMFailureResponse, ProviderInfo, ModelInfo, ApiProviderId, LLMSettings, ModelContext, LLMMessage } from "./types";
+import type { LLMChatRequest, LLMChatRequestWithPreset, LLMResponse, LLMFailureResponse, ProviderInfo, ModelInfo, ApiProviderId, LLMSettings, ModelContext, LLMMessage, LLMStreamEvent } from "./types";
 import type { ModelPreset } from "../types/presets";
 import { type RetryPolicy } from "../shared/services/withRetry";
 export type { PresetMode };
@@ -43,6 +43,18 @@ export interface SendMessageOptions {
     /** Per-request retry cap (overrides the service-level retry.maxRetries) */
     maxRetries?: number;
 }
+/**
+ * Per-call options for LLMService.streamMessage
+ */
+export interface StreamMessageOptions {
+    /**
+     * Abort signal to cancel the request (client-side - the provider may still
+     * process and bill an already-dispatched request).
+     */
+    signal?: AbortSignal;
+    /** Per-request timeout in ms (overrides the service-level timeoutMs) */
+    timeoutMs?: number;
+}
 /**
  * Result from createMessages method
  */
@@ -96,6 +108,16 @@ export declare class LLMService {
      * @returns Promise resolving to either success or failure response
      */
     sendMessage(request: LLMChatRequest | LLMChatRequestWithPreset, callOptions?: SendMessageOptions): Promise<LLMResponse | LLMFailureResponse>;
+    /**
+     * Streams a chat message from an LLM provider.
+     *
+     * The final `complete` event contains the same normalized response shape as
+     * sendMessage(). Validation/API key failures and unsupported streaming adapters
+     * are yielded as a single `error` event.
+     */
+    streamMessage(request: LLMChatRequest | LLMChatRequestWithPreset, callOptions?: StreamMessageOptions): AsyncGenerator<LLMStreamEvent>;
+    private prepareRequest;
+    private postProcessResponse;
     /**
      * Gets all configured model presets
      *

package/dist/llm/LLMService.js

@@ -85,116 +85,23 @@ class LLMService {
     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
-            const resolved = await this.modelResolver.resolve(request);
-            if (resolved.error) {
-                return resolved.error;
-            }
-            const { providerId, modelId, modelInfo, settings: resolvedSettings } = resolved;
-            // Create a proper LLMChatRequest with resolved values
-            const resolvedRequest = {
-                ...request,
-                providerId: providerId,
-                modelId: modelId,
-            };
-            // Validate basic request structure
-            const structureValidationResult = this.requestValidator.validateRequestStructure(resolvedRequest);
-            if (structureValidationResult) {
-                return structureValidationResult;
-            }
-            // Validate settings if provided  
-            const combinedSettings = { ...resolvedSettings, ...request.settings };
-            if (combinedSettings) {
-                const settingsValidation = this.requestValidator.validateSettings(combinedSettings, providerId, modelId);
-                if (settingsValidation) {
-                    return settingsValidation;
-                }
-            }
-            // Apply model-specific defaults and merge with user settings
-            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) {
-                return reasoningValidation;
+            const preparedResult = await this.prepareRequest(request, callOptions);
+            if ("error" in preparedResult) {
+                return preparedResult.error;
             }
-            // Validate structured output settings for model capabilities
-            const structuredOutputValidation = this.requestValidator.validateStructuredOutputSettings(modelInfo, finalSettings.structuredOutput, resolvedRequest);
-            if (structuredOutputValidation) {
-                return structuredOutputValidation;
-            }
-            // Get provider info for parameter filtering
-            const providerInfo = (0, config_1.getProviderById)(providerId);
-            if (!providerInfo) {
-                return {
-                    provider: providerId,
-                    model: modelId,
-                    error: {
-                        message: `Provider information not found: ${providerId}`,
-                        code: "PROVIDER_ERROR",
-                        type: "server_error",
-                    },
-                    object: "error",
-                };
-            }
-            // Filter out unsupported parameters
-            const filteredSettings = this.settingsManager.filterUnsupportedParameters(finalSettings, modelInfo, providerInfo);
-            const internalRequest = {
-                ...resolvedRequest,
-                settings: filteredSettings,
-            };
-            this.logger.debug(`Processing LLM request with (potentially filtered) settings:`, {
-                provider: providerId,
-                model: modelId,
-                settings: filteredSettings,
-                messageCount: resolvedRequest.messages.length,
-            });
-            // Get client adapter
-            const clientAdapter = this.adapterRegistry.getAdapter(providerId);
-            // Use ApiKeyProvider to get the API key and make the request
+            const prepared = preparedResult.prepared;
             try {
-                const apiKey = await this.getApiKey(providerId);
-                if (!apiKey) {
-                    return {
-                        provider: providerId,
-                        model: modelId,
-                        error: {
-                            message: `API key for provider '${providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`,
-                            code: "API_KEY_ERROR",
-                            type: "authentication_error",
-                        },
-                        object: "error",
-                    };
-                }
-                // Validate API key format if adapter supports it
-                if (clientAdapter.validateApiKey && !clientAdapter.validateApiKey(apiKey)) {
-                    return {
-                        provider: providerId,
-                        model: modelId,
-                        error: {
-                            message: `Invalid API key format for provider '${providerId}'. Please check your API key.`,
-                            code: "INVALID_API_KEY",
-                            type: "authentication_error",
-                        },
-                        object: "error",
-                    };
-                }
-                this.logger.info(`Making LLM request with ${clientAdapter.constructor.name} for provider: ${providerId}`);
+                this.logger.info(`Making LLM request with ${prepared.clientAdapter.constructor.name} for provider: ${prepared.providerId}`);
                 // 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) => {
+                const result = await (0, withRetry_1.withRetry)(() => prepared.clientAdapter.sendMessage(prepared.internalRequest, prepared.apiKey, prepared.adapterOptions), (res) => {
                     if (res.object !== 'error') {
                         return { retry: false };
                     }
@@ -212,99 +119,19 @@ class LLMService {
                     }),
                     signal: callOptions?.signal,
                     logger: this.logger,
-                    label: `${providerId}/${modelId}`,
+                    label: `${prepared.providerId}/${prepared.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.
-                const fallbackSettings = internalRequest.settings.thinkingTagFallback;
-                if (result.object === 'chat.completion' && fallbackSettings && fallbackSettings.enabled !== false) {
-                    const tagName = fallbackSettings.tagName || 'thinking';
-                    // Check if native reasoning is active for this request
-                    const isNativeReasoningActive = modelInfo.reasoning?.supported === true &&
-                        (internalRequest.settings.reasoning?.enabled === true ||
-                            (modelInfo.reasoning?.enabledByDefault === true &&
-                                internalRequest.settings.reasoning?.enabled !== false) ||
-                            modelInfo.reasoning?.canDisable === false);
-                    // Process the response - extract thinking tags if present
-                    const choice = result.choices[0];
-                    if (choice?.message?.content) {
-                        const { extracted, remaining } = (0, parser_1.extractInitialTaggedContent)(choice.message.content, tagName);
-                        if (extracted !== null) {
-                            // Success: thinking tag found
-                            this.logger.debug(`Extracted <${tagName}> block from response.`);
-                            // Handle the edge case: append to existing reasoning if present (e.g., native reasoning + thinking tags)
-                            const existingReasoning = choice.reasoning || '';
-                            if (existingReasoning) {
-                                // Use a neutral markdown header that works for any consumer (human or AI)
-                                choice.reasoning = `${existingReasoning}\n\n#### Additional Reasoning\n\n${extracted}`;
-                            }
-                            else {
-                                // No existing reasoning, just use the extracted content directly
-                                choice.reasoning = extracted;
-                            }
-                            choice.message.content = remaining;
-                        }
-                        else {
-                            // Tag was not found
-                            // Enforce only if: (1) enforce: true AND (2) native reasoning is NOT active
-                            if (fallbackSettings.enforce === true && !isNativeReasoningActive) {
-                                const nativeReasoningCapable = modelInfo.reasoning?.supported === true;
-                                return {
-                                    provider: providerId,
-                                    model: modelId,
-                                    error: {
-                                        message: `Model response missing required <${tagName}> tags.`,
-                                        code: "THINKING_TAGS_MISSING",
-                                        type: "validation_error",
-                                        param: nativeReasoningCapable && !isNativeReasoningActive
-                                            ? `You disabled native reasoning for this model (${modelId}). ` +
-                                                `To see its reasoning, you must prompt it to use <${tagName}> tags. ` +
-                                                `Example: "Write your step-by-step reasoning in <${tagName}> tags before answering."`
-                                            : `This model (${modelId}) does not support native reasoning. ` +
-                                                `To get reasoning, you must prompt it to use <${tagName}> tags. ` +
-                                                `Example: "Write your step-by-step reasoning in <${tagName}> tags before answering."`,
-                                    },
-                                    object: "error",
-                                    partialResponse: {
-                                        id: result.id,
-                                        provider: result.provider,
-                                        model: result.model,
-                                        created: result.created,
-                                        choices: result.choices,
-                                        usage: result.usage
-                                    }
-                                };
-                            }
-                            // If enforce: false or native reasoning is active, do nothing
-                        }
-                    }
-                }
-                // Post-process for structured output auto-parsing
-                // Parse JSON response when structuredOutput is enabled and autoParse is not disabled
-                const structuredOutputSettings = internalRequest.settings.structuredOutput;
-                if (result.object === 'chat.completion' && structuredOutputSettings &&
-                    structuredOutputSettings.enabled !== false && structuredOutputSettings.autoParse !== false) {
-                    for (const choice of result.choices) {
-                        if (choice.message?.content) {
-                            try {
-                                choice.parsedContent = JSON.parse(choice.message.content);
-                            }
-                            catch (e) {
-                                choice.parseError = `JSON parse failed: ${e instanceof Error ? e.message : String(e)}`;
-                                this.logger.warn(`Failed to parse structured output for choice ${choice.index}: ${choice.parseError}`);
-                            }
-                        }
-                    }
+                const processedResult = this.postProcessResponse(result, prepared);
+                if (processedResult.object === "chat.completion") {
+                    this.logger.info(`LLM request completed successfully for model: ${prepared.modelId}`);
                 }
-                this.logger.info(`LLM request completed successfully for model: ${modelId}`);
-                return result;
+                return processedResult;
             }
             catch (error) {
                 this.logger.error("Error in LLMService.sendMessage:", error);
                 return {
-                    provider: providerId,
-                    model: modelId,
+                    provider: prepared.providerId,
+                    model: prepared.modelId,
                     error: {
                         message: error instanceof Error
                             ? error.message
@@ -334,6 +161,319 @@ class LLMService {
             };
         }
     }
+    /**
+     * Streams a chat message from an LLM provider.
+     *
+     * The final `complete` event contains the same normalized response shape as
+     * sendMessage(). Validation/API key failures and unsupported streaming adapters
+     * are yielded as a single `error` event.
+     */
+    async *streamMessage(request, callOptions) {
+        this.logger.info(`LLMService.streamMessage called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
+        try {
+            const preparedResult = await this.prepareRequest(request, callOptions);
+            if ("error" in preparedResult) {
+                yield { type: "error", error: preparedResult.error };
+                return;
+            }
+            const prepared = preparedResult.prepared;
+            if (!prepared.clientAdapter.streamMessage) {
+                yield {
+                    type: "error",
+                    error: {
+                        provider: prepared.providerId,
+                        model: prepared.modelId,
+                        error: {
+                            message: `Streaming is not supported for provider '${prepared.providerId}'.`,
+                            code: "PROVIDER_ERROR",
+                            type: "unsupported_feature",
+                        },
+                        object: "error",
+                    },
+                };
+                return;
+            }
+            try {
+                for await (const event of prepared.clientAdapter.streamMessage(prepared.internalRequest, prepared.apiKey, prepared.adapterOptions)) {
+                    if (event.type === "complete") {
+                        const processedResult = this.postProcessResponse(event.response, prepared);
+                        if (processedResult.object === "error") {
+                            yield { type: "error", error: processedResult };
+                        }
+                        else {
+                            yield { type: "complete", response: processedResult };
+                        }
+                        continue;
+                    }
+                    yield event;
+                }
+            }
+            catch (error) {
+                this.logger.error("Error in LLMService.streamMessage:", error);
+                yield {
+                    type: "error",
+                    error: {
+                        provider: prepared.providerId,
+                        model: prepared.modelId,
+                        error: {
+                            message: error instanceof Error
+                                ? error.message
+                                : "An unknown error occurred during message streaming.",
+                            code: "PROVIDER_ERROR",
+                            type: "server_error",
+                            providerError: error,
+                        },
+                        object: "error",
+                    },
+                };
+            }
+        }
+        catch (error) {
+            this.logger.error("Error in LLMService.streamMessage (outer):", error);
+            yield {
+                type: "error",
+                error: {
+                    provider: request.providerId || request.presetId || 'unknown',
+                    model: request.modelId || request.presetId || 'unknown',
+                    error: {
+                        message: error instanceof Error
+                            ? error.message
+                            : "An unknown error occurred.",
+                        code: "UNEXPECTED_ERROR",
+                        type: "server_error",
+                        providerError: error,
+                    },
+                    object: "error",
+                },
+            };
+        }
+    }
+    async prepareRequest(request, callOptions) {
+        // Resolve model information from preset or direct IDs
+        const resolved = await this.modelResolver.resolve(request);
+        if (resolved.error) {
+            return { error: resolved.error };
+        }
+        const { providerId, modelId, modelInfo, settings: resolvedSettings } = resolved;
+        // Create a proper LLMChatRequest with resolved values
+        const resolvedRequest = {
+            ...request,
+            providerId: providerId,
+            modelId: modelId,
+        };
+        // Validate basic request structure
+        const structureValidationResult = this.requestValidator.validateRequestStructure(resolvedRequest);
+        if (structureValidationResult) {
+            return { error: structureValidationResult };
+        }
+        // Validate settings if provided
+        const combinedSettings = { ...resolvedSettings, ...request.settings };
+        if (combinedSettings) {
+            const settingsValidation = this.requestValidator.validateSettings(combinedSettings, providerId, modelId);
+            if (settingsValidation) {
+                return { error: settingsValidation };
+            }
+        }
+        // Apply model-specific defaults and merge with user settings
+        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) {
+            return { error: reasoningValidation };
+        }
+        // Validate structured output settings for model capabilities
+        const structuredOutputValidation = this.requestValidator.validateStructuredOutputSettings(modelInfo, finalSettings.structuredOutput, resolvedRequest);
+        if (structuredOutputValidation) {
+            return { error: structuredOutputValidation };
+        }
+        // Get provider info for parameter filtering
+        const providerInfo = (0, config_1.getProviderById)(providerId);
+        if (!providerInfo) {
+            return {
+                error: {
+                    provider: providerId,
+                    model: modelId,
+                    error: {
+                        message: `Provider information not found: ${providerId}`,
+                        code: "PROVIDER_ERROR",
+                        type: "server_error",
+                    },
+                    object: "error",
+                },
+            };
+        }
+        // Filter out unsupported parameters
+        const filteredSettings = this.settingsManager.filterUnsupportedParameters(finalSettings, modelInfo, providerInfo);
+        const internalRequest = {
+            ...resolvedRequest,
+            settings: filteredSettings,
+        };
+        this.logger.debug(`Processing LLM request with (potentially filtered) settings:`, {
+            provider: providerId,
+            model: modelId,
+            settings: filteredSettings,
+            messageCount: resolvedRequest.messages.length,
+        });
+        // Get client adapter
+        const clientAdapter = this.adapterRegistry.getAdapter(providerId);
+        try {
+            const apiKey = await this.getApiKey(providerId);
+            if (!apiKey) {
+                return {
+                    error: {
+                        provider: providerId,
+                        model: modelId,
+                        error: {
+                            message: `API key for provider '${providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`,
+                            code: "API_KEY_ERROR",
+                            type: "authentication_error",
+                        },
+                        object: "error",
+                    },
+                };
+            }
+            // Validate API key format if adapter supports it
+            if (clientAdapter.validateApiKey && !clientAdapter.validateApiKey(apiKey)) {
+                return {
+                    error: {
+                        provider: providerId,
+                        model: modelId,
+                        error: {
+                            message: `Invalid API key format for provider '${providerId}'. Please check your API key.`,
+                            code: "INVALID_API_KEY",
+                            type: "authentication_error",
+                        },
+                        object: "error",
+                    },
+                };
+            }
+            const adapterOptions = {
+                ...(callOptions?.signal && { signal: callOptions.signal }),
+                ...((callOptions?.timeoutMs ?? this.defaultTimeoutMs) !== undefined && {
+                    timeoutMs: callOptions?.timeoutMs ?? this.defaultTimeoutMs,
+                }),
+            };
+            return {
+                prepared: {
+                    providerId: providerId,
+                    modelId: modelId,
+                    modelInfo: modelInfo,
+                    resolvedRequest,
+                    internalRequest,
+                    clientAdapter,
+                    apiKey,
+                    adapterOptions,
+                },
+            };
+        }
+        catch (error) {
+            this.logger.error("Error preparing LLM request:", error);
+            return {
+                error: {
+                    provider: providerId,
+                    model: modelId,
+                    error: {
+                        message: error instanceof Error
+                            ? error.message
+                            : "An unknown error occurred during request preparation.",
+                        code: "PROVIDER_ERROR",
+                        type: "server_error",
+                        providerError: error,
+                    },
+                    object: "error",
+                },
+            };
+        }
+    }
+    postProcessResponse(result, prepared) {
+        if (result.object === "error") {
+            return result;
+        }
+        // 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.
+        const fallbackSettings = prepared.internalRequest.settings.thinkingTagFallback;
+        if (fallbackSettings && fallbackSettings.enabled !== false) {
+            const tagName = fallbackSettings.tagName || 'thinking';
+            // Check if native reasoning is active for this request
+            const isNativeReasoningActive = prepared.modelInfo.reasoning?.supported === true &&
+                (prepared.internalRequest.settings.reasoning?.enabled === true ||
+                    (prepared.modelInfo.reasoning?.enabledByDefault === true &&
+                        prepared.internalRequest.settings.reasoning?.enabled !== false) ||
+                    prepared.modelInfo.reasoning?.canDisable === false);
+            // Process the response - extract thinking tags if present
+            const choice = result.choices[0];
+            if (choice?.message?.content) {
+                const { extracted, remaining } = (0, parser_1.extractInitialTaggedContent)(choice.message.content, tagName);
+                if (extracted !== null) {
+                    // Success: thinking tag found
+                    this.logger.debug(`Extracted <${tagName}> block from response.`);
+                    // Handle the edge case: append to existing reasoning if present (e.g., native reasoning + thinking tags)
+                    const existingReasoning = choice.reasoning || '';
+                    if (existingReasoning) {
+                        // Use a neutral markdown header that works for any consumer (human or AI)
+                        choice.reasoning = `${existingReasoning}\n\n#### Additional Reasoning\n\n${extracted}`;
+                    }
+                    else {
+                        // No existing reasoning, just use the extracted content directly
+                        choice.reasoning = extracted;
+                    }
+                    choice.message.content = remaining;
+                }
+                else {
+                    // Tag was not found
+                    // Enforce only if: (1) enforce: true AND (2) native reasoning is NOT active
+                    if (fallbackSettings.enforce === true && !isNativeReasoningActive) {
+                        const nativeReasoningCapable = prepared.modelInfo.reasoning?.supported === true;
+                        return {
+                            provider: prepared.providerId,
+                            model: prepared.modelId,
+                            error: {
+                                message: `Model response missing required <${tagName}> tags.`,
+                                code: "THINKING_TAGS_MISSING",
+                                type: "validation_error",
+                                param: nativeReasoningCapable && !isNativeReasoningActive
+                                    ? `You disabled native reasoning for this model (${prepared.modelId}). ` +
+                                        `To see its reasoning, you must prompt it to use <${tagName}> tags. ` +
+                                        `Example: "Write your step-by-step reasoning in <${tagName}> tags before answering."`
+                                    : `This model (${prepared.modelId}) does not support native reasoning. ` +
+                                        `To get reasoning, you must prompt it to use <${tagName}> tags. ` +
+                                        `Example: "Write your step-by-step reasoning in <${tagName}> tags before answering."`,
+                            },
+                            object: "error",
+                            partialResponse: {
+                                id: result.id,
+                                provider: result.provider,
+                                model: result.model,
+                                created: result.created,
+                                choices: result.choices,
+                                usage: result.usage
+                            }
+                        };
+                    }
+                    // If enforce: false or native reasoning is active, do nothing
+                }
+            }
+        }
+        // Post-process for structured output auto-parsing
+        // Parse JSON response when structuredOutput is enabled and autoParse is not disabled
+        const structuredOutputSettings = prepared.internalRequest.settings.structuredOutput;
+        if (structuredOutputSettings &&
+            structuredOutputSettings.enabled !== false && structuredOutputSettings.autoParse !== false) {
+            for (const choice of result.choices) {
+                if (choice.message?.content) {
+                    try {
+                        choice.parsedContent = JSON.parse(choice.message.content);
+                    }
+                    catch (e) {
+                        choice.parseError = `JSON parse failed: ${e instanceof Error ? e.message : String(e)}`;
+                        this.logger.warn(`Failed to parse structured output for choice ${choice.index}: ${choice.parseError}`);
+                    }
+                }
+            }
+        }
+        return result;
+    }
     /**
      * Gets all configured model presets
      *