@layer-ai/core 2.0.18 → 2.0.20

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { default as authRouter } from './routes/v1/auth.js';
 export { default as gatesRouter } from './routes/v1/gates.js';
 export { default as keysRouter } from './routes/v1/keys.js';
 export { default as logsRouter } from './routes/v1/logs.js';
+export { default as chatCompletionsRouter } from './routes/v1/chat-completions.js';
 export { default as completeRouter } from './routes/v2/complete.js';
 export { default as chatRouter } from './routes/v3/chat.js';
 export { default as imageRouter } from './routes/v3/image.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAG5D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG3C,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAGrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAG3E,CAAC;AAGF,cAAc,6BAA6B,CAAC;AAG5C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,WAAW,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAGnF,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG1D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG3C,OAAO,EAAE,EAAE,EAAE,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAGrE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,IAAI,CAG3E,CAAC;AAGF,cAAc,6BAA6B,CAAC;AAG5C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,QAAQ,EAAE,WAAW,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -3,6 +3,7 @@ export { default as authRouter } from './routes/v1/auth.js';
 export { default as gatesRouter } from './routes/v1/gates.js';
 export { default as keysRouter } from './routes/v1/keys.js';
 export { default as logsRouter } from './routes/v1/logs.js';
+export { default as chatCompletionsRouter } from './routes/v1/chat-completions.js';
 // v2 routes
 export { default as completeRouter } from './routes/v2/complete.js';
 // v3 routes

package/dist/lib/openai-conversion.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAIChatCompletionRequest, OpenAIChatCompletionResponse, OpenAIChatCompletionChunk } from '@layer-ai/sdk';
+import type { LayerRequest, LayerResponse } from '@layer-ai/sdk';
+export declare function convertOpenAIRequestToLayer(openaiReq: OpenAIChatCompletionRequest, gateId: string): LayerRequest;
+export declare function convertLayerResponseToOpenAI(layerResp: LayerResponse, requestId?: string): OpenAIChatCompletionResponse;
+export declare function convertLayerChunkToOpenAI(layerChunk: LayerResponse, requestId: string, created: number): OpenAIChatCompletionChunk;
+//# sourceMappingURL=openai-conversion.d.ts.map

package/dist/lib/openai-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-conversion.d.ts","sourceRoot":"","sources":["../../src/lib/openai-conversion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,2BAA2B,EAK3B,4BAA4B,EAC5B,yBAAyB,EAE1B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAOd,MAAM,eAAe,CAAC;AAqFvB,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,2BAA2B,EACtC,MAAM,EAAE,MAAM,GACb,YAAY,CA2Cd;AAwCD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,aAAa,EACxB,SAAS,CAAC,EAAE,MAAM,GACjB,4BAA4B,CA+B9B;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,aAAa,EACzB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,yBAAyB,CA2C3B"}

package/dist/lib/openai-conversion.js

