@vybestack/llxprt-code-core 0.1.19-alpha → 0.1.19-gamma

package/dist/src/providers/openai/OpenAIProvider.js

@@ -23,25 +23,59 @@ import { estimateMessagesTokens, estimateRemoteTokens, } from './estimateRemoteT
 // ConversationContext removed - using inline conversation ID generation
 import { parseResponsesStream, parseErrorResponse, } from './parseResponsesStream.js';
 import { buildResponsesRequest } from './buildResponsesRequest.js';
-export class OpenAIProvider {
-    name = 'openai';
+import { BaseProvider } from '../BaseProvider.js';
+import { isQwenEndpoint, generateOAuthEndpointMismatchError, } from '../../config/endpoints.js';
+import { getSettingsService } from '../../settings/settingsServiceInstance.js';
+export class OpenAIProvider extends BaseProvider {
     openai;
     currentModel = 'gpt-4.1';
-    apiKey;
     baseURL;
-    config;
+    providerConfig;
     toolFormatter;
     toolFormatOverride;
     conversationCache;
     modelParams;
-    constructor(apiKey, baseURL, config) {
-        this.apiKey = apiKey;
+    _cachedClient;
+    _cachedClientKey;
+    constructor(apiKey, baseURL, config, oauthManager) {
+        // Initialize base provider with auth configuration
+        // Check if we should enable OAuth for Qwen
+        // Enable OAuth if: 1) we have an oauth manager, and 2) either the baseURL is a Qwen endpoint OR no baseURL/apiKey is provided
+        const shouldEnableQwenOAuth = !!oauthManager &&
+            (isQwenEndpoint(baseURL || '') ||
+                (!baseURL && (!apiKey || apiKey === '')) ||
+                baseURL === 'https://portal.qwen.ai/v1');
+        if (process.env.DEBUG) {
+            console.log(`[OpenAI Constructor] baseURL: ${baseURL}, apiKey: ${apiKey?.substring(0, 10) || 'none'}, oauthManager: ${!!oauthManager}, shouldEnableQwenOAuth: ${shouldEnableQwenOAuth}`);
+        }
+        const baseConfig = {
+            name: 'openai',
+            apiKey,
+            baseURL,
+            cliKey: !apiKey || apiKey === '' ? undefined : apiKey, // Don't set cliKey if no API key to allow OAuth
+            envKeyNames: ['OPENAI_API_KEY'],
+            isOAuthEnabled: shouldEnableQwenOAuth,
+            oauthProvider: shouldEnableQwenOAuth ? 'qwen' : undefined,
+            oauthManager,
+        };
+        super(baseConfig);
         this.baseURL = baseURL;
-        this.config = config;
+        this.providerConfig = config;
         this.toolFormatter = new ToolFormatter();
         this.conversationCache = new ConversationCache();
+        // Initialize from SettingsService
+        this.initializeFromSettings().catch((error) => {
+            if (process.env.DEBUG) {
+                console.warn('Failed to initialize OpenAI provider from SettingsService:', error);
+            }
+        });
+        // Set appropriate default model based on the provider
+        if (shouldEnableQwenOAuth || isQwenEndpoint(baseURL || '')) {
+            // Default to Qwen model when using Qwen endpoints
+            this.currentModel = 'qwen3-coder-plus';
+        }
         const clientOptions = {
-            apiKey,
+            apiKey: apiKey || 'placeholder', // OpenAI client requires a string, use placeholder if OAuth will be used
             // Allow browser environment if explicitly configured
             dangerouslyAllowBrowser: config?.allowBrowserEnvironment || false,
         };
@@ -50,9 +84,87 @@ export class OpenAIProvider {
             clientOptions.baseURL = baseURL;
         }
         this.openai = new OpenAI(clientOptions);
+        this._cachedClientKey = apiKey; // Track the initial key used
+    }
+    /**
+     * Implementation of BaseProvider abstract method
+     * Determines if this provider supports OAuth authentication
+     */
+    supportsOAuth() {
+        // Only support Qwen OAuth for Qwen endpoints
+        // Use baseProviderConfig.baseURL if this.baseURL not set yet (during constructor)
+        const baseURL = this.baseURL ||
+            this.baseProviderConfig.baseURL ||
+            'https://api.openai.com/v1';
+        return isQwenEndpoint(baseURL);
+    }
+    /**
+     * Helper method to determine if we're using Qwen (via OAuth or direct endpoint)
+     */
+    isUsingQwen() {
+        // Check if we're using qwen format based on tool format detection
+        const toolFormat = this.detectToolFormat();
+        return toolFormat === 'qwen';
+    }
+    /**
+     * Update the OpenAI client with resolved authentication if needed
+     */
+    async updateClientWithResolvedAuth() {
+        const resolvedKey = await this.getAuthToken();
+        if (!resolvedKey) {
+            // Provide specific error message based on endpoint validation
+            const endpoint = this.baseURL || 'https://api.openai.com/v1';
+            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
+                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
+            }
+            throw new Error('No authentication available for OpenAI API calls');
+        }
+        // Check if we're using Qwen OAuth and need to update the baseURL
+        let effectiveBaseURL = this.baseURL;
+        // Debug logging
+        if (process.env.DEBUG) {
+            console.log(`[OpenAI] updateClientWithResolvedAuth - OAuth enabled: ${this.isOAuthEnabled()}, OAuth provider: ${this.baseProviderConfig.oauthProvider}, baseURL: ${this.baseURL}, resolvedKey: ${resolvedKey?.substring(0, 10)}...`);
+        }
+        if (this.isOAuthEnabled() &&
+            this.baseProviderConfig.oauthProvider === 'qwen') {
+            // Get the OAuth token to check for resource_url
+            const oauthManager = this.baseProviderConfig.oauthManager;
+            if (oauthManager?.getOAuthToken) {
+                const oauthToken = await oauthManager.getOAuthToken('qwen');
+                if (process.env.DEBUG) {
+                    console.log(`[OpenAI] OAuth token retrieved, resource_url: ${oauthToken?.resource_url}, access_token: ${oauthToken?.access_token?.substring(0, 10)}...`);
+                }
+                if (oauthToken?.resource_url) {
+                    // Use the resource_url from the OAuth token
+                    effectiveBaseURL = `https://${oauthToken.resource_url}/v1`;
+                    if (process.env.DEBUG) {
+                        console.log(`[OpenAI] Using Qwen OAuth endpoint: ${effectiveBaseURL}`);
+                    }
+                }
+            }
+        }
+        // Only update client if the key or URL has changed
+        if (this._cachedClientKey !== resolvedKey ||
+            this.baseURL !== effectiveBaseURL) {
+            const clientOptions = {
+                apiKey: resolvedKey,
+                // Allow browser environment if explicitly configured
+                dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
+            };
+            // Only include baseURL if it's defined
+            if (effectiveBaseURL) {
+                clientOptions.baseURL = effectiveBaseURL;
+            }
+            this.openai = new OpenAI(clientOptions);
+            this._cachedClientKey = resolvedKey;
+            // Update the baseURL to track changes
+            if (effectiveBaseURL !== this.baseURL) {
+                this.baseURL = effectiveBaseURL;
+            }
+        }
     }
     requiresTextToolCallParsing() {
-        if (this.config?.enableTextToolCallParsing === false) {
+        if (this.providerConfig?.enableTextToolCallParsing === false) {
             return false;
         }
         // Check if current tool format requires text-based parsing
@@ -61,7 +173,7 @@ export class OpenAIProvider {
         if (textBasedFormats.includes(currentFormat)) {
             return true;
         }
-        const configuredModels = this.config?.textToolCallModels || [];
+        const configuredModels = this.providerConfig?.textToolCallModels || [];
         return configuredModels.includes(this.currentModel);
     }
     getToolFormat() {
@@ -70,15 +182,16 @@ export class OpenAIProvider {
             return this.toolFormatOverride;
         }
         // Check for settings override
-        if (this.config?.providerToolFormatOverrides?.[this.name]) {
-            return this.config.providerToolFormatOverrides[this.name];
+        if (this.providerConfig?.providerToolFormatOverrides?.[this.name]) {
+            return this.providerConfig.providerToolFormatOverrides[this.name];
         }
         // Auto-detect tool format based on model or base URL
         if (this.currentModel.includes('deepseek') ||
             this.baseURL?.includes('deepseek')) {
             return 'deepseek';
         }
-        if (this.currentModel.includes('qwen') || this.baseURL?.includes('qwen')) {
+        // Check for Qwen - including OAuth authenticated Qwen
+        if (this.isUsingQwen()) {
             return 'qwen';
         }
         // Default to OpenAI format
@@ -90,7 +203,7 @@ export class OpenAIProvider {
             return false;
         }
         // Check settings override - if explicitly set to false, always respect that
-        if (this.config?.openaiResponsesEnabled === false) {
+        if (this.providerConfig?.openaiResponsesEnabled === false) {
             return false;
         }
         // Never use Responses API for non-OpenAI providers (those with custom base URLs)
@@ -102,8 +215,13 @@ export class OpenAIProvider {
         return RESPONSES_API_MODELS.some((responsesModel) => model.startsWith(responsesModel));
     }
     async callResponsesEndpoint(messages, tools, options) {
-        // Check if API key is available
-        if (!this.apiKey || this.apiKey.trim() === '') {
+        // Check if API key is available (using resolved authentication)
+        const apiKey = await this.getAuthToken();
+        if (!apiKey) {
+            const endpoint = this.baseURL || 'https://api.openai.com/v1';
+            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
+                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
+            }
             throw new Error('OpenAI API key is required to make API calls');
         }
         // Remove the stateful mode error to allow O3 to work with conversation IDs
@@ -135,10 +253,13 @@ export class OpenAIProvider {
         const formattedTools = tools
             ? this.toolFormatter.toResponsesTool(tools)
             : undefined;
+        // Patch messages to include synthetic responses for cancelled tools
+        const { SyntheticToolResponseHandler } = await import('./syntheticToolResponses.js');
+        const patchedMessages = SyntheticToolResponseHandler.patchMessageHistory(messages);
         // Build the request
         const request = buildResponsesRequest({
             model: this.currentModel,
-            messages,
+            messages: patchedMessages,
             tools: formattedTools,
             stream: options?.stream ?? true,
             conversationId: options?.conversationId,
@@ -157,7 +278,7 @@ export class OpenAIProvider {
         const response = await fetch(responsesURL, {
             method: 'POST',
             headers: {
-                Authorization: `Bearer ${this.apiKey}`,
+                Authorization: `Bearer ${apiKey}`,
                 'Content-Type': 'application/json; charset=utf-8',
             },
             body: bodyBlob,
@@ -192,7 +313,7 @@ export class OpenAIProvider {
                 const retryResponse = await fetch(responsesURL, {
                     method: 'POST',
                     headers: {
-                        Authorization: `Bearer ${this.apiKey}`,
+                        Authorization: `Bearer ${apiKey}`,
                         'Content-Type': 'application/json; charset=utf-8',
                     },
                     body: retryBodyBlob,
@@ -286,11 +407,18 @@ export class OpenAIProvider {
         })();
     }
     async getModels() {
-        // Check if API key is available
-        if (!this.apiKey || this.apiKey.trim() === '') {
+        // Check if API key is available (using resolved authentication)
+        const apiKey = await this.getAuthToken();
+        if (!apiKey) {
+            const endpoint = this.baseURL || 'https://api.openai.com/v1';
+            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
+                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
+            }
             throw new Error('OpenAI API key is required to fetch models');
         }
         try {
+            // Get resolved authentication and update client if needed
+            await this.updateClientWithResolvedAuth();
             const response = await this.openai.models.list();
             const models = [];
             for await (const model of response) {
@@ -311,6 +439,18 @@ export class OpenAIProvider {
                 console.error('Error fetching models from OpenAI:', error);
             }
             // Return a hardcoded list as fallback
+            // Check if this is a Qwen endpoint
+            if (isQwenEndpoint(this.baseURL || '')) {
+                return [
+                    {
+                        id: 'qwen3-coder-plus',
+                        name: 'qwen3-coder-plus',
+                        provider: 'openai',
+                        supportedToolFormats: ['openai'],
+                    },
+                ];
+            }
+            // Default OpenAI models
             return [
                 {
                     id: 'gpt-4o',
@@ -340,8 +480,13 @@ export class OpenAIProvider {
         }
     }
     async *generateChatCompletion(messages, tools, _toolFormat) {
-        // Check if API key is available
-        if (!this.apiKey || this.apiKey.trim() === '') {
+        // Check if API key is available (using resolved authentication)
+        const apiKey = await this.getAuthToken();
+        if (!apiKey) {
+            const endpoint = this.baseURL || 'https://api.openai.com/v1';
+            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
+                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
+            }
             throw new Error('OpenAI API key is required to generate completions');
         }
         // Check if we should use responses endpoint
@@ -372,14 +517,17 @@ export class OpenAIProvider {
             : null;
         // Get current tool format (with override support)
         const currentToolFormat = this.getToolFormat();
-        // Format tools using ToolFormatter
-        const formattedTools = tools
-            ? this.toolFormatter.toProviderFormat(tools, currentToolFormat)
-            : undefined;
+        // Format tools using formatToolsForAPI method
+        const formattedTools = tools ? this.formatToolsForAPI(tools) : undefined;
         // Get stream_options from ephemeral settings (not model params)
-        const streamOptions = this.config?.getEphemeralSettings?.()?.['stream-options'];
+        const streamOptions = this.providerConfig?.getEphemeralSettings?.()?.['stream-options'];
         // Default stream_options to { include_usage: true } unless explicitly set
         const finalStreamOptions = streamOptions !== undefined ? streamOptions : { include_usage: true };
+        // Get resolved authentication and update client if needed
+        await this.updateClientWithResolvedAuth();
+        if (process.env.DEBUG) {
+            console.log(`[OpenAI] About to make API call with model: ${this.currentModel}, baseURL: ${this.openai.baseURL}, apiKey: ${this.openai.apiKey?.substring(0, 10)}...`);
+        }
         // Build request params with exact order from original
         const stream = await this.openai.chat.completions.create({
             model: this.currentModel,
@@ -389,7 +537,7 @@ export class OpenAIProvider {
                 ? { stream_options: finalStreamOptions }
                 : {}),
             tools: formattedTools,
-            tool_choice: tools && tools.length > 0 ? 'auto' : undefined,
+            tool_choice: this.getToolChoiceForFormat(tools),
             ...this.modelParams,
         });
         let fullContent = '';
@@ -402,7 +550,7 @@ export class OpenAIProvider {
             const delta = chunk.choices[0]?.delta;
             if (delta?.content) {
                 // Enhanced debug logging to understand streaming behavior
-                if (process.env.DEBUG && this.currentModel.includes('qwen')) {
+                if (process.env.DEBUG && this.isUsingQwen()) {
                     console.log(`[OpenAIProvider/${this.currentModel}] Chunk:`, {
                         content: delta.content,
                         contentLength: delta.content.length,
@@ -412,7 +560,7 @@ export class OpenAIProvider {
                 }
                 // For text-based models, don't yield content chunks yet
                 if (!parser) {
-                    if (this.currentModel.includes('qwen')) {
+                    if (this.isUsingQwen()) {
                         const isWhitespaceOnly = delta.content.trim() === '';
                         if (isWhitespaceOnly) {
                             // Buffer whitespace-only chunk
@@ -459,7 +607,7 @@ export class OpenAIProvider {
             }
         }
         // Flush any remaining pending whitespace for Qwen
-        if (pendingWhitespace && this.currentModel.includes('qwen') && !parser) {
+        if (pendingWhitespace && this.isUsingQwen() && !parser) {
             if (process.env.DEBUG) {
                 console.log(`[OpenAIProvider/${this.currentModel}] Flushing trailing pending whitespace (len=${pendingWhitespace.length}) at stream end`);
             }
@@ -503,7 +651,7 @@ export class OpenAIProvider {
         else {
             // Standard OpenAI tool call handling
             if (accumulatedToolCalls.length > 0) {
-                if (process.env.DEBUG && this.currentModel.includes('qwen')) {
+                if (process.env.DEBUG && this.isUsingQwen()) {
                     console.log(`[OpenAIProvider/${this.currentModel}] Final message with tool calls:`, {
                         contentLength: fullContent.length,
                         content: fullContent.substring(0, 200) +
@@ -513,7 +661,7 @@ export class OpenAIProvider {
                     });
                 }
                 // For Qwen models, don't duplicate content if we've already streamed it
-                const shouldOmitContent = hasStreamedContent && this.currentModel.includes('qwen');
+                const shouldOmitContent = hasStreamedContent && this.isUsingQwen();
                 if (shouldOmitContent) {
                     // Only yield tool calls with empty content to avoid duplication
                     yield {
@@ -544,40 +692,94 @@ export class OpenAIProvider {
         }
     }
     setModel(modelId) {
+        // Update SettingsService as the source of truth
+        this.setModelInSettings(modelId).catch((error) => {
+            if (process.env.DEBUG) {
+                console.warn('Failed to persist model to SettingsService:', error);
+            }
+        });
+        // Keep local cache for performance
         this.currentModel = modelId;
     }
     getCurrentModel() {
-        return this.currentModel;
+        // Try to get from SettingsService first (source of truth)
+        try {
+            const settingsService = getSettingsService();
+            const providerSettings = settingsService.getProviderSettings(this.name);
+            if (providerSettings.model) {
+                return providerSettings.model;
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn('Failed to get model from SettingsService:', error);
+            }
+        }
+        // Fall back to cached value or default
+        return this.currentModel || this.getDefaultModel();
+    }
+    getDefaultModel() {
+        // Return the default model for this provider
+        // This can be overridden based on configuration or endpoint
+        if (this.isUsingQwen()) {
+            return 'qwen3-coder-plus';
+        }
+        return 'gpt-4.1';
     }
     setApiKey(apiKey) {
-        this.apiKey = apiKey;
+        // Call base provider implementation
+        super.setApiKey?.(apiKey);
+        // Persist to SettingsService if available
+        this.setApiKeyInSettings(apiKey).catch((error) => {
+            if (process.env.DEBUG) {
+                console.warn('Failed to persist API key to SettingsService:', error);
+            }
+        });
         // Create a new OpenAI client with the updated API key
         const clientOptions = {
             apiKey,
-            dangerouslyAllowBrowser: this.config?.allowBrowserEnvironment || false,
+            dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
         };
         // Only include baseURL if it's defined
         if (this.baseURL) {
             clientOptions.baseURL = this.baseURL;
         }
         this.openai = new OpenAI(clientOptions);
+        this._cachedClientKey = apiKey; // Update cached key
     }
     setBaseUrl(baseUrl) {
         // If no baseUrl is provided, clear to default (undefined)
         this.baseURL = baseUrl && baseUrl.trim() !== '' ? baseUrl : undefined;
+        // Persist to SettingsService if available
+        this.setBaseUrlInSettings(this.baseURL).catch((error) => {
+            if (process.env.DEBUG) {
+                console.warn('Failed to persist base URL to SettingsService:', error);
+            }
+        });
+        // Update OAuth configuration based on endpoint validation
+        // Enable OAuth for Qwen endpoints if we have an OAuth manager
+        const shouldEnableQwenOAuth = !!this.baseProviderConfig.oauthManager &&
+            (isQwenEndpoint(this.baseURL || '') ||
+                this.baseURL === 'https://portal.qwen.ai/v1');
+        this.updateOAuthConfig(shouldEnableQwenOAuth, shouldEnableQwenOAuth ? 'qwen' : undefined, this.baseProviderConfig.oauthManager);
+        // Call base provider implementation
+        super.setBaseUrl?.(baseUrl);
         // Create a new OpenAI client with the updated (or cleared) base URL
         const clientOptions = {
-            apiKey: this.apiKey,
-            dangerouslyAllowBrowser: this.config?.allowBrowserEnvironment || false,
+            // Use existing key or empty string as placeholder
+            apiKey: this._cachedClientKey || 'placeholder',
+            dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
         };
         // Only include baseURL if it's defined
         if (this.baseURL) {
             clientOptions.baseURL = this.baseURL;
         }
         this.openai = new OpenAI(clientOptions);
+        // Clear cached key to force re-resolution on next API call
+        this._cachedClientKey = undefined;
     }
     setConfig(config) {
-        this.config = config;
+        this.providerConfig = config;
     }
     setToolFormatOverride(format) {
         this.toolFormatOverride = format || undefined;
@@ -633,6 +835,12 @@ export class OpenAIProvider {
         else {
             this.modelParams = { ...this.modelParams, ...params };
         }
+        // Persist to SettingsService if available
+        this.setModelParamsInSettings(this.modelParams).catch((error) => {
+            if (process.env.DEBUG) {
+                console.warn('Failed to persist model params to SettingsService:', error);
+            }
+        });
     }
     /**
      * Get current model parameters
@@ -641,5 +849,130 @@ export class OpenAIProvider {
     getModelParams() {
         return this.modelParams;
     }
+    /**
+     * Initialize provider configuration from SettingsService
+     */
+    async initializeFromSettings() {
+        try {
+            const _settingsService = getSettingsService();
+            // Load saved model if available
+            const savedModel = await this.getModelFromSettings();
+            if (savedModel) {
+                this.currentModel = savedModel;
+            }
+            // Load saved base URL if available
+            const savedBaseUrl = await this.getBaseUrlFromSettings();
+            if (savedBaseUrl !== undefined) {
+                this.baseURL = savedBaseUrl;
+            }
+            // Load saved model parameters if available
+            const savedParams = await this.getModelParamsFromSettings();
+            if (savedParams) {
+                this.modelParams = savedParams;
+            }
+            if (process.env.DEBUG) {
+                console.log(`[OpenAI] Initialized from SettingsService - model: ${this.currentModel}, baseURL: ${this.baseURL}, params:`, this.modelParams);
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.error('Failed to initialize OpenAI provider from SettingsService:', error);
+            }
+        }
+    }
+    /**
+     * Check if the provider is authenticated using any available method
+     * Uses the base provider's isAuthenticated implementation
+     */
+    async isAuthenticated() {
+        return super.isAuthenticated();
+    }
+    /**
+     * Detect the appropriate tool format for the current model/configuration
+     * @returns The detected tool format
+     */
+    detectToolFormat() {
+        try {
+            const settingsService = getSettingsService();
+            // First check SettingsService for toolFormat override in provider settings
+            // Note: This is synchronous access to cached settings, not async
+            const currentSettings = settingsService['settings'];
+            const providerSettings = currentSettings?.providers?.[this.name];
+            const toolFormatOverride = providerSettings?.toolFormat;
+            // If explicitly set to a specific format (not 'auto'), use it
+            if (toolFormatOverride && toolFormatOverride !== 'auto') {
+                return toolFormatOverride;
+            }
+            // Auto-detect based on model name if set to 'auto' or not set
+            const modelName = this.currentModel.toLowerCase();
+            // Check for GLM-4.5 models (glm-4.5, glm-4-5)
+            if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
+                return 'qwen';
+            }
+            // Check for qwen models
+            if (modelName.includes('qwen')) {
+                return 'qwen';
+            }
+            // Default to 'openai' format
+            return 'openai';
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn('Failed to detect tool format from SettingsService:', error);
+            }
+            // Fallback detection without SettingsService
+            const modelName = this.currentModel.toLowerCase();
+            if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
+                return 'qwen';
+            }
+            if (modelName.includes('qwen')) {
+                return 'qwen';
+            }
+            return 'openai';
+        }
+    }
+    /**
+     * Get appropriate tool_choice value based on detected tool format
+     * @param tools Array of tools (if any)
+     * @returns Appropriate tool_choice value for the current format
+     */
+    getToolChoiceForFormat(tools) {
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        // For all formats, use 'auto' (standard behavior)
+        // Future enhancement: different formats may need different tool_choice values
+        return 'auto';
+    }
+    /**
+     * Format tools for API based on detected tool format
+     * @param tools Array of tools to format
+     * @returns Formatted tools for API consumption
+     */
+    formatToolsForAPI(tools) {
+        // For now, always use OpenAI format through OpenRouter
+        // TODO: Investigate if OpenRouter needs special handling for GLM/Qwen
+        // const detectedFormat = this.detectToolFormat();
+        // if (detectedFormat === 'qwen') {
+        //   // Convert OpenAI format to Qwen format: {name, description, parameters} without type/function wrapper
+        //   return tools.map((tool) => ({
+        //     name: tool.function.name,
+        //     description: tool.function.description,
+        //     parameters: tool.function.parameters,
+        //   }));
+        // }
+        // For all formats, use the existing ToolFormatter
+        return this.toolFormatter.toProviderFormat(tools, 'openai');
+    }
+    /**
+     * Parse tool response from API (placeholder for future response parsing)
+     * @param response The raw API response
+     * @returns Parsed tool response
+     */
+    parseToolResponse(response) {
+        // TODO: Implement response parsing based on detected format
+        // For now, return the response as-is
+        return response;
+    }
 }
 //# sourceMappingURL=OpenAIProvider.js.map