@vybestack/llxprt-code-core 0.1.23-nightly.250903.97906524 → 0.1.23-nightly.250905.67589d14

package/dist/src/providers/gemini/GeminiProvider.js

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { DebugLogger } from '../../debug/index.js';
-import { Config, AuthType, ContentGeneratorRole, AuthenticationRequiredError, getCoreSystemPromptAsync, createCodeAssistContentGenerator, } from '@vybestack/llxprt-code-core';
+import { Config, AuthType, AuthenticationRequiredError, getCoreSystemPromptAsync, createCodeAssistContentGenerator, } from '@vybestack/llxprt-code-core';
+import { Type, } from '@google/genai';
 import { BaseProvider } from '../BaseProvider.js';
 import { getSettingsService } from '../../settings/settingsServiceInstance.js';
 export class GeminiProvider extends BaseProvider {
@@ -15,7 +16,6 @@ export class GeminiProvider extends BaseProvider {
     modelExplicitlySet = false;
     baseURL;
     modelParams;
-    toolSchemas;
     geminiOAuthManager;
     constructor(apiKey, baseURL, config, oauthManager) {
         // Initialize base provider with auth configuration
@@ -260,462 +260,6 @@ export class GeminiProvider extends BaseProvider {
             },
         ];
     }
-    async *generateChatCompletion(messages, tools, _toolFormat) {
-        // Comprehensive debug logging
-        this.logger.debug(() => `generateChatCompletion called with ${messages.length} messages`);
-        this.logger.debug(() => `Messages: ${JSON.stringify(messages, null, 2)}`);
-        this.logger.debug(() => `First message: ${messages[0] ? JSON.stringify(messages[0], null, 2) : 'NO FIRST MESSAGE'}`);
-        this.logger.debug(() => `Tools: ${tools ? JSON.stringify(tools.map((t) => t.function.name)) : 'NO TOOLS'}`);
-        // Lazily determine the best auth method now that it's needed.
-        // This implements lazy OAuth triggering - OAuth is only triggered when making API calls
-        let authToken;
-        try {
-            authToken = await this.determineBestAuth();
-        }
-        catch (error) {
-            if (error instanceof AuthenticationRequiredError) {
-                throw error;
-            }
-            throw new AuthenticationRequiredError('Failed to resolve authentication for Gemini provider', this.authMode, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']);
-        }
-        // Authentication has already been resolved by determineBestAuth()
-        // No need for additional validation since the auth token is already obtained
-        // Import the necessary modules dynamically to avoid circular dependencies
-        const { GoogleGenAI } = await import('@google/genai');
-        // Create the appropriate client based on auth mode
-        let genAI;
-        const httpOptions = {
-            headers: {
-                'User-Agent': `LLxprt-Code/${process.env.CLI_VERSION || process.version} (${process.platform}; ${process.arch})`,
-            },
-        };
-        switch (this.authMode) {
-            case 'gemini-api-key':
-                genAI = new GoogleGenAI({
-                    apiKey: authToken,
-                    httpOptions: this.baseURL
-                        ? {
-                            ...httpOptions,
-                            baseUrl: this.baseURL,
-                        }
-                        : httpOptions,
-                });
-                break;
-            case 'vertex-ai':
-                genAI = new GoogleGenAI({
-                    apiKey: authToken,
-                    vertexai: true,
-                    httpOptions: this.baseURL
-                        ? {
-                            ...httpOptions,
-                            baseUrl: this.baseURL,
-                        }
-                        : httpOptions,
-                });
-                break;
-            case 'oauth': {
-                // For OAuth, create a minimal config-like object if we don't have one
-                const configForOAuth = this.geminiConfig || {
-                    getProxy: () => undefined, // OAuth only needs this from config
-                };
-                // For OAuth, we need to use the code assist server
-                const contentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, configForOAuth, this.baseURL);
-                // Convert messages to Gemini request format
-                // Use config model in OAuth mode to ensure synchronization
-                const oauthModel = this.modelExplicitlySet
-                    ? this.currentModel
-                    : this.geminiConfig?.getModel() || this.currentModel;
-                // Generate systemInstruction using getCoreSystemPrompt
-                // Get user memory from config if available
-                const userMemory = this.geminiConfig?.getUserMemory
-                    ? this.geminiConfig.getUserMemory()
-                    : '';
-                const systemInstruction = await getCoreSystemPromptAsync(userMemory, oauthModel);
-                // Store tools if provided
-                if (tools && tools.length > 0) {
-                    this.toolSchemas = this.convertToolsToGeminiFormat(tools);
-                }
-                // Use provided tools or stored tools
-                let geminiTools = tools
-                    ? this.convertToolsToGeminiFormat(tools)
-                    : this.toolSchemas;
-                // For Flash models, always include tools if available
-                if (oauthModel.includes('flash') && !geminiTools && this.toolSchemas) {
-                    geminiTools = this.toolSchemas;
-                }
-                const request = {
-                    model: oauthModel,
-                    contents: this.convertMessagesToGeminiFormat(messages),
-                    systemInstruction,
-                    config: {
-                        tools: geminiTools,
-                        ...this.modelParams,
-                    },
-                };
-                // Use the content generator stream
-                // PRIVACY FIX: Removed sessionId to prevent transmission to Google servers
-                const streamResult = await contentGenerator.generateContentStream(request, 'oauth-session');
-                // Reset global state variables after successful authentication
-                /**
-                 * @plan PLAN-20250822-GEMINIFALLBACK.P12
-                 * @requirement REQ-003.3
-                 * @pseudocode lines 17-18, 25-26
-                 */
-                global.__oauth_needs_code = false;
-                global.__oauth_provider = undefined;
-                // Convert the stream to our format
-                for await (const response of streamResult) {
-                    // Extract text from the response
-                    const text = response.candidates?.[0]?.content?.parts
-                        ?.filter((part) => 'text' in part)
-                        ?.map((part) => part.text)
-                        ?.join('') || '';
-                    // Extract function calls from the response
-                    const functionCalls = response.candidates?.[0]?.content?.parts
-                        ?.filter((part) => 'functionCall' in part)
-                        ?.map((part) => part.functionCall) || [];
-                    // Build response message
-                    const message = {
-                        role: ContentGeneratorRole.ASSISTANT,
-                        content: text,
-                    };
-                    // Add function calls if any
-                    if (functionCalls && functionCalls.length > 0) {
-                        message.tool_calls = functionCalls.map((call) => ({
-                            id: call.id ||
-                                `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                            type: 'function',
-                            function: {
-                                name: call.name || 'unknown_function',
-                                arguments: JSON.stringify(call.args || {}),
-                            },
-                        }));
-                    }
-                    // Only yield if there's content or tool calls
-                    if (text || (functionCalls && functionCalls.length > 0)) {
-                        yield message;
-                    }
-                }
-                return;
-            }
-            case 'none':
-                // For 'none' mode, use the resolved auth token
-                genAI = new GoogleGenAI({
-                    apiKey: authToken,
-                    vertexai: this.hasVertexAICredentials(),
-                    httpOptions: this.baseURL
-                        ? {
-                            ...httpOptions,
-                            baseUrl: this.baseURL,
-                        }
-                        : httpOptions,
-                });
-                break;
-            default:
-                throw new Error(`Unsupported auth mode: ${this.authMode}`);
-        }
-        // Get the models interface (which is a ContentGenerator)
-        const contentGenerator = genAI.models;
-        // Store tools if provided
-        if (tools && tools.length > 0) {
-            this.toolSchemas = this.convertToolsToGeminiFormat(tools);
-        }
-        // Convert IMessage[] to Gemini format - do this after storing tools so priming can access them
-        const contents = this.convertMessagesToGeminiFormat(messages);
-        // Use provided tools or stored tools
-        let geminiTools = tools
-            ? this.convertToolsToGeminiFormat(tools)
-            : this.toolSchemas;
-        // Create the request - ContentGenerator expects model in the request
-        // Use explicit model if set, otherwise fall back to config model
-        const modelToUse = this.modelExplicitlySet
-            ? this.currentModel
-            : this.geminiConfig?.getModel() || this.currentModel;
-        // For Flash models, always include tools if available
-        if (modelToUse.includes('flash') && !geminiTools && this.toolSchemas) {
-            geminiTools = this.toolSchemas;
-        }
-        // Generate systemInstruction using getCoreSystemPrompt
-        // Get user memory from config if available
-        const userMemory = this.geminiConfig?.getUserMemory
-            ? this.geminiConfig.getUserMemory()
-            : '';
-        const systemInstruction = await getCoreSystemPromptAsync(userMemory, modelToUse);
-        const request = {
-            model: modelToUse,
-            contents,
-            systemInstruction,
-            config: {
-                tools: geminiTools,
-                ...this.modelParams,
-            },
-        };
-        // Generate content stream using the ContentGenerator interface
-        const stream = await contentGenerator.generateContentStream(request);
-        // Stream the response
-        for await (const response of stream) {
-            // Extract text from the response
-            const text = response.candidates?.[0]?.content?.parts
-                ?.filter((part) => 'text' in part)
-                ?.map((part) => part.text)
-                ?.join('') || '';
-            // Extract function calls from the response
-            const functionCalls = response.candidates?.[0]?.content?.parts
-                ?.filter((part) => 'functionCall' in part)
-                ?.map((part) => part.functionCall) || [];
-            // Build response message
-            const message = {
-                role: ContentGeneratorRole.ASSISTANT,
-                content: text || '',
-            };
-            // Add function calls if any
-            if (functionCalls && functionCalls.length > 0) {
-                message.tool_calls = functionCalls.map((call) => ({
-                    id: call.id ||
-                        `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                    type: 'function',
-                    function: {
-                        name: call.name || 'unknown_function',
-                        arguments: JSON.stringify(call.args || {}),
-                    },
-                }));
-            }
-            // Only yield if there's content or tool calls
-            if (text || (functionCalls && functionCalls.length > 0)) {
-                yield message;
-            }
-        }
-    }
-    convertMessagesToGeminiFormat(messages) {
-        const contents = [];
-        // Enhanced tracking with more details
-        const functionCalls = new Map();
-        const functionResponses = new Map();
-        for (let i = 0; i < messages.length; i++) {
-            const msg = messages[i];
-            // Handle tool responses - each in its own Content object
-            if (msg.role === ContentGeneratorRole.TOOL) {
-                if (!msg.tool_call_id) {
-                    this.logger.debug(() => `Tool response at index ${i} missing tool_call_id, skipping: ${JSON.stringify(msg)}`);
-                    continue;
-                }
-                functionResponses.set(msg.tool_call_id, {
-                    name: msg.tool_name || 'unknown_function',
-                    contentIndex: contents.length,
-                    messageIndex: i,
-                });
-                // Add each tool response as a separate content immediately
-                contents.push({
-                    role: 'user',
-                    parts: [
-                        {
-                            functionResponse: {
-                                id: msg.tool_call_id,
-                                name: msg.tool_name || 'unknown_function',
-                                response: {
-                                    output: msg.content || '',
-                                },
-                            },
-                        },
-                    ],
-                });
-                continue;
-            }
-            // For non-tool messages, convert normally
-            const parts = [];
-            // Check for parts first (for messages with PDF/image parts but no text content)
-            if (msg.parts && msg.parts.length > 0) {
-                parts.push(...msg.parts);
-            }
-            else if (msg.content) {
-                // Handle PartListUnion: string | Part | Part[]
-                // In practice, content can be PartListUnion even though IMessage types it as string
-                const content = msg.content;
-                if (typeof content === 'string') {
-                    // Try to parse string in case it's a stringified Part or Part[]
-                    if ((content.startsWith('{') && content.endsWith('}')) ||
-                        (content.startsWith('[') && content.endsWith(']'))) {
-                        try {
-                            const parsed = JSON.parse(content);
-                            if (Array.isArray(parsed)) {
-                                parts.push(...parsed);
-                            }
-                            else {
-                                parts.push(parsed);
-                            }
-                        }
-                        catch (_e) {
-                            // Not valid JSON, treat as text
-                            parts.push({ text: content });
-                        }
-                    }
-                    else {
-                        parts.push({ text: content });
-                    }
-                }
-                else if (Array.isArray(content)) {
-                    // Content is Part[]
-                    parts.push(...content);
-                }
-                else {
-                    // Content is a single Part
-                    parts.push(content);
-                }
-            }
-            // Handle tool calls
-            if (msg.tool_calls && msg.tool_calls.length > 0) {
-                // Check if function calls were already added via parts
-                const existingFunctionCallIds = new Set();
-                if (msg.parts && msg.parts.length > 0) {
-                    for (const part of parts) {
-                        if ('functionCall' in part) {
-                            const fc = part;
-                            if (fc.functionCall.id) {
-                                existingFunctionCallIds.add(fc.functionCall.id);
-                            }
-                        }
-                    }
-                }
-                for (const toolCall of msg.tool_calls) {
-                    // Skip if this function call was already added via parts
-                    if (toolCall.id && existingFunctionCallIds.has(toolCall.id)) {
-                        continue;
-                    }
-                    // Ensure tool call has an ID
-                    if (!toolCall.id) {
-                        this.logger.debug(() => `Tool call at message ${i} missing ID, generating one: ${JSON.stringify(toolCall)}`);
-                        // Generate a unique ID for the function call
-                        toolCall.id = `generated_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                    }
-                    const partIndex = parts.length;
-                    parts.push({
-                        functionCall: {
-                            id: toolCall.id,
-                            name: toolCall.function.name,
-                            args: JSON.parse(toolCall.function.arguments),
-                        },
-                    });
-                    // Track this function call with its position
-                    functionCalls.set(toolCall.id, {
-                        name: toolCall.function.name,
-                        contentIndex: contents.length,
-                        partIndex,
-                        messageIndex: i,
-                    });
-                }
-            }
-            // Map roles
-            let role = 'user';
-            if (msg.role === ContentGeneratorRole.ASSISTANT) {
-                role = 'model';
-            }
-            else if (msg.role === ContentGeneratorRole.USER) {
-                role = 'user';
-            }
-            else if (msg.role === 'system') {
-                // Gemini doesn't have system role in contents, handle separately
-                role = 'user';
-            }
-            if (parts.length > 0) {
-                contents.push({
-                    role,
-                    parts,
-                });
-            }
-        }
-        // Validate and add missing function responses
-        for (const [callId, callInfo] of Array.from(functionCalls.entries())) {
-            if (!functionResponses.has(callId)) {
-                // Create a placeholder response for missing function response
-                this.logger.debug(() => `Function call ${callInfo.name} (id: ${callId}) has no matching response, adding placeholder`);
-                // Add each function response as a separate content object (same as regular tool responses)
-                contents.push({
-                    role: 'user',
-                    parts: [
-                        {
-                            functionResponse: {
-                                id: callId,
-                                name: callInfo.name,
-                                response: {
-                                    output: JSON.stringify({
-                                        error: 'Function call was interrupted or no response received',
-                                        message: `The function "${callInfo.name}" was called but did not receive a response. This may occur if the function execution was interrupted, requires authentication, or encountered an error.`,
-                                        callId,
-                                        functionName: callInfo.name,
-                                    }),
-                                },
-                            },
-                        },
-                    ],
-                });
-                // Mark this response as added
-                functionResponses.set(callId, {
-                    name: callInfo.name,
-                    contentIndex: contents.length - 1,
-                    messageIndex: -1, // Placeholder response doesn't have original message index
-                });
-            }
-        }
-        // Final validation - count function calls and responses
-        let totalFunctionCalls = 0;
-        let totalFunctionResponses = 0;
-        const callsDetail = [];
-        const responsesDetail = [];
-        const unmatchedCalls = new Set();
-        const unmatchedResponses = new Set();
-        // First pass: collect all function calls and responses with their IDs
-        for (let i = 0; i < contents.length; i++) {
-            const content = contents[i];
-            for (const part of content.parts) {
-                if ('functionCall' in part) {
-                    totalFunctionCalls++;
-                    const fc = part;
-                    callsDetail.push(`${i}: ${fc.functionCall.name} (${fc.functionCall.id})`);
-                    if (fc.functionCall.id) {
-                        unmatchedCalls.add(fc.functionCall.id);
-                    }
-                }
-                else if ('functionResponse' in part) {
-                    totalFunctionResponses++;
-                    const fr = part;
-                    responsesDetail.push(`${i}: ${fr.functionResponse.name} (${fr.functionResponse.id})`);
-                    if (fr.functionResponse.id) {
-                        unmatchedResponses.add(fr.functionResponse.id);
-                    }
-                }
-            }
-        }
-        // Second pass: match calls with responses
-        for (const id of unmatchedCalls) {
-            if (unmatchedResponses.has(id)) {
-                unmatchedCalls.delete(id);
-                unmatchedResponses.delete(id);
-            }
-        }
-        if (totalFunctionCalls !== totalFunctionResponses) {
-            this.logger.debug(() => `Function parts count mismatch: ${totalFunctionCalls} calls vs ${totalFunctionResponses} responses`);
-            this.logger.debug(() => `Function calls: ${JSON.stringify(callsDetail)}`);
-            this.logger.debug(() => `Function responses: ${JSON.stringify(responsesDetail)}`);
-            this.logger.debug(() => `Unmatched call IDs: ${JSON.stringify(Array.from(unmatchedCalls))}`);
-            this.logger.debug(() => `Unmatched response IDs: ${JSON.stringify(Array.from(unmatchedResponses))}`);
-            // This is now just a warning, not an error, since we've added placeholders
-            // The Gemini API should handle this gracefully
-        }
-        return contents;
-    }
-    convertToolsToGeminiFormat(tools) {
-        const result = [
-            {
-                functionDeclarations: tools.map((tool) => ({
-                    name: tool.function.name,
-                    description: tool.function.description,
-                    parameters: tool.function.parameters,
-                })),
-            },
-        ];
-        this.logger.debug(() => `Converted tools to Gemini format: ${JSON.stringify(result, null, 2)}`);
-        return result;
-    }
     setApiKey(apiKey) {
         // Call base provider implementation
         super.setApiKey(apiKey);
@@ -1096,5 +640,187 @@ export class GeminiProvider extends BaseProvider {
             throw new Error(`Unknown server tool: ${toolName}`);
         }
     }
+    /**
+     * Generate chat completion with IContent interface
+     * Direct implementation for Gemini API with IContent interface
+     */
+    async *generateChatCompletion(content, tools, _toolFormat) {
+        // Determine best auth method
+        const authToken = await this.determineBestAuth();
+        // Import necessary modules
+        const { GoogleGenAI } = await import('@google/genai');
+        // Convert IContent directly to Gemini format
+        const contents = [];
+        let systemMessage;
+        for (const c of content) {
+            if (c.speaker === 'human') {
+                const textBlock = c.blocks.find((b) => b.type === 'text');
+                if (textBlock?.text?.includes('You are') && contents.length === 0) {
+                    // First message might be system prompt
+                    systemMessage = textBlock.text;
+                    continue;
+                }
+                const parts = [];
+                for (const block of c.blocks) {
+                    if (block.type === 'text') {
+                        parts.push({ text: block.text });
+                    }
+                }
+                if (parts.length > 0) {
+                    contents.push({ role: 'user', parts });
+                }
+            }
+            else if (c.speaker === 'ai') {
+                const parts = [];
+                for (const block of c.blocks) {
+                    if (block.type === 'text') {
+                        parts.push({ text: block.text });
+                    }
+                    else if (block.type === 'tool_call') {
+                        const tc = block;
+                        parts.push({
+                            functionCall: {
+                                id: tc.id,
+                                name: tc.name,
+                                args: tc.parameters,
+                            },
+                        });
+                    }
+                }
+                if (parts.length > 0) {
+                    contents.push({ role: 'model', parts });
+                }
+            }
+            else if (c.speaker === 'tool') {
+                const toolResponseBlock = c.blocks.find((b) => b.type === 'tool_response');
+                if (!toolResponseBlock) {
+                    throw new Error('Tool content must have a tool_response block');
+                }
+                contents.push({
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                id: toolResponseBlock.callId,
+                                name: toolResponseBlock.toolName,
+                                response: {
+                                    output: JSON.stringify(toolResponseBlock.result),
+                                },
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        // Ensure tools have proper type: 'object' for Gemini
+        const geminiTools = tools
+            ? [
+                {
+                    functionDeclarations: tools[0].functionDeclarations.map((decl) => {
+                        let parameters = decl.parameters;
+                        if (parameters &&
+                            typeof parameters === 'object' &&
+                            !('type' in parameters)) {
+                            parameters = { type: Type.OBJECT, ...parameters };
+                        }
+                        else if (!parameters) {
+                            parameters = { type: Type.OBJECT, properties: {} };
+                        }
+                        return {
+                            name: decl.name,
+                            description: decl.description,
+                            parameters: parameters,
+                        };
+                    }),
+                },
+            ]
+            : undefined;
+        // Create appropriate client and generate content
+        const httpOptions = {
+            headers: {
+                'User-Agent': `LLxprt-Code/${process.env.CLI_VERSION || process.version} (${process.platform}; ${process.arch})`,
+            },
+        };
+        let stream;
+        if (this.authMode === 'oauth') {
+            // OAuth mode
+            const configForOAuth = this.geminiConfig || {
+                getProxy: () => undefined,
+            };
+            const contentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, configForOAuth, this.baseURL);
+            const userMemory = this.geminiConfig?.getUserMemory
+                ? this.geminiConfig.getUserMemory()
+                : '';
+            const systemInstruction = systemMessage ||
+                (await getCoreSystemPromptAsync(userMemory, this.currentModel));
+            const request = {
+                model: this.currentModel,
+                contents,
+                systemInstruction,
+                config: {
+                    tools: geminiTools,
+                    ...this.modelParams,
+                },
+            };
+            stream = await contentGenerator.generateContentStream(request, 'oauth-session');
+        }
+        else {
+            // API key mode
+            const genAI = new GoogleGenAI({
+                apiKey: authToken,
+                vertexai: this.authMode === 'vertex-ai',
+                httpOptions: this.baseURL
+                    ? { ...httpOptions, baseUrl: this.baseURL }
+                    : httpOptions,
+            });
+            const contentGenerator = genAI.models;
+            const userMemory = this.geminiConfig?.getUserMemory
+                ? this.geminiConfig.getUserMemory()
+                : '';
+            const systemInstruction = systemMessage ||
+                (await getCoreSystemPromptAsync(userMemory, this.currentModel));
+            const request = {
+                model: this.currentModel,
+                contents,
+                systemInstruction,
+                config: {
+                    tools: geminiTools,
+                    ...this.modelParams,
+                },
+            };
+            stream = await contentGenerator.generateContentStream(request);
+        }
+        // Stream responses as IContent
+        for await (const response of stream) {
+            const text = response.candidates?.[0]?.content?.parts
+                ?.filter((part) => 'text' in part)
+                ?.map((part) => part.text)
+                ?.join('') || '';
+            const functionCalls = response.candidates?.[0]?.content?.parts
+                ?.filter((part) => 'functionCall' in part)
+                ?.map((part) => part.functionCall) || [];
+            // Yield text if present
+            if (text) {
+                yield {
+                    speaker: 'ai',
+                    blocks: [{ type: 'text', text }],
+                };
+            }
+            // Yield tool calls if present
+            if (functionCalls.length > 0) {
+                const blocks = functionCalls.map((call) => ({
+                    type: 'tool_call',
+                    id: call.id ||
+                        `call_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+                    name: call.name || 'unknown_function',
+                    parameters: call.args || {},
+                }));
+                yield {
+                    speaker: 'ai',
+                    blocks,
+                };
+            }
+        }
+    }
 }
 //# sourceMappingURL=GeminiProvider.js.map