@layer-ai/core 2.0.18 → 2.0.19

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

@@ -392,6 +392,84 @@ async function testGeminiToolCallsStreaming() {
         console.log('  ⚠️  Tool calls may not have been invoked (model chose not to use tools)\n');
     }
 }
+// Test 10: Mistral streaming
+async function testMistralStreaming() {
+    console.log('Test 10: Mistral Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-small-2501',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say "mistral 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('  ✅ Mistral streaming test passed\n');
+}
+// Test 11: Mistral with tool calls streaming
+async function testMistralToolCallsStreaming() {
+    console.log('Test 11: Mistral Tool Calls Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-small-2501',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in Berlin?' }
+            ],
+            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('  ✅ Mistral 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 {
@@ -404,6 +482,8 @@ async function testGeminiToolCallsStreaming() {
         await testMultiProviderFallback();
         await testGeminiStreaming();
         await testGeminiToolCallsStreaming();
+        await testMistralStreaming();
+        await testMistralToolCallsStreaming();
         console.log('='.repeat(80));
         console.log('✅ ALL STREAMING ROUTE TESTS PASSED');
         console.log('='.repeat(80));

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

@@ -7,7 +7,9 @@ export declare class MistralAdapter extends BaseProviderAdapter {
     protected finishReasonMappings: Record<string, FinishReason>;
     protected toolChoiceMappings: Record<string, string>;
     call(request: LayerRequest, userId?: string): Promise<LayerResponse>;
+    callStream(request: LayerRequest, userId?: string): AsyncIterable<LayerResponse>;
     private handleChat;
+    private handleChatStream;
     private handleEmbeddings;
     private handleOCR;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"mistral-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/mistral-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EAEb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAoB1E,qBAAa,cAAe,SAAQ,mBAAmB;IACrD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAoB;IAEhD,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAGF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAM1D;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIlD;IAEI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;YAsB5D,UAAU;YAiMV,gBAAgB;YA0ChB,SAAS;CA8ExB"}
+{"version":3,"file":"mistral-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/mistral-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EAEb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAoB1E,qBAAa,cAAe,SAAQ,mBAAmB;IACrD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAoB;IAEhD,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAGF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAM1D;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIlD;IAEI,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAsBnE,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAAC;YAYzE,UAAU;YAiMT,gBAAgB;YAgPjB,gBAAgB;YA0ChB,SAAS;CA8ExB"}

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

@@ -64,6 +64,16 @@ export class MistralAdapter extends BaseProviderAdapter {
                 throw new Error(`Unknown modality: ${request.type}`);
         }
     }
+    async *callStream(request, userId) {
+        const resolved = await resolveApiKey(this.provider, userId, process.env.MISTRAL_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 mistral = getMistralClient(apiKey);
@@ -218,6 +228,201 @@ export class MistralAdapter extends BaseProviderAdapter {
             raw: response,
         };
     }
+    async *handleChatStream(request, apiKey, usedPlatformKey) {
+        const startTime = Date.now();
+        const mistral = getMistralClient(apiKey);
+        const { data: chat, model } = request;
+        if (!model) {
+            throw new Error('Model is required for chat completion');
+        }
+        // Build messages array (same as non-streaming)
+        const messages = [];
+        // Handle system prompt
+        if (chat.systemPrompt) {
+            messages.push({ role: 'system', content: chat.systemPrompt });
+        }
+        // Convert messages to Mistral format
+        for (const msg of chat.messages) {
+            const role = this.mapRole(msg.role);
+            // Handle vision messages (content + images)
+            if (msg.images && msg.images.length > 0 && role === 'user') {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                for (const image of msg.images) {
+                    const imageUrl = image.url || `data:${image.mimeType || 'image/jpeg'};base64,${image.base64}`;
+                    content.push({
+                        type: 'image_url',
+                        imageUrl: imageUrl,
+                    });
+                }
+                messages.push({ role, content });
+            }
+            // Handle tool responses
+            else if (msg.toolCallId && role === 'tool') {
+                messages.push({
+                    role: 'tool',
+                    content: msg.content || '',
+                    toolCallId: msg.toolCallId,
+                    name: msg.name,
+                });
+            }
+            // Handle assistant messages with tool calls
+            else if (msg.toolCalls && msg.toolCalls.length > 0) {
+                messages.push({
+                    role: 'assistant',
+                    content: msg.content || '',
+                    toolCalls: msg.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.function.name,
+                            arguments: tc.function.arguments,
+                        },
+                    })),
+                });
+            }
+            // Handle regular text messages
+            else {
+                messages.push({
+                    role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        // Convert tools to Mistral format
+        let tools;
+        if (chat.tools && chat.tools.length > 0) {
+            tools = chat.tools.map((tool) => ({
+                type: 'function',
+                function: {
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    parameters: tool.function.parameters || {},
+                },
+            }));
+        }
+        // Map tool choice
+        let toolChoice;
+        if (chat.toolChoice) {
+            if (typeof chat.toolChoice === 'object') {
+                toolChoice = chat.toolChoice;
+            }
+            else {
+                const mapped = this.mapToolChoice(chat.toolChoice);
+                if (mapped === 'auto' || mapped === 'none' || mapped === 'any' || mapped === 'required') {
+                    toolChoice = mapped;
+                }
+            }
+        }
+        const stream = await mistral.chat.stream({
+            model,
+            messages: messages,
+            ...(chat.temperature !== undefined && { temperature: chat.temperature }),
+            ...(chat.maxTokens !== undefined && { maxTokens: chat.maxTokens }),
+            ...(chat.topP !== undefined && { topP: chat.topP }),
+            ...(chat.stopSequences !== undefined && { stop: chat.stopSequences }),
+            ...(chat.frequencyPenalty !== undefined && { frequencyPenalty: chat.frequencyPenalty }),
+            ...(chat.presencePenalty !== undefined && { presencePenalty: chat.presencePenalty }),
+            ...(chat.seed !== undefined && { randomSeed: chat.seed }),
+            ...(tools && { tools }),
+            ...(toolChoice && { toolChoice }),
+            ...(chat.responseFormat && {
+                responseFormat: typeof chat.responseFormat === 'string'
+                    ? { type: chat.responseFormat }
+                    : chat.responseFormat,
+            }),
+        });
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let totalTokens = 0;
+        let fullContent = '';
+        let currentToolCalls = [];
+        let finishReason = null;
+        let modelVersion;
+        for await (const chunk of stream) {
+            // Mistral CompletionEvent can be of type 'chunk' or 'usage'
+            const event = chunk;
+            // Handle chunk events with choices
+            if (event.data?.choices) {
+                const choice = event.data.choices[0];
+                const delta = choice?.delta;
+                // Handle text content
+                if (delta?.content) {
+                    const contentStr = typeof delta.content === 'string'
+                        ? delta.content
+                        : Array.isArray(delta.content)
+                            ? delta.content.map((c) => c.text || c.content || '').join('')
+                            : '';
+                    if (contentStr) {
+                        fullContent += contentStr;
+                        yield {
+                            content: contentStr,
+                            model: model,
+                            stream: true,
+                        };
+                    }
+                }
+                // Handle tool calls
+                if (delta?.toolCalls && delta.toolCalls.length > 0) {
+                    for (const tc of delta.toolCalls) {
+                        const existingCall = currentToolCalls.find(call => call.id === tc.id);
+                        if (existingCall) {
+                            // Append to existing tool call arguments
+                            if (tc.function?.arguments) {
+                                existingCall.function.arguments += tc.function.arguments;
+                            }
+                        }
+                        else {
+                            // New tool call
+                            currentToolCalls.push({
+                                id: tc.id || `call_${currentToolCalls.length}`,
+                                type: 'function',
+                                function: {
+                                    name: tc.function?.name || '',
+                                    arguments: tc.function?.arguments || '',
+                                },
+                            });
+                        }
+                    }
+                }
+                // Handle finish reason
+                if (choice?.finishReason) {
+                    finishReason = choice.finishReason;
+                }
+                // Handle model version
+                if (event.data.model) {
+                    modelVersion = event.data.model;
+                }
+            }
+            // Handle usage events
+            if (event.data?.usage) {
+                promptTokens = event.data.usage.promptTokens || 0;
+                completionTokens = event.data.usage.completionTokens || 0;
+                totalTokens = event.data.usage.totalTokens || 0;
+            }
+        }
+        const cost = this.calculateCost(model, promptTokens, completionTokens);
+        const latencyMs = Date.now() - startTime;
+        // Yield final chunk with metadata
+        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 handleEmbeddings(request, apiKey, usedPlatformKey) {
         const startTime = Date.now();
         const mistral = getMistralClient(apiKey);

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

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

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

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

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

@@ -0,0 +1,139 @@
+import { MistralAdapter } from '../mistral-adapter.js';
+const adapter = new MistralAdapter();
+async function testChatStreamingBasic() {
+    console.log('Testing basic chat streaming...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'mistral-small-2501',
+        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: 'mistral-small-2501',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in Paris?' }
+            ],
+            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. Paris, France',
+                                },
+                            },
+                            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-mistral-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.18",
+  "version": "2.0.19",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",