@@ -0,0 +1,215 @@
+import { nanoid } from 'nanoid';
+function convertMessage(openaiMsg) {
+    const layerMsg = {
+        role: openaiMsg.role,
+    };
+    if (typeof openaiMsg.content === 'string') {
+        layerMsg.content = openaiMsg.content;
+    }
+    else if (Array.isArray(openaiMsg.content)) {
+        const textParts = [];
+        const imageParts = [];
+        for (const part of openaiMsg.content) {
+            if (part.type === 'text') {
+                textParts.push(part.text);
+            }
+            else if (part.type === 'image_url') {
+                imageParts.push({
+                    url: part.image_url.url,
+                    detail: part.image_url.detail,
+                });
+            }
+        }
+        if (textParts.length > 0) {
+            layerMsg.content = textParts.join('\n');
+        }
+        if (imageParts.length > 0) {
+            layerMsg.images = imageParts;
+        }
+    }
+    if (openaiMsg.tool_calls) {
+        layerMsg.toolCalls = openaiMsg.tool_calls.map(tc => ({
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+            },
+        }));
+    }
+    if (openaiMsg.tool_call_id) {
+        layerMsg.toolCallId = openaiMsg.tool_call_id;
+    }
+    if (openaiMsg.name) {
+        layerMsg.name = openaiMsg.name;
+    }
+    return layerMsg;
+}
+function convertTool(openaiTool) {
+    return {
+        type: 'function',
+        function: {
+            name: openaiTool.function.name,
+            description: openaiTool.function.description,
+            parameters: openaiTool.function.parameters,
+        },
+    };
+}
+function convertToolChoice(openaiToolChoice) {
+    if (!openaiToolChoice)
+        return undefined;
+    if (typeof openaiToolChoice === 'string')
+        return openaiToolChoice;
+    return openaiToolChoice;
+}
+function convertResponseFormat(openaiFormat) {
+    if (!openaiFormat)
+        return undefined;
+    if (openaiFormat.type === 'json_schema' && openaiFormat.json_schema) {
+        return {
+            type: 'json_schema',
+            json_schema: openaiFormat.json_schema,
+        };
+    }
+    return openaiFormat.type;
+}
+export function convertOpenAIRequestToLayer(openaiReq, gateId) {
+    let systemPrompt;
+    const messages = [];
+    for (const msg of openaiReq.messages) {
+        if (msg.role === 'system' && typeof msg.content === 'string') {
+            systemPrompt = msg.content;
+        }
+        else {
+            messages.push(convertMessage(msg));
+        }
+    }
+    const layerRequest = {
+        gateId,
+        type: 'chat',
+        model: openaiReq.model,
+        data: {
+            messages,
+            systemPrompt,
+            temperature: openaiReq.temperature,
+            maxTokens: openaiReq.max_tokens || openaiReq.max_completion_tokens,
+            topP: openaiReq.top_p,
+            stream: openaiReq.stream,
+            stopSequences: typeof openaiReq.stop === 'string' ? [openaiReq.stop] : openaiReq.stop,
+            frequencyPenalty: openaiReq.frequency_penalty,
+            presencePenalty: openaiReq.presence_penalty,
+            seed: openaiReq.seed,
+        },
+    };
+    if (openaiReq.tools && openaiReq.tools.length > 0) {
+        layerRequest.data.tools = openaiReq.tools.map(convertTool);
+    }
+    if (openaiReq.tool_choice) {
+        layerRequest.data.toolChoice = convertToolChoice(openaiReq.tool_choice);
+    }
+    if (openaiReq.response_format) {
+        layerRequest.data.responseFormat = convertResponseFormat(openaiReq.response_format);
+    }
+    return layerRequest;
+}
+function convertFinishReason(layerReason) {
+    if (!layerReason)
+        return null;
+    switch (layerReason) {
+        case 'completed':
+            return 'stop';
+        case 'length_limit':
+            return 'length';
+        case 'tool_call':
+            return 'tool_calls';
+        case 'filtered':
+            return 'content_filter';
+        default:
+            return 'stop';
+    }
+}
+function convertToolCallsToOpenAI(layerToolCalls) {
+    if (!layerToolCalls || layerToolCalls.length === 0)
+        return undefined;
+    return layerToolCalls.map(tc => ({
+        id: tc.id,
+        type: 'function',
+        function: {
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+        },
+    }));
+}
+function convertUsage(layerUsage) {
+    return {
+        prompt_tokens: layerUsage?.promptTokens || 0,
+        completion_tokens: layerUsage?.completionTokens || 0,
+        total_tokens: layerUsage?.totalTokens || 0,
+    };
+}
+export function convertLayerResponseToOpenAI(layerResp, requestId) {
+    const id = requestId || layerResp.id || `chatcmpl-${nanoid()}`;
+    const created = layerResp.created || Math.floor(Date.now() / 1000);
+    const message = {
+        role: 'assistant',
+        content: layerResp.content || undefined,
+    };
+    const toolCalls = convertToolCallsToOpenAI(layerResp.toolCalls);
+    if (toolCalls) {
+        message.tool_calls = toolCalls;
+    }
+    const response = {
+        id,
+        object: 'chat.completion',
+        created,
+        model: layerResp.model || 'unknown',
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: convertFinishReason(layerResp.finishReason),
+                logprobs: null,
+            },
+        ],
+        usage: convertUsage(layerResp.usage),
+    };
+    return response;
+}
+export function convertLayerChunkToOpenAI(layerChunk, requestId, created) {
+    const delta = {};
+    if (layerChunk.content && !layerChunk.finishReason) {
+        delta.role = 'assistant';
+    }
+    if (layerChunk.content) {
+        delta.content = layerChunk.content;
+    }
+    if (layerChunk.toolCalls && layerChunk.toolCalls.length > 0) {
+        delta.tool_calls = layerChunk.toolCalls.map((tc, index) => ({
+            index,
+            id: tc.id,
+            type: 'function',
+            function: {
+                name: tc.function.name,
+                arguments: tc.function.arguments,
+            },
+        }));
+    }
+    const chunk = {
+        id: requestId,
+        object: 'chat.completion.chunk',
+        created,
+        model: layerChunk.model || 'unknown',
+        choices: [
+            {
+                index: 0,
+                delta,
+                finish_reason: convertFinishReason(layerChunk.finishReason),
+                logprobs: null,
+            },
+        ],
+    };
+    if (layerChunk.usage && layerChunk.finishReason) {
+        chunk.usage = convertUsage(layerChunk.usage);
+    }
+    return chunk;
+}

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/routes/tests/test-openai-endpoint.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env npx tsx
+export {};
+//# sourceMappingURL=test-openai-endpoint.d.ts.map

