@layer-ai/core 2.0.17 → 2.0.18

package/dist/routes/tests/test-chat-streaming.js

@@ -314,6 +314,84 @@ async function testMultiProviderFallback() {
         console.log('  ✅ Multi-provider fallback test passed\n');
     }
 }
+// Test 8: Google/Gemini streaming
+async function testGeminiStreaming() {
+    console.log('Test 8: Google/Gemini Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say "gemini test passed" and nothing else.' }
+            ],
+            maxTokens: 20,
+            stream: true,
+        }
+    };
+    let chunkCount = 0;
+    let fullContent = '';
+    for await (const chunk of callAdapterStream(request)) {
+        chunkCount++;
+        if (chunk.content) {
+            fullContent += chunk.content;
+        }
+    }
+    console.log(`  Chunks received: ${chunkCount}`);
+    console.log(`  Content: ${fullContent.trim()}`);
+    console.log('  ✅ Gemini streaming test passed\n');
+}
+// Test 9: Gemini with tool calls streaming
+async function testGeminiToolCallsStreaming() {
+    console.log('Test 9: Gemini Tool Calls Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in London?' }
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'get_weather',
+                        description: 'Get weather for a location',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                location: { type: 'string' },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+            stream: true,
+        }
+    };
+    let toolCallsFound = false;
+    let finishReason = null;
+    for await (const chunk of callAdapterStream(request)) {
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+            toolCallsFound = true;
+        }
+        if (chunk.finishReason) {
+            finishReason = chunk.finishReason;
+        }
+    }
+    console.log(`  Tool calls found: ${toolCallsFound}`);
+    console.log(`  Finish reason: ${finishReason}`);
+    if (toolCallsFound) {
+        console.log('  ✅ Gemini tool calls streaming test passed\n');
+    }
+    else {
+        console.log('  ⚠️  Tool calls may not have been invoked (model chose not to use tools)\n');
+    }
+}
 // Run all tests
 (async () => {
     try {
@@ -324,6 +402,8 @@ async function testMultiProviderFallback() {
         await testClaudeStreaming();
         await testClaudeToolCallsStreaming();
         await testMultiProviderFallback();
+        await testGeminiStreaming();
+        await testGeminiToolCallsStreaming();
         console.log('='.repeat(80));
         console.log('✅ ALL STREAMING ROUTE TESTS PASSED');
         console.log('='.repeat(80));

package/dist/services/providers/google-adapter.d.ts

@@ -12,7 +12,9 @@ export declare class GoogleAdapter extends BaseProviderAdapter {
         resolution: string;
     }>;
     call(request: LayerRequest, userId?: string): Promise<LayerResponse>;
+    callStream(request: LayerRequest, userId?: string): AsyncIterable<LayerResponse>;
     private handleChat;
+    private handleChatStream;
     private handleImageGeneration;
     private handleEmbeddings;
     private handleVideoGeneration;

package/dist/services/providers/google-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/google-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,yBAAyB,EAI1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAkB1E,qBAAa,aAAc,SAAQ,mBAAmB;IACpD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAmB;IAE/C,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAGF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAO1D;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAIrE;IAGF,SAAS,CAAC,eAAe,EAAE,MAAM,CAC/B,SAAS,EACT;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC5C,CAKC;IAEI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;YAoB5D,UAAU;YAwLV,qBAAqB;YAqCrB,gBAAgB;YAsChB,qBAAqB;YAsHrB,kBAAkB;IA2ChC,OAAO,CAAC,KAAK;CAGd"}
+{"version":3,"file":"google-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/google-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,yBAAyB,EAI1B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAgB1E,qBAAa,aAAc,SAAQ,mBAAmB;IACpD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAmB;IAE/C,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAEF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAO1D;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAIrE;IAEF,SAAS,CAAC,eAAe,EAAE,MAAM,CAC/B,SAAS,EACT;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC5C,CAKC;IAEI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAmBnE,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAAC;YAYzE,UAAU;YAwLT,gBAAgB;YAmNjB,qBAAqB;YAqCrB,gBAAgB;YAsChB,qBAAqB;YAsHrB,kBAAkB;IA2ChC,OAAO,CAAC,KAAK;CAGd"}

package/dist/services/providers/google-adapter.js

@@ -5,11 +5,9 @@ import { PROVIDER } from "../../lib/provider-constants.js";
 import { resolveApiKey } from '../../lib/key-resolver.js';
 let client = null;
 function getGoogleClient(apiKey) {
-    // If custom API key provided, create new client
     if (apiKey) {
         return new GoogleGenAI({ apiKey });
     }
-    // Otherwise use singleton with platform key
     if (!client) {
         client = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY || '' });
     }
@@ -28,7 +26,6 @@ export class GoogleAdapter extends BaseProviderAdapter {
             model: 'model',
             developer: 'system',
         };
-        // Map Google finish reasons to Layer finish reasons
         this.finishReasonMappings = {
             STOP: 'completed',
             MAX_TOKENS: 'length_limit',
@@ -42,7 +39,6 @@ export class GoogleAdapter extends BaseProviderAdapter {
             none: FunctionCallingConfigMode.NONE,
             required: FunctionCallingConfigMode.ANY,
         };
-        // Map Layer VideoSize to Veo aspect ratio and resolution
         this.videoSizeConfig = {
             '720x1280': { aspectRatio: '9:16', resolution: '720p' },
             '1280x720': { aspectRatio: '16:9', resolution: '720p' },
@@ -51,7 +47,6 @@ export class GoogleAdapter extends BaseProviderAdapter {
         };
     }
     async call(request, userId) {
-        // Resolve API key (BYOK → Platform key)
         const resolved = await resolveApiKey(this.provider, userId, process.env.GOOGLE_API_KEY);
         switch (request.type) {
             case 'chat':
@@ -68,6 +63,16 @@ export class GoogleAdapter extends BaseProviderAdapter {
                 throw new Error(`Unknown modality: ${request.type}`);
         }
     }
+    async *callStream(request, userId) {
+        const resolved = await resolveApiKey(this.provider, userId, process.env.GOOGLE_API_KEY);
+        switch (request.type) {
+            case 'chat':
+                yield* this.handleChatStream(request, resolved.key, resolved.usedPlatformKey);
+                break;
+            default:
+                throw new Error(`Streaming not supported for type: ${request.type}`);
+        }
+    }
     async handleChat(request, apiKey, usedPlatformKey) {
         const startTime = Date.now();
         const client = getGoogleClient(apiKey);
@@ -224,6 +229,182 @@ export class GoogleAdapter extends BaseProviderAdapter {
             raw: response,
         };
     }
+    async *handleChatStream(request, apiKey, usedPlatformKey) {
+        const startTime = Date.now();
+        const client = getGoogleClient(apiKey);
+        const { data: chat, model } = request;
+        if (!model) {
+            throw new Error('Model is required for chat completion');
+        }
+        const contents = [];
+        let systemInstruction;
+        if (chat.systemPrompt) {
+            systemInstruction = chat.systemPrompt;
+        }
+        for (const msg of chat.messages) {
+            const role = this.mapRole(msg.role);
+            if (role === 'system') {
+                systemInstruction = systemInstruction
+                    ? `${systemInstruction}\n${msg.content}`
+                    : msg.content;
+                continue;
+            }
+            const parts = [];
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            if (msg.images && msg.images.length > 0) {
+                for (const image of msg.images) {
+                    if (image.base64) {
+                        parts.push({
+                            inlineData: {
+                                mimeType: image.mimeType || 'image/jpeg',
+                                data: image.base64,
+                            },
+                        });
+                    }
+                    else if (image.url) {
+                        parts.push({
+                            fileData: {
+                                mimeType: image.mimeType || 'image/jpeg',
+                                fileUri: image.url,
+                            },
+                        });
+                    }
+                }
+            }
+            if (msg.toolCallId && msg.role === 'tool') {
+                if (!msg.name) {
+                    throw new Error('Tool response messages must include the function name');
+                }
+                parts.push({
+                    functionResponse: {
+                        name: msg.name || msg.toolCallId,
+                        response: { result: msg.content },
+                    },
+                });
+            }
+            if (msg.toolCalls && msg.toolCalls.length > 0) {
+                for (const toolCall of msg.toolCalls) {
+                    parts.push({
+                        functionCall: {
+                            name: toolCall.function.name,
+                            args: JSON.parse(toolCall.function.arguments),
+                        },
+                    });
+                }
+            }
+            if (parts.length > 0) {
+                contents.push({
+                    role: role === 'model' ? 'model' : 'user',
+                    parts,
+                });
+            }
+        }
+        let googleTools;
+        if (chat.tools && chat.tools.length > 0) {
+            googleTools = [
+                {
+                    functionDeclarations: chat.tools.map((tool) => ({
+                        name: tool.function.name,
+                        description: tool.function.description,
+                        parametersJsonSchema: tool.function.parameters,
+                    })),
+                },
+            ];
+        }
+        let toolConfig;
+        if (chat.toolChoice) {
+            const mode = this.mapToolChoice(chat.toolChoice);
+            if (typeof mode === 'string') {
+                toolConfig = {
+                    functionCallingConfig: { mode: mode },
+                };
+            }
+        }
+        const stream = await client.models.generateContentStream({
+            model: model,
+            contents,
+            config: {
+                ...(systemInstruction && { systemInstruction }),
+                ...(googleTools && { tools: googleTools }),
+                ...(toolConfig && { toolConfig }),
+                ...(chat.temperature !== undefined && { temperature: chat.temperature }),
+                ...(chat.maxTokens !== undefined && { maxOutputTokens: chat.maxTokens }),
+                ...(chat.topP !== undefined && { topP: chat.topP }),
+                ...(chat.stopSequences !== undefined && { stopSequences: chat.stopSequences }),
+            }
+        });
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let totalTokens = 0;
+        let fullContent = '';
+        let currentToolCalls = [];
+        let finishReason = null;
+        let modelVersion;
+        for await (const chunk of stream) {
+            const candidate = chunk.candidates?.[0];
+            const content = candidate?.content;
+            const textChunk = content?.parts
+                ?.filter((part) => 'text' in part)
+                .map((part) => part.text)
+                .join('');
+            if (textChunk) {
+                fullContent += textChunk;
+                yield {
+                    content: textChunk,
+                    model: model,
+                    stream: true,
+                };
+            }
+            const toolCallParts = content?.parts?.filter((part) => 'functionCall' in part);
+            if (toolCallParts && toolCallParts.length > 0) {
+                for (const part of toolCallParts) {
+                    const fc = part.functionCall;
+                    const existingCall = currentToolCalls.find(tc => tc.function.name === fc.name);
+                    if (!existingCall) {
+                        currentToolCalls.push({
+                            id: `call_${currentToolCalls.length}_${fc.name}`,
+                            type: 'function',
+                            function: {
+                                name: fc.name,
+                                arguments: JSON.stringify(fc.args),
+                            },
+                        });
+                    }
+                }
+            }
+            if (chunk.usageMetadata) {
+                promptTokens = chunk.usageMetadata.promptTokenCount || 0;
+                completionTokens = chunk.usageMetadata.candidatesTokenCount || 0;
+                totalTokens = chunk.usageMetadata.totalTokenCount || 0;
+            }
+            if (candidate?.finishReason) {
+                finishReason = candidate.finishReason;
+            }
+            if (chunk.modelVersion) {
+                modelVersion = chunk.modelVersion;
+            }
+        }
+        const cost = this.calculateCost(model, promptTokens, completionTokens);
+        const latencyMs = Date.now() - startTime;
+        yield {
+            content: '',
+            model: modelVersion || model,
+            toolCalls: currentToolCalls.length > 0 ? currentToolCalls : undefined,
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens,
+            },
+            cost,
+            latencyMs,
+            usedPlatformKey,
+            stream: true,
+            finishReason: this.mapFinishReason(finishReason || 'STOP'),
+            rawFinishReason: finishReason || undefined,
+        };
+    }
     async handleImageGeneration(request, apiKey, usedPlatformKey) {
         const startTime = Date.now();
         const client = getGoogleClient(apiKey);

package/dist/services/providers/tests/test-google-streaming.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-google-streaming.d.ts.map

package/dist/services/providers/tests/test-google-streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-google-streaming.d.ts","sourceRoot":"","sources":["../../../../src/services/providers/tests/test-google-streaming.ts"],"names":[],"mappings":""}

package/dist/services/providers/tests/test-google-streaming.js

@@ -0,0 +1,139 @@
+import { GoogleAdapter } from '../google-adapter.js';
+const adapter = new GoogleAdapter();
+async function testChatStreamingBasic() {
+    console.log('Testing basic chat streaming...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Count from 1 to 5 slowly, one number per line.' }
+            ],
+            temperature: 0.7,
+            maxTokens: 50,
+            stream: true,
+        }
+    };
+    if (!adapter.callStream) {
+        throw new Error('callStream method not available');
+    }
+    let chunkCount = 0;
+    let fullContent = '';
+    let finalUsage = null;
+    let finalCost = null;
+    console.log('\nStreaming chunks:');
+    console.log('---');
+    for await (const chunk of adapter.callStream(request)) {
+        chunkCount++;
+        if (chunk.content) {
+            process.stdout.write(chunk.content);
+            fullContent += chunk.content;
+        }
+        if (chunk.usage) {
+            finalUsage = chunk.usage;
+        }
+        if (chunk.cost) {
+            finalCost = chunk.cost;
+        }
+    }
+    console.log('\n---\n');
+    console.log('Total chunks received:', chunkCount);
+    console.log('Full content:', fullContent);
+    console.log('Final usage:', finalUsage);
+    console.log('Final cost:', finalCost);
+    console.log('✅ Basic streaming test passed\n');
+}
+async function testChatStreamingWithToolCalls() {
+    console.log('Testing chat streaming with tool calls...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'gemini-2.0-flash',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in San Francisco?' }
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'get_weather',
+                        description: 'Get the current weather for a location',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                location: {
+                                    type: 'string',
+                                    description: 'The city and state, e.g. San Francisco, CA',
+                                },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+            toolChoice: 'auto',
+            stream: true,
+        }
+    };
+    if (!adapter.callStream) {
+        throw new Error('callStream method not available');
+    }
+    let toolCallsReceived = false;
+    for await (const chunk of adapter.callStream(request)) {
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+            console.log('Tool calls received:', JSON.stringify(chunk.toolCalls, null, 2));
+            toolCallsReceived = true;
+        }
+        if (chunk.finishReason === 'tool_call') {
+            console.log('Finish reason: tool_call');
+        }
+    }
+    if (!toolCallsReceived) {
+        console.warn('⚠️  No tool calls received (model may have chosen not to use tools)');
+    }
+    else {
+        console.log('✅ Tool calls streaming test passed\n');
+    }
+}
+async function testChatStreamingError() {
+    console.log('Testing streaming with invalid model (error handling)...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'invalid-google-model-name',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Hello' }
+            ],
+            stream: true,
+        }
+    };
+    if (!adapter.callStream) {
+        throw new Error('callStream method not available');
+    }
+    try {
+        for await (const chunk of adapter.callStream(request)) {
+            console.log('Received chunk:', chunk);
+        }
+        console.error('❌ Should have thrown an error for invalid model');
+    }
+    catch (error) {
+        console.log('✅ Correctly threw error:', error instanceof Error ? error.message : error);
+        console.log('✅ Error handling test passed\n');
+    }
+}
+// Run all tests
+(async () => {
+    try {
+        await testChatStreamingBasic();
+        await testChatStreamingWithToolCalls();
+        await testChatStreamingError();
+        console.log('✅ All streaming tests completed successfully!');
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        process.exit(1);
+    }
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "2.0.17",
+  "version": "2.0.18",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",