genai-lite 0.11.0 → 0.13.0

package/dist/llm/LLMService.js

@@ -76,6 +76,93 @@ class LLMService {
         this.logger.debug(`Found ${models.length} models for provider: ${providerId}`);
         return [...models]; // Return a copy to prevent external modification
     }
+    /**
+     * Gets static capability metadata for a provider/model pair without retrieving
+     * API keys, calling provider adapters, or performing network I/O.
+     *
+     * Unknown or unregistered models use the same fallback model resolution policy
+     * as sendMessage(), but their optional capabilities are reported as unknown.
+     */
+    async getModelCapabilities(providerId, modelId) {
+        this.logger.debug(`LLMService.getModelCapabilities called for provider: ${providerId}, model: ${modelId}`);
+        const resolved = await this.modelResolver.resolve({ providerId, modelId }, { detectLocalCapabilities: false });
+        if (resolved.error) {
+            return resolved.error;
+        }
+        const resolvedProviderId = resolved.providerId;
+        const resolvedModelId = resolved.modelId;
+        const modelInfo = resolved.modelInfo;
+        const source = this.getCapabilitySource(resolvedProviderId, resolvedModelId);
+        return {
+            object: "model.capabilities",
+            provider: resolvedProviderId,
+            model: resolvedModelId,
+            modelInfo: { ...modelInfo },
+            structuredOutput: this.getStructuredOutputSupport(modelInfo, source),
+        };
+    }
+    /**
+     * Convenience wrapper for checking structured-output support.
+     *
+     * Returns `unknown` when genai-lite has no explicit capability metadata. Callers
+     * should decide whether unknown is acceptable for their use case.
+     */
+    async supportsStructuredOutput(providerId, modelId) {
+        const capabilities = await this.getModelCapabilities(providerId, modelId);
+        if (capabilities.object === "error") {
+            return capabilities;
+        }
+        return capabilities.structuredOutput;
+    }
+    /**
+     * Preflights provider/model capability requirements for a request without
+     * retrieving API keys, calling provider adapters, or performing network I/O.
+     *
+     * This checks the effective settings after preset and model defaults are
+     * applied. Unknown/unspecified capabilities are reported as unknown and remain
+     * valid; explicitly unsupported capabilities return the same validation error
+     * shape as sendMessage() where possible.
+     */
+    async validateRequestCapabilities(request) {
+        this.logger.debug(`LLMService.validateRequestCapabilities called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
+        try {
+            const validation = await this.resolveAndValidateCapabilities(request, {
+                validateStructure: false,
+                detectLocalCapabilities: false,
+            });
+            if ("error" in validation) {
+                return {
+                    ...validation.error,
+                    valid: false,
+                    ...(validation.capabilities && { capabilities: validation.capabilities }),
+                };
+            }
+            return {
+                object: "capability.validation",
+                valid: true,
+                provider: validation.context.providerId,
+                model: validation.context.modelId,
+                capabilities: validation.context.capabilities,
+            };
+        }
+        catch (error) {
+            this.logger.error("Error in LLMService.validateRequestCapabilities:", error);
+            return {
+                provider: request.providerId || request.presetId || 'unknown',
+                model: request.modelId || request.presetId || 'unknown',
+                error: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "Unexpected error during capability preflight",
+                    code: "UNKNOWN_ERROR",
+                    type: "server_error",
+                    providerError: error,
+                },
+                object: "error",
+                valid: false,
+            };
+        }
+    }
     /**
      * Sends a chat message to an LLM provider
      *
@@ -85,116 +172,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 +206,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
-                        }
-                    }
+                const processedResult = this.postProcessResponse(result, prepared);
+                if (processedResult.object === "chat.completion") {
+                    this.logger.info(`LLM request completed successfully for model: ${prepared.modelId}`);
                 }
-                // 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}`);
-                            }
-                        }
-                    }
-                }
-                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 +248,370 @@ 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 resolveAndValidateCapabilities(request, options) {
+        const resolved = await this.modelResolver.resolve(request, {
+            detectLocalCapabilities: options.detectLocalCapabilities,
+        });
+        if (resolved.error) {
+            return { error: resolved.error };
+        }
+        const providerId = resolved.providerId;
+        const modelId = resolved.modelId;
+        const modelInfo = resolved.modelInfo;
+        const source = this.getCapabilitySource(providerId, modelId);
+        const capabilities = this.buildModelCapabilities(modelInfo, source);
+        const resolvedRequest = {
+            ...request,
+            providerId,
+            modelId,
+            messages: "messages" in request && Array.isArray(request.messages)
+                ? request.messages
+                : [],
+        };
+        if (options.validateStructure) {
+            const structureValidationResult = this.requestValidator.validateRequestStructure(resolvedRequest);
+            if (structureValidationResult) {
+                return { error: structureValidationResult, capabilities };
+            }
+        }
+        const combinedSettings = {
+            ...(resolved.settings || {}),
+            ...(request.settings || {}),
+        };
+        const settingsValidation = this.requestValidator.validateSettings(combinedSettings, providerId, modelId);
+        if (settingsValidation) {
+            return { error: settingsValidation, capabilities };
+        }
+        const finalSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, combinedSettings, modelInfo);
+        const reasoningValidation = this.requestValidator.validateReasoningSettings(modelInfo, finalSettings.reasoning, resolvedRequest);
+        if (reasoningValidation) {
+            return { error: reasoningValidation, capabilities };
+        }
+        const structuredOutputValidation = this.requestValidator.validateStructuredOutputSettings(modelInfo, finalSettings.structuredOutput, resolvedRequest);
+        if (structuredOutputValidation) {
+            return { error: structuredOutputValidation, capabilities };
+        }
+        return {
+            context: {
+                providerId,
+                modelId,
+                modelInfo,
+                resolvedRequest,
+                finalSettings,
+                capabilities,
+            },
+        };
+    }
+    buildModelCapabilities(modelInfo, source) {
+        return {
+            structuredOutput: this.getStructuredOutputSupport(modelInfo, source),
+        };
+    }
+    getStructuredOutputSupport(modelInfo, source) {
+        if (modelInfo.structuredOutput === undefined) {
+            return {
+                status: "unknown",
+                source,
+            };
+        }
+        return {
+            status: modelInfo.structuredOutput.supported ? "supported" : "unsupported",
+            ...(modelInfo.structuredOutput.strictMode !== undefined && {
+                strictMode: modelInfo.structuredOutput.strictMode,
+            }),
+            ...(modelInfo.structuredOutput.notes && {
+                notes: modelInfo.structuredOutput.notes,
+            }),
+            source,
+        };
+    }
+    getCapabilitySource(providerId, modelId) {
+        return (0, config_1.getModelById)(modelId, providerId) ? "registry" : "fallback";
+    }
+    async prepareRequest(request, callOptions) {
+        const validation = await this.resolveAndValidateCapabilities(request, {
+            validateStructure: true,
+            detectLocalCapabilities: true,
+        });
+        if ("error" in validation) {
+            return { error: validation.error };
+        }
+        const { providerId, modelId, modelInfo, resolvedRequest, finalSettings, } = validation.context;
+        // 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,
+                    modelId,
+                    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
      *