package/dist/routes/tests/test-openai-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-openai-endpoint.d.ts","sourceRoot":"","sources":["../../../src/routes/tests/test-openai-endpoint.ts"],"names":[],"mappings":""}

package/dist/routes/tests/test-openai-endpoint.js

@@ -0,0 +1,292 @@
+#!/usr/bin/env npx tsx
+console.log('='.repeat(80));
+console.log('OPENAI-COMPATIBLE ENDPOINT TESTS');
+console.log('='.repeat(80));
+console.log('');
+const BASE_URL = process.env.API_URL || 'http://localhost:3004';
+const API_KEY = process.env.LAYER_API_KEY;
+const GATE_ID = process.env.TEST_GATE_ID;
+if (!API_KEY) {
+    console.error('❌ Error: LAYER_API_KEY environment variable not set');
+    process.exit(1);
+}
+if (!GATE_ID) {
+    console.error('❌ Error: TEST_GATE_ID environment variable not set');
+    process.exit(1);
+}
+async function testNonStreamingBasic() {
+    console.log('Test 1: Non-streaming basic chat completion');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'gpt-4o',
+        messages: [
+            { role: 'user', content: 'Say "test passed" and nothing else.' }
+        ],
+        max_tokens: 10,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Response ID:', data.id);
+    console.log('  Model:', data.model);
+    console.log('  Content:', data.choices[0].message.content);
+    console.log('  Finish reason:', data.choices[0].finish_reason);
+    console.log('  Usage:', data.usage);
+    console.log('  ✅ Non-streaming basic test passed\n');
+}
+async function testNonStreamingWithGateIdInHeader() {
+    console.log('Test 2: Non-streaming with gateId in header');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'gpt-4o',
+        messages: [
+            { role: 'user', content: 'Say "header test passed" and nothing else.' }
+        ],
+        max_tokens: 10,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+            'X-Layer-Gate-Id': GATE_ID,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Content:', data.choices[0].message.content);
+    console.log('  ✅ Header gateId test passed\n');
+}
+async function testStreamingBasic() {
+    console.log('Test 3: Streaming basic chat completion');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'gpt-4o',
+        messages: [
+            { role: 'user', content: 'Count from 1 to 3, one number per line.' }
+        ],
+        max_tokens: 50,
+        stream: true,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    let chunkCount = 0;
+    let fullContent = '';
+    let finalUsage = null;
+    const reader = response.body?.getReader();
+    const decoder = new TextDecoder();
+    if (!reader) {
+        throw new Error('No response body reader');
+    }
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const text = decoder.decode(value);
+        const lines = text.split('\n').filter(line => line.trim().startsWith('data: '));
+        for (const line of lines) {
+            const data = line.replace('data: ', '').trim();
+            if (data === '[DONE]') {
+                continue;
+            }
+            try {
+                const chunk = JSON.parse(data);
+                chunkCount++;
+                if (chunk.choices[0].delta.content) {
+                    fullContent += chunk.choices[0].delta.content;
+                }
+                if (chunk.usage) {
+                    finalUsage = chunk.usage;
+                }
+            }
+            catch (e) {
+                // Skip invalid JSON
+            }
+        }
+    }
+    console.log('  Chunks received:', chunkCount);
+    console.log('  Full content:', fullContent.trim());
+    console.log('  Final usage:', finalUsage);
+    console.log('  ✅ Streaming basic test passed\n');
+}
+async function testWithToolCalls() {
+    console.log('Test 4: Non-streaming with tool calls');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'gpt-4o',
+        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'],
+                    },
+                },
+            },
+        ],
+        tool_choice: 'auto',
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Finish reason:', data.choices[0].finish_reason);
+    if (data.choices[0].message.tool_calls && data.choices[0].message.tool_calls.length > 0) {
+        console.log('  Tool calls:', JSON.stringify(data.choices[0].message.tool_calls, null, 2));
+        console.log('  ✅ Tool calls test passed\n');
+    }
+    else {
+        console.log('  ⚠️  No tool calls received (model may have chosen not to use tools)\n');
+    }
+}
+async function testClaudeModel() {
+    console.log('Test 5: OpenAI format with Claude model');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-7-sonnet-20250219',
+        messages: [
+            { role: 'user', content: 'Say "claude via openai format works" and nothing else.' }
+        ],
+        max_tokens: 20,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Model:', data.model);
+    console.log('  Content:', data.choices[0].message.content);
+    console.log('  ✅ Claude model test passed\n');
+}
+async function testGeminiModel() {
+    console.log('Test 6: OpenAI format with Gemini model');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'gemini-2.0-flash',
+        messages: [
+            { role: 'user', content: 'Say "gemini via openai format works" and nothing else.' }
+        ],
+        max_tokens: 20,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Model:', data.model);
+    console.log('  Content:', data.choices[0].message.content);
+    console.log('  ✅ Gemini model test passed\n');
+}
+async function testMistralModel() {
+    console.log('Test 7: OpenAI format with Mistral model');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'mistral-small-2501',
+        messages: [
+            { role: 'user', content: 'Say "mistral via openai format works" and nothing else.' }
+        ],
+        max_tokens: 20,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(`Request failed: ${JSON.stringify(error)}`);
+    }
+    const data = await response.json();
+    console.log('  Model:', data.model);
+    console.log('  Content:', data.choices[0].message.content);
+    console.log('  ✅ Mistral model test passed\n');
+}
+(async () => {
+    try {
+        await testNonStreamingBasic();
+        await testNonStreamingWithGateIdInHeader();
+        await testStreamingBasic();
+        await testWithToolCalls();
+        await testClaudeModel();
+        await testGeminiModel();
+        await testMistralModel();
+        console.log('='.repeat(80));
+        console.log('✅ ALL OPENAI-COMPATIBLE ENDPOINT TESTS PASSED');
+        console.log('='.repeat(80));
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        process.exit(1);
+    }
+})();
+export {};

