@layer-ai/core 0.5.0 → 0.5.2

package/dist/routes/v2/complete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/complete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAWpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAgQpC,eAAe,MAAM,CAAC"}
+{"version":3,"file":"complete.d.ts","sourceRoot":"","sources":["../../../src/routes/v2/complete.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,SAAS,CAAC;AAYpD,QAAA,MAAM,MAAM,EAAE,UAAqB,CAAC;AAyRpC,eAAe,MAAM,CAAC"}

package/dist/routes/v2/complete.js

@@ -5,9 +5,23 @@ import { authenticate } from '../../middleware/auth.js';
 import { OpenAIAdapter } from '../../services/providers/openai-adapter.js';
 import { AnthropicAdapter } from '../../services/providers/anthropic-adapter.js';
 import { GoogleAdapter } from '../../services/providers/google-adapter.js';
+import { MistralAdapter } from '../../services/providers/mistral-adapter.js';
 import { MODEL_REGISTRY, OverrideField } from '@layer-ai/sdk';
 const router = Router();
 // MARK:- Helper Functions
+function normalizeModelId(modelId) {
+    if (MODEL_REGISTRY[modelId]) {
+        return modelId;
+    }
+    const providers = ['openai', 'anthropic', 'google', 'mistral'];
+    for (const provider of providers) {
+        const fullId = `${provider}/${modelId}`;
+        if (MODEL_REGISTRY[fullId]) {
+            return fullId;
+        }
+    }
+    throw new Error(`invalid model ID: "${modelId}" not found in registry`);
+}
 function isOverrideAllowed(allowOverrides, field) {
     if (allowOverrides === undefined || allowOverrides === null || allowOverrides === true)
         return true;
@@ -28,10 +42,15 @@ async function getGateConfig(userId, gateName) {
 function resolveFinalRequest(gateConfig, request) {
     const finalRequest = { ...request };
     let finalModel = gateConfig.model;
-    if (request.model && isOverrideAllowed(gateConfig.allowOverrides, OverrideField.Model) && MODEL_REGISTRY[request.model]) {
-        finalModel = request.model;
+    if (request.model && isOverrideAllowed(gateConfig.allowOverrides, OverrideField.Model)) {
+        try {
+            finalModel = normalizeModelId(request.model);
+        }
+        catch {
+            finalModel = gateConfig.model;
+        }
     }
-    finalRequest.model = finalModel;
+    finalRequest.model = normalizeModelId(finalModel);
     if (request.type === 'chat') {
         const chatData = { ...request.data };
         if (!chatData.systemPrompt && gateConfig.systemPrompt) {
@@ -60,7 +79,8 @@ function resolveFinalRequest(gateConfig, request) {
     return finalRequest;
 }
 async function callProvider(request) {
-    const provider = MODEL_REGISTRY[request.model].provider;
+    const normalizedModel = normalizeModelId(request.model);
+    const provider = MODEL_REGISTRY[normalizedModel].provider;
     switch (provider) {
         case 'openai': {
             const adapter = new OpenAIAdapter();
@@ -73,6 +93,10 @@ async function callProvider(request) {
         case 'google':
             const adapter = new GoogleAdapter();
             return await adapter.call(request);
+        case 'mistral': {
+            const adapter = new MistralAdapter();
+            return await adapter.call(request);
+        }
         default:
             throw new Error(`Unknown provider: ${provider}`);
     }

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

@@ -0,0 +1,13 @@
+import { BaseProviderAdapter } from './base-adapter.js';
+import { LayerRequest, LayerResponse, Role, FinishReason } from '@layer-ai/sdk';
+export declare class MistralAdapter extends BaseProviderAdapter {
+    protected provider: string;
+    protected roleMappings: Record<Role, string>;
+    protected finishReasonMappings: Record<string, FinishReason>;
+    protected toolChoiceMappings: Record<string, string>;
+    call(request: LayerRequest): Promise<LayerResponse>;
+    private handleChat;
+    private handleEmbeddings;
+    private handleOCR;
+}
+//# sourceMappingURL=mistral-adapter.d.ts.map

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

@@ -0,0 +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;AAavB,qBAAa,cAAe,SAAQ,mBAAmB;IACrD,SAAS,CAAC,QAAQ,SAAa;IAE/B,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,GAAG,OAAO,CAAC,aAAa,CAAC;YAmB3C,UAAU;YA8LV,gBAAgB;YAuChB,SAAS;CA2ExB"}

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

@@ -0,0 +1,310 @@
+import { Mistral } from '@mistralai/mistralai';
+import { BaseProviderAdapter } from './base-adapter.js';
+import { ADAPTER_HANDLED, } from '@layer-ai/sdk';
+let client = null;
+function getMistralClient() {
+    if (!client) {
+        client = new Mistral({
+            apiKey: process.env.MISTRAL_API_KEY || '',
+        });
+    }
+    return client;
+}
+export class MistralAdapter extends BaseProviderAdapter {
+    constructor() {
+        super(...arguments);
+        this.provider = 'mistral';
+        this.roleMappings = {
+            system: ADAPTER_HANDLED,
+            user: 'user',
+            assistant: 'assistant',
+            tool: 'tool',
+            function: 'tool',
+            model: 'assistant',
+            developer: 'system',
+        };
+        // Map Mistral finish reasons to Layer finish reasons
+        this.finishReasonMappings = {
+            stop: 'completed',
+            length: 'length_limit',
+            tool_calls: 'tool_call',
+            model_length: 'length_limit',
+            error: 'error',
+        };
+        this.toolChoiceMappings = {
+            auto: 'auto',
+            none: 'none',
+            required: 'any',
+        };
+    }
+    async call(request) {
+        switch (request.type) {
+            case 'chat':
+                return this.handleChat(request);
+            case 'embeddings':
+                return this.handleEmbeddings(request);
+            case 'ocr':
+                return this.handleOCR(request);
+            case 'image':
+                throw new Error('Image generation not supported by Mistral');
+            case 'tts':
+                throw new Error('Text-to-speech not supported by Mistral');
+            case 'video':
+                throw new Error('Video generation not supported by Mistral');
+            default:
+                throw new Error(`Unknown modality: ${request.type}`);
+        }
+    }
+    async handleChat(request) {
+        const startTime = Date.now();
+        const mistral = getMistralClient();
+        const { data: chat, model } = request;
+        if (!model) {
+            throw new Error('Model is required for chat completion');
+        }
+        // Build messages array
+        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 - ensure parameters is always defined
+        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 - Mistral uses 'auto', 'none', 'any', 'required' or specific function
+        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 response = await mistral.chat.complete({
+            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,
+            }),
+        });
+        const choice = response.choices?.[0];
+        const message = choice?.message;
+        // Extract tool calls if present - normalize arguments to string
+        const toolCalls = message?.toolCalls?.map((tc) => ({
+            id: tc.id || '',
+            type: 'function',
+            function: {
+                name: tc.function?.name || '',
+                arguments: typeof tc.function?.arguments === 'string'
+                    ? tc.function.arguments
+                    : JSON.stringify(tc.function?.arguments || {}),
+            },
+        }));
+        const promptTokens = response.usage?.promptTokens || 0;
+        const completionTokens = response.usage?.completionTokens || 0;
+        const totalTokens = response.usage?.totalTokens || 0;
+        const cost = this.calculateCost(model, promptTokens, completionTokens);
+        // Extract content as string - handle ContentChunk array
+        let contentStr;
+        if (message?.content) {
+            if (typeof message.content === 'string') {
+                contentStr = message.content;
+            }
+            else if (Array.isArray(message.content)) {
+                // ContentChunk array - extract text parts
+                contentStr = message.content
+                    .map((chunk) => chunk.text || chunk.content || '')
+                    .filter(Boolean)
+                    .join('');
+            }
+        }
+        return {
+            content: contentStr || undefined,
+            toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined,
+            model: response.model || model,
+            finishReason: this.mapFinishReason(choice?.finishReason || 'stop'),
+            rawFinishReason: choice?.finishReason,
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens,
+            },
+            cost,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+    async handleEmbeddings(request) {
+        const startTime = Date.now();
+        const mistral = getMistralClient();
+        const { data: embedding, model } = request;
+        if (!model) {
+            throw new Error('Model is required for embeddings');
+        }
+        // Mistral expects 'inputs' as an array of strings
+        const inputs = Array.isArray(embedding.input) ? embedding.input : [embedding.input];
+        const response = await mistral.embeddings.create({
+            model,
+            inputs,
+        });
+        const embeddings = response.data?.map((d) => d.embedding || []) || [];
+        const promptTokens = response.usage?.promptTokens || 0;
+        const totalTokens = response.usage?.totalTokens || 0;
+        const cost = this.calculateCost(model, promptTokens, 0);
+        return {
+            embeddings,
+            model: response.model || model,
+            usage: {
+                promptTokens,
+                completionTokens: 0,
+                totalTokens,
+            },
+            cost,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+    async handleOCR(request) {
+        const startTime = Date.now();
+        const mistral = getMistralClient();
+        const { data: ocr, model } = request;
+        const ocrModel = model || 'mistral-ocr-latest';
+        let document;
+        if (ocr.documentUrl) {
+            document = {
+                type: 'document_url',
+                documentUrl: ocr.documentUrl,
+            };
+        }
+        else if (ocr.imageUrl) {
+            document = {
+                type: 'image_url',
+                imageUrl: ocr.imageUrl,
+            };
+        }
+        else if (ocr.base64) {
+            const mimeType = ocr.mimeType || 'application/pdf';
+            const isImage = mimeType.startsWith('image/');
+            if (isImage) {
+                document = {
+                    type: 'image_url',
+                    imageUrl: `data:${mimeType};base64,${ocr.base64}`,
+                };
+            }
+            else {
+                document = {
+                    type: 'document_url',
+                    documentUrl: `data:${mimeType};base64,${ocr.base64}`,
+                };
+            }
+        }
+        else {
+            throw new Error('OCR requires either documentUrl, imageUrl, or base64 input');
+        }
+        const response = await mistral.ocr.process({
+            model: ocrModel,
+            document,
+            ...(ocr.tableFormat && { tableFormat: ocr.tableFormat }),
+            ...(ocr.includeImageBase64 !== undefined && { includeImageBase64: ocr.includeImageBase64 }),
+            ...(ocr.extractHeader !== undefined && { extractHeader: ocr.extractHeader }),
+            ...(ocr.extractFooter !== undefined && { extractFooter: ocr.extractFooter }),
+        });
+        const pages = response.pages?.map((page) => ({
+            index: page.index,
+            markdown: page.markdown,
+            images: page.images,
+            tables: page.tables,
+            hyperlinks: page.hyperlinks,
+            header: page.header,
+            footer: page.footer,
+            dimensions: page.dimensions,
+        })) || [];
+        const combinedMarkdown = pages.map((p) => p.markdown).join('\n\n---\n\n');
+        return {
+            content: combinedMarkdown,
+            ocr: {
+                pages,
+                model: response.model || ocrModel,
+                documentAnnotation: response.documentAnnotation,
+                usageInfo: response.usageInfo,
+            },
+            model: response.model || ocrModel,
+            latencyMs: Date.now() - startTime,
+            raw: response,
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+//# sourceMappingURL=test-mistral-adapter.d.ts.map

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

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

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

@@ -0,0 +1,334 @@
+import 'dotenv/config';
+import { MistralAdapter } from '../mistral-adapter.js';
+const adapter = new MistralAdapter();
+// Test delay to avoid rate limits
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function testChatCompletion() {
+    console.log('--- Testing Chat Completion ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'What is the capital of France? Answer in one word.',
+                },
+            ],
+            temperature: 0.7,
+            maxTokens: 50,
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('Response:', response.content);
+    console.log('Model:', response.model);
+    console.log('Finish Reason:', response.finishReason);
+    console.log('Usage:', response.usage);
+    console.log('Latency:', response.latencyMs, 'ms');
+    console.log();
+}
+async function testChatWithSystemPrompt() {
+    console.log('--- Testing Chat with System Prompt ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            systemPrompt: 'You are a helpful assistant that responds in JSON format only.',
+            messages: [
+                {
+                    role: 'user',
+                    content: 'List 3 colors.',
+                },
+            ],
+            temperature: 0.5,
+            maxTokens: 100,
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('Response:', response.content);
+    console.log('Model:', response.model);
+    console.log();
+}
+async function testChatWithTools() {
+    console.log('--- Testing Chat with Tools ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'What is the weather in Paris today?',
+                },
+            ],
+            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 name',
+                                },
+                                unit: {
+                                    type: 'string',
+                                    enum: ['celsius', 'fahrenheit'],
+                                    description: 'Temperature unit',
+                                },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+            toolChoice: 'auto',
+            maxTokens: 200,
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('Response content:', response.content);
+    console.log('Tool calls:', JSON.stringify(response.toolCalls, null, 2));
+    console.log('Finish Reason:', response.finishReason);
+    console.log();
+}
+async function testToolResponse() {
+    console.log('--- Testing Tool Response Flow ---');
+    // First, get the tool call
+    const initialRequest = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'What is 25 multiplied by 4?',
+                },
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'calculator',
+                        description: 'Perform mathematical calculations',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                operation: {
+                                    type: 'string',
+                                    enum: ['add', 'subtract', 'multiply', 'divide'],
+                                },
+                                a: { type: 'number' },
+                                b: { type: 'number' },
+                            },
+                            required: ['operation', 'a', 'b'],
+                        },
+                    },
+                },
+            ],
+            toolChoice: 'required',
+            maxTokens: 200,
+        },
+    };
+    const initialResponse = await adapter.call(initialRequest);
+    console.log('Initial response tool calls:', JSON.stringify(initialResponse.toolCalls, null, 2));
+    if (initialResponse.toolCalls && initialResponse.toolCalls.length > 0) {
+        const toolCall = initialResponse.toolCalls[0];
+        await delay(2000);
+        const followUpRequest = {
+            gate: 'test-gate',
+            type: 'chat',
+            model: 'mistral-small-latest',
+            data: {
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'What is 25 multiplied by 4?',
+                    },
+                    {
+                        role: 'assistant',
+                        content: '',
+                        toolCalls: initialResponse.toolCalls,
+                    },
+                    {
+                        role: 'tool',
+                        content: '100',
+                        toolCallId: toolCall.id,
+                        name: toolCall.function.name,
+                    },
+                ],
+                maxTokens: 200,
+            },
+        };
+        const followUpResponse = await adapter.call(followUpRequest);
+        console.log('Follow-up response:', followUpResponse.content);
+    }
+    console.log();
+}
+async function testEmbeddings() {
+    console.log('--- Testing Embeddings ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'embeddings',
+        model: 'mistral-embed',
+        data: {
+            input: ['Hello, world!', 'How are you?'],
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('Number of embeddings:', response.embeddings?.length);
+    console.log('First embedding dimensions:', response.embeddings?.[0]?.length);
+    console.log('Usage:', response.usage);
+    console.log('Latency:', response.latencyMs, 'ms');
+    console.log();
+}
+async function testVisionCapability() {
+    console.log('--- Testing Vision Capability (Pixtral) ---');
+    // Use a public image URL for testing
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'pixtral-large-2411',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'Describe this image briefly.',
+                    images: [
+                        {
+                            url: 'https://upload.wikimedia.org/wikipedia/commons/thumb/a/a7/Camponotus_flavomarginatus_ant.jpg/320px-Camponotus_flavomarginatus_ant.jpg',
+                        },
+                    ],
+                },
+            ],
+            maxTokens: 150,
+        },
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('Vision response:', response.content);
+        console.log('Model:', response.model);
+    }
+    catch (error) {
+        console.log('Test failed (Mistral could not fetch image URL):', error.message.substring(0, 100));
+    }
+    console.log();
+}
+async function testResponseFormat() {
+    console.log('--- Testing JSON Response Format ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'List 3 programming languages with their year of creation.',
+                },
+            ],
+            responseFormat: { type: 'json_object' },
+            maxTokens: 200,
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('JSON Response:', response.content);
+    console.log();
+}
+async function testMultiTurn() {
+    console.log('--- Testing Multi-turn Conversation ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'chat',
+        model: 'mistral-small-latest',
+        data: {
+            messages: [
+                {
+                    role: 'user',
+                    content: 'My name is Alice.',
+                },
+                {
+                    role: 'assistant',
+                    content: 'Hello Alice! Nice to meet you.',
+                },
+                {
+                    role: 'user',
+                    content: 'What is my name?',
+                },
+            ],
+            maxTokens: 50,
+        },
+    };
+    const response = await adapter.call(request);
+    console.log('Response:', response.content);
+    console.log();
+}
+async function testOCR() {
+    console.log('--- Testing OCR Capability ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'ocr',
+        model: 'mistral-ocr-latest',
+        data: {
+            documentUrl: 'https://arxiv.org/pdf/2201.04234',
+        },
+    };
+    try {
+        const response = await adapter.call(request);
+        console.log('OCR Response (first 500 chars):', response.content?.substring(0, 500));
+        console.log('Model:', response.model);
+        console.log('Pages extracted:', response.ocr?.pages?.length || 0);
+        console.log('Latency:', response.latencyMs, 'ms');
+    }
+    catch (error) {
+        console.log('Test failed:', error.message);
+    }
+    console.log();
+}
+async function testUnsupportedModality() {
+    console.log('--- Testing Unsupported Modality (Image Generation) ---');
+    const request = {
+        gate: 'test-gate',
+        type: 'image',
+        model: 'mistral-large-latest',
+        data: {
+            prompt: 'A sunset over the ocean',
+        },
+    };
+    try {
+        await adapter.call(request);
+        console.log('ERROR: Should have thrown an error');
+    }
+    catch (error) {
+        console.log('Expected error:', error.message);
+    }
+    console.log();
+}
+async function runAllTests() {
+    console.log('=== Mistral Adapter Tests ===\n');
+    try {
+        await testChatCompletion();
+        await testChatWithSystemPrompt();
+        await testChatWithTools();
+        await testToolResponse();
+        await testEmbeddings();
+        await testVisionCapability();
+        await testOCR();
+        await testResponseFormat();
+        await testMultiTurn();
+        await testUnsupportedModality();
+        console.log('=== All tests completed ===');
+    }
+    catch (error) {
+        console.error('Test failed:', error);
+        process.exit(1);
+    }
+}
+runAllTests();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "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": "^0.5.0"
+    "@layer-ai/sdk": "^0.5.1"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",