package/dist/routes/v1/chat-completions.d.ts

@@ -0,0 +1,4 @@
+import type { Router as RouterType } from 'express';
+declare const router: RouterType;
+export default router;
+//# sourceMappingURL=chat-completions.d.ts.map

package/dist/routes/v1/chat-completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-completions.d.ts","sourceRoot":"","sources":["../../../src/routes/v1/chat-completions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAapD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AA6RpC,eAAe,MAAM,CAAC"}

package/dist/routes/v1/chat-completions.js

@@ -0,0 +1,262 @@
+import { Router } from 'express';
+import { nanoid } from 'nanoid';
+import { db } from '../../lib/db/postgres.js';
+import { authenticate } from '../../middleware/auth.js';
+import { convertOpenAIRequestToLayer, convertLayerResponseToOpenAI, convertLayerChunkToOpenAI, } from '../../lib/openai-conversion.js';
+import { resolveFinalRequest } from '../v3/chat.js';
+import { callAdapter, callAdapterStream } from '../../lib/provider-factory.js';
+const router = Router();
+async function* executeWithRoutingStream(gateConfig, request, userId) {
+    yield* callAdapterStream(request, userId);
+}
+async function executeWithRouting(gateConfig, request, userId) {
+    const result = await callAdapter(request, userId);
+    return { result, modelUsed: request.model };
+}
+router.post('/', authenticate, async (req, res) => {
+    const startTime = Date.now();
+    if (!req.userId) {
+        const error = {
+            error: {
+                message: 'Missing user ID',
+                type: 'authentication_error',
+                code: 'unauthorized',
+            },
+        };
+        res.status(401).json(error);
+        return;
+    }
+    const userId = req.userId;
+    let gateConfig = null;
+    let layerRequest = null;
+    try {
+        const openaiReq = req.body;
+        const gateId = openaiReq.gateId || req.headers['x-layer-gate-id'];
+        if (!gateId) {
+            const error = {
+                error: {
+                    message: 'Missing required field: gateId (provide in request body or X-Layer-Gate-Id header)',
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'missing_field',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        const isUUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(gateId);
+        if (!isUUID) {
+            const error = {
+                error: {
+                    message: 'gateId must be a valid UUID',
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'invalid_format',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        gateConfig = await db.getGateByUserAndId(userId, gateId);
+        if (!gateConfig) {
+            const error = {
+                error: {
+                    message: `Gate with ID "${gateId}" not found`,
+                    type: 'invalid_request_error',
+                    param: 'gateId',
+                    code: 'not_found',
+                },
+            };
+            res.status(404).json(error);
+            return;
+        }
+        if (!openaiReq.messages || !Array.isArray(openaiReq.messages) || openaiReq.messages.length === 0) {
+            const error = {
+                error: {
+                    message: 'Missing required field: messages (must be a non-empty array)',
+                    type: 'invalid_request_error',
+                    param: 'messages',
+                    code: 'missing_field',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        if (gateConfig.taskType && gateConfig.taskType !== 'chat') {
+            console.warn(`[Type Mismatch] Gate "${gateConfig.name}" (${gateConfig.id}) configured for taskType="${gateConfig.taskType}" ` +
+                `but received request to /v1/chat/completions endpoint. Processing as chat request.`);
+        }
+        layerRequest = convertOpenAIRequestToLayer(openaiReq, gateId);
+        const finalRequest = resolveFinalRequest(gateConfig, layerRequest);
+        const isStreaming = finalRequest.data && 'stream' in finalRequest.data && finalRequest.data.stream === true;
+        if (isStreaming) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            res.setHeader('X-Accel-Buffering', 'no');
+            const requestId = `chatcmpl-${nanoid()}`;
+            const created = Math.floor(Date.now() / 1000);
+            let promptTokens = 0;
+            let completionTokens = 0;
+            let totalCost = 0;
+            let modelUsed = finalRequest.model;
+            try {
+                for await (const layerChunk of executeWithRoutingStream(gateConfig, finalRequest, userId)) {
+                    if (layerChunk.usage) {
+                        promptTokens = layerChunk.usage.promptTokens || 0;
+                        completionTokens = layerChunk.usage.completionTokens || 0;
+                    }
+                    if (layerChunk.cost) {
+                        totalCost = layerChunk.cost;
+                    }
+                    if (layerChunk.model) {
+                        modelUsed = layerChunk.model;
+                    }
+                    const openaiChunk = convertLayerChunkToOpenAI(layerChunk, requestId, created);
+                    res.write(`data: ${JSON.stringify(openaiChunk)}\n\n`);
+                }
+                res.write(`data: [DONE]\n\n`);
+                res.end();
+                const latencyMs = Date.now() - startTime;
+                db.logRequest({
+                    userId,
+                    gateId: gateConfig.id,
+                    gateName: gateConfig.name,
+                    modelRequested: layerRequest.model || gateConfig.model,
+                    modelUsed: modelUsed,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                    costUsd: totalCost,
+                    latencyMs,
+                    success: true,
+                    errorMessage: null,
+                    userAgent: req.headers['user-agent'] || null,
+                    ipAddress: req.ip || null,
+                    requestPayload: {
+                        gateId: layerRequest.gateId,
+                        type: layerRequest.type,
+                        model: layerRequest.model,
+                        data: layerRequest.data,
+                        metadata: layerRequest.metadata,
+                    },
+                    responsePayload: {
+                        streamed: true,
+                        model: modelUsed,
+                        usage: { promptTokens, completionTokens, totalTokens: promptTokens + completionTokens },
+                        cost: totalCost,
+                    },
+                }).catch(err => console.error('Failed to log request:', err));
+            }
+            catch (streamError) {
+                const errorMessage = streamError instanceof Error ? streamError.message : 'Unknown streaming error';
+                const openaiError = {
+                    error: {
+                        message: errorMessage,
+                        type: 'server_error',
+                        code: 'stream_error',
+                    },
+                };
+                res.write(`data: ${JSON.stringify(openaiError)}\n\n`);
+                res.end();
+                db.logRequest({
+                    userId,
+                    gateId: gateConfig.id,
+                    gateName: gateConfig.name,
+                    modelRequested: layerRequest.model || gateConfig.model,
+                    modelUsed: null,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: 0,
+                    costUsd: 0,
+                    latencyMs: Date.now() - startTime,
+                    success: false,
+                    errorMessage,
+                    userAgent: req.headers['user-agent'] || null,
+                    ipAddress: req.ip || null,
+                    requestPayload: {
+                        gateId: layerRequest.gateId,
+                        type: layerRequest.type,
+                        model: layerRequest.model,
+                        data: layerRequest.data,
+                        metadata: layerRequest.metadata,
+                    },
+                    responsePayload: null,
+                }).catch(err => console.error('Failed to log request:', err));
+            }
+            return;
+        }
+        const { result, modelUsed } = await executeWithRouting(gateConfig, finalRequest, userId);
+        const latencyMs = Date.now() - startTime;
+        db.logRequest({
+            userId,
+            gateId: gateConfig.id,
+            gateName: gateConfig.name,
+            modelRequested: layerRequest.model || gateConfig.model,
+            modelUsed: modelUsed,
+            promptTokens: result.usage?.promptTokens || 0,
+            completionTokens: result.usage?.completionTokens || 0,
+            totalTokens: result.usage?.totalTokens || 0,
+            costUsd: result.cost || 0,
+            latencyMs,
+            success: true,
+            errorMessage: null,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+            requestPayload: {
+                gateId: layerRequest.gateId,
+                type: layerRequest.type,
+                model: layerRequest.model,
+                data: layerRequest.data,
+                metadata: layerRequest.metadata,
+            },
+            responsePayload: {
+                content: result.content,
+                model: result.model,
+                usage: result.usage,
+                cost: result.cost,
+                finishReason: result.finishReason,
+            },
+        }).catch(err => console.error('Failed to log request:', err));
+        const openaiResponse = convertLayerResponseToOpenAI(result);
+        res.json(openaiResponse);
+    }
+    catch (error) {
+        const latencyMs = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        db.logRequest({
+            userId,
+            gateId: gateConfig?.id || null,
+            gateName: gateConfig?.name || null,
+            modelRequested: (layerRequest?.model || gateConfig?.model) || 'unknown',
+            modelUsed: null,
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            costUsd: 0,
+            latencyMs,
+            success: false,
+            errorMessage,
+            userAgent: req.headers['user-agent'] || null,
+            ipAddress: req.ip || null,
+            requestPayload: layerRequest ? {
+                gateId: layerRequest.gateId,
+                type: layerRequest.type,
+                model: layerRequest.model,
+                data: layerRequest.data,
+                metadata: layerRequest.metadata,
+            } : null,
+            responsePayload: null,
+        }).catch(err => console.error('Failed to log request:', err));
+        console.error('OpenAI chat completion error:', error);
+        const openaiError = {
+            error: {
+                message: errorMessage,
+                type: 'server_error',
+                code: 'internal_error',
+            },
+        };
+        res.status(500).json(openaiError);
+    }
+});
+export default router;

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.20",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
     "nanoid": "^5.0.4",
     "openai": "^4.24.0",
     "pg": "^8.11.3",
-    "@layer-ai/sdk": "^2.5.6"
+    "@layer-ai/sdk": "^2.5.7"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",