@layer-ai/core 2.0.32 → 2.0.34

package/dist/index.d.ts

@@ -3,6 +3,7 @@ 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 messagesRouter } from './routes/v1/messages.js';
 export { default as spendingRouter } from './routes/v1/spending.js';
 export { default as completeRouter } from './routes/v2/complete.js';
 export { default as chatRouter } from './routes/v3/chat.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;AAC5D,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,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;AAGnI,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,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;AACnF,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGpE,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;AAGnI,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/index.js

@@ -4,6 +4,7 @@ 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 messagesRouter } from './routes/v1/messages.js';
 export { default as spendingRouter } from './routes/v1/spending.js';
 // v2 routes
 export { default as completeRouter } from './routes/v2/complete.js';

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

@@ -0,0 +1,15 @@
+import type { AnthropicMessageCreateParams, AnthropicMessageResponse, AnthropicMessageStreamEvent } from '@layer-ai/sdk';
+import type { LayerRequest, LayerResponse } from '@layer-ai/sdk';
+/**
+ * Convert Anthropic Messages API request to LayerRequest
+ */
+export declare function convertAnthropicRequestToLayer(anthropicReq: AnthropicMessageCreateParams, gateId: string): LayerRequest;
+/**
+ * Convert LayerResponse to Anthropic Messages API response
+ */
+export declare function convertLayerResponseToAnthropic(layerResp: LayerResponse): AnthropicMessageResponse;
+/**
+ * Convert LayerResponse stream chunks to Anthropic streaming events
+ */
+export declare function convertLayerStreamToAnthropicEvents(chunks: AsyncGenerator<LayerResponse>): AsyncGenerator<AnthropicMessageStreamEvent>;
+//# sourceMappingURL=anthropic-conversion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-conversion.d.ts","sourceRoot":"","sources":["../../src/lib/anthropic-conversion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,4BAA4B,EAI5B,wBAAwB,EACxB,2BAA2B,EAE5B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EAMd,MAAM,eAAe,CAAC;AAyHvB;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,MAAM,GACb,YAAY,CAkCd;AAkBD;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,aAAa,GACvB,wBAAwB,CAoC1B;AAeD;;GAEG;AACH,wBAAuB,mCAAmC,CACxD,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,GACpC,cAAc,CAAC,2BAA2B,CAAC,CAiJ7C"}

package/dist/lib/anthropic-conversion.js

@@ -0,0 +1,331 @@
+import { nanoid } from 'nanoid';
+/**
+ * Convert a single Anthropic message to Layer message format
+ */
+function convertAnthropicMessageToLayer(msg) {
+    // Handle string content (simple case)
+    if (typeof msg.content === 'string') {
+        return {
+            role: msg.role,
+            content: msg.content,
+        };
+    }
+    // Handle content blocks
+    let textContent = '';
+    const images = [];
+    const toolCalls = [];
+    let toolCallId;
+    for (const block of msg.content) {
+        if (block.type === 'text') {
+            textContent += (textContent ? '\n' : '') + block.text;
+        }
+        else if (block.type === 'image') {
+            if (block.source.type === 'url' && block.source.url) {
+                images.push({ url: block.source.url });
+            }
+            else if (block.source.type === 'base64' && block.source.data) {
+                images.push({
+                    base64: block.source.data,
+                    mimeType: (block.source.media_type || 'image/jpeg'),
+                });
+            }
+        }
+        else if (block.type === 'tool_use') {
+            toolCalls.push({
+                id: block.id,
+                type: 'function',
+                function: {
+                    name: block.name,
+                    arguments: JSON.stringify(block.input),
+                },
+            });
+        }
+        else if (block.type === 'tool_result') {
+            toolCallId = block.tool_use_id;
+            // Content in tool_result can be string or array
+            if (typeof block.content === 'string') {
+                textContent = block.content;
+            }
+            else if (Array.isArray(block.content)) {
+                // Extract text from content blocks
+                textContent = block.content
+                    .filter((c) => c.type === 'text')
+                    .map((c) => c.text)
+                    .join('\n');
+            }
+        }
+    }
+    return {
+        role: msg.role,
+        content: textContent || undefined,
+        images: images.length > 0 ? images : undefined,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        toolCallId,
+    };
+}
+/**
+ * Convert Anthropic tools to Layer tools
+ */
+function convertAnthropicToolsToLayer(anthropicTools) {
+    return anthropicTools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.input_schema,
+        },
+    }));
+}
+/**
+ * Convert Anthropic tool_choice to Layer tool_choice
+ */
+function convertAnthropicToolChoiceToLayer(anthropicToolChoice) {
+    if (!anthropicToolChoice)
+        return undefined;
+    if (anthropicToolChoice.type === 'auto') {
+        return 'auto';
+    }
+    else if (anthropicToolChoice.type === 'any') {
+        return 'required';
+    }
+    else if (anthropicToolChoice.type === 'tool') {
+        return {
+            type: 'function',
+            function: { name: anthropicToolChoice.name },
+        };
+    }
+    return undefined;
+}
+/**
+ * Extract system prompt from Anthropic system parameter
+ */
+function extractSystemPrompt(system) {
+    if (!system)
+        return undefined;
+    if (typeof system === 'string') {
+        return system;
+    }
+    // Array of content blocks - concatenate text blocks
+    return system
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n');
+}
+/**
+ * Convert Anthropic Messages API request to LayerRequest
+ */
+export function convertAnthropicRequestToLayer(anthropicReq, gateId) {
+    // Extract system prompt
+    const systemPrompt = extractSystemPrompt(anthropicReq.system);
+    // Convert messages
+    const messages = anthropicReq.messages.map((msg) => convertAnthropicMessageToLayer(msg));
+    // Convert tools
+    const tools = anthropicReq.tools
+        ? convertAnthropicToolsToLayer(anthropicReq.tools)
+        : undefined;
+    // Convert tool_choice
+    const toolChoice = convertAnthropicToolChoiceToLayer(anthropicReq.tool_choice);
+    return {
+        gateId,
+        type: 'chat',
+        model: anthropicReq.model,
+        data: {
+            messages,
+            systemPrompt,
+            tools,
+            toolChoice,
+            temperature: anthropicReq.temperature,
+            maxTokens: anthropicReq.max_tokens,
+            topP: anthropicReq.top_p,
+            // Note: topK is not supported in Layer's ChatRequest, Anthropic-specific parameter ignored
+            stream: anthropicReq.stream,
+            stopSequences: anthropicReq.stop_sequences,
+        },
+    };
+}
+/**
+ * Map Layer finish reason to Anthropic stop_reason
+ */
+function mapFinishReasonToAnthropic(finishReason) {
+    if (finishReason === 'length_limit') {
+        return 'max_tokens';
+    }
+    else if (finishReason === 'tool_call') {
+        return 'tool_use';
+    }
+    else if (finishReason === 'stop_sequence') {
+        return 'stop_sequence';
+    }
+    return 'end_turn';
+}
+/**
+ * Convert LayerResponse to Anthropic Messages API response
+ */
+export function convertLayerResponseToAnthropic(layerResp) {
+    const content = [];
+    // Add text content block
+    if (layerResp.content) {
+        content.push({
+            type: 'text',
+            text: layerResp.content,
+        });
+    }
+    // Add tool use blocks
+    if (layerResp.toolCalls && layerResp.toolCalls.length > 0) {
+        for (const toolCall of layerResp.toolCalls) {
+            content.push({
+                type: 'tool_use',
+                id: toolCall.id,
+                name: toolCall.function.name,
+                input: JSON.parse(toolCall.function.arguments),
+            });
+        }
+    }
+    return {
+        id: layerResp.id || `msg-${nanoid()}`,
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: layerResp.model || 'claude-3-5-sonnet-20241022',
+        stop_reason: mapFinishReasonToAnthropic(layerResp.finishReason),
+        stop_sequence: null,
+        usage: {
+            input_tokens: layerResp.usage?.promptTokens || 0,
+            output_tokens: layerResp.usage?.completionTokens || 0,
+        },
+    };
+}
+/**
+ * Convert LayerResponse stream chunks to Anthropic streaming events
+ */
+export async function* convertLayerStreamToAnthropicEvents(chunks) {
+    const state = {
+        messageId: `msg-${nanoid()}`,
+        model: 'claude-3-5-sonnet-20241022',
+        contentBlockIndex: 0,
+        hasStartedContentBlock: false,
+        currentToolCallInput: '',
+    };
+    let isFirstChunk = true;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for await (const chunk of chunks) {
+        // Update model from first chunk
+        if (chunk.model) {
+            state.model = chunk.model;
+        }
+        // First chunk: send message_start
+        if (isFirstChunk) {
+            inputTokens = chunk.usage?.promptTokens || 0;
+            yield {
+                type: 'message_start',
+                message: {
+                    id: state.messageId,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [],
+                    model: state.model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: {
+                        input_tokens: inputTokens,
+                        output_tokens: 0,
+                    },
+                },
+            };
+            isFirstChunk = false;
+        }
+        // Handle text content
+        if (chunk.content) {
+            if (!state.hasStartedContentBlock) {
+                // Start text content block
+                yield {
+                    type: 'content_block_start',
+                    index: state.contentBlockIndex,
+                    content_block: {
+                        type: 'text',
+                        text: '',
+                    },
+                };
+                state.hasStartedContentBlock = true;
+            }
+            // Send text delta
+            yield {
+                type: 'content_block_delta',
+                index: state.contentBlockIndex,
+                delta: {
+                    type: 'text_delta',
+                    text: chunk.content,
+                },
+            };
+        }
+        // Handle tool calls
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+            for (const toolCall of chunk.toolCalls) {
+                // Close previous content block if needed
+                if (state.hasStartedContentBlock) {
+                    yield {
+                        type: 'content_block_stop',
+                        index: state.contentBlockIndex,
+                    };
+                    state.contentBlockIndex++;
+                    state.hasStartedContentBlock = false;
+                }
+                // Start tool use block
+                yield {
+                    type: 'content_block_start',
+                    index: state.contentBlockIndex,
+                    content_block: {
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input: {},
+                    },
+                };
+                // Send tool input delta
+                yield {
+                    type: 'content_block_delta',
+                    index: state.contentBlockIndex,
+                    delta: {
+                        type: 'input_json_delta',
+                        partial_json: toolCall.function.arguments,
+                    },
+                };
+                // Close tool use block
+                yield {
+                    type: 'content_block_stop',
+                    index: state.contentBlockIndex,
+                };
+                state.contentBlockIndex++;
+            }
+        }
+        // Track output tokens
+        if (chunk.usage?.completionTokens) {
+            outputTokens = chunk.usage.completionTokens;
+        }
+        // Last chunk: send message_delta and message_stop
+        if (chunk.finishReason) {
+            // Close any open content block
+            if (state.hasStartedContentBlock) {
+                yield {
+                    type: 'content_block_stop',
+                    index: state.contentBlockIndex,
+                };
+            }
+            // Send message delta with stop reason
+            yield {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: mapFinishReasonToAnthropic(chunk.finishReason),
+                },
+                usage: {
+                    output_tokens: outputTokens,
+                },
+            };
+            // Send message stop
+            yield {
+                type: 'message_stop',
+            };
+        }
+    }
+}

package/dist/middleware/auth.d.ts

@@ -20,6 +20,11 @@ declare global {
  * Authorization: Bearer layer_abc123...
  */
 export declare function authenticate(req: Request, res: Response, next: NextFunction): Promise<void>;
+/**
+ * Auth middleware that supports both Layer format (Authorization: Bearer) and Anthropic format (x-api-key)
+ * Used for the /v1/messages endpoint to support Anthropic SDK clients
+ */
+export declare function authenticateAnthropicCompatible(req: Request, res: Response, next: NextFunction): Promise<void>;
 /**
  * Optional middleware for endpoints that don't require auth
  * like the health check public endpoints etc.

package/dist/middleware/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAK1D,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO,CAAC;QAChB,UAAU,OAAO;YACf,MAAM,CAAC,EAAE,MAAM,CAAC;YAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,UAAU,CAAC,EAAE,MAAM,CAAC;YACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;SACrB;KACF;CACF;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA4Jf;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,IAAI,CAWN"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/middleware/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAK1D,oBAAY,QAAQ;IAClB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO,CAAC;QAChB,UAAU,OAAO;YACf,MAAM,CAAC,EAAE,MAAM,CAAC;YAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,UAAU,CAAC,EAAE,MAAM,CAAC;YACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;SACrB;KACF;CACF;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CA4Jf;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,IAAI,CAWN"}

package/dist/middleware/auth.js

@@ -144,6 +144,30 @@ export async function authenticate(req, res, next) {
         });
     }
 }
+/**
+ * Auth middleware that supports both Layer format (Authorization: Bearer) and Anthropic format (x-api-key)
+ * Used for the /v1/messages endpoint to support Anthropic SDK clients
+ */
+export async function authenticateAnthropicCompatible(req, res, next) {
+    try {
+        // Check for x-api-key header first (Anthropic SDK format)
+        const xApiKey = req.headers['x-api-key'];
+        if (xApiKey) {
+            // Convert x-api-key to Authorization header format and process
+            req.headers.authorization = `Bearer ${xApiKey}`;
+            return authenticate(req, res, next);
+        }
+        // Fall back to standard Authorization header
+        return authenticate(req, res, next);
+    }
+    catch (error) {
+        console.error('Authentication error:', error);
+        res.status(500).json({
+            error: 'internal_error',
+            message: 'Authentication failed'
+        });
+    }
+}
 /**
  * Optional middleware for endpoints that don't require auth
  * like the health check public endpoints etc.
@@ -155,6 +179,6 @@ export function optionalAuth(req, res, next) {
         next();
         return;
     }
-    // if auth header exists, validate it 
+    // if auth header exists, validate it
     authenticate(req, res, next);
 }

package/dist/routes/tests/test-anthropic-endpoint.d.ts

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

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

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

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

@@ -0,0 +1,346 @@
+#!/usr/bin/env npx tsx
+console.log('='.repeat(80));
+console.log('ANTHROPIC MESSAGES API ENDPOINT TESTS');
+console.log('='.repeat(80));
+console.log('');
+const BASE_URL = process.env.API_URL || 'http://localhost:3001';
+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 message');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        max_tokens: 100,
+        messages: [
+            { role: 'user', content: 'Say "test passed" and nothing else.' }
+        ],
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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.content);
+    console.log('  Stop reason:', data.stop_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: 'claude-3-5-sonnet-20241022',
+        max_tokens: 100,
+        messages: [
+            { role: 'user', content: 'Say "header test passed" and nothing else.' }
+        ],
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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();
+    const textBlock = data.content.find(block => block.type === 'text');
+    console.log('  Content:', textBlock ? textBlock.text : 'No text content');
+    console.log('  ✅ Header gateId test passed\n');
+}
+async function testStreamingBasic() {
+    console.log('Test 3: Streaming basic message');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        max_tokens: 100,
+        messages: [
+            { role: 'user', content: 'Count from 1 to 3, one number per line.' }
+        ],
+        stream: true,
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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 eventCount = 0;
+    let fullContent = '';
+    let inputTokens = 0;
+    let outputTokens = 0;
+    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');
+        let currentEvent = '';
+        for (const line of lines) {
+            if (line.startsWith('event: ')) {
+                currentEvent = line.replace('event: ', '').trim();
+            }
+            else if (line.startsWith('data: ')) {
+                const data = line.replace('data: ', '').trim();
+                try {
+                    const event = JSON.parse(data);
+                    eventCount++;
+                    if (event.type === 'message_start' && 'message' in event) {
+                        inputTokens = event.message.usage.input_tokens;
+                    }
+                    else if (event.type === 'content_block_delta' && 'delta' in event) {
+                        if (event.delta.type === 'text_delta' && event.delta.text) {
+                            fullContent += event.delta.text;
+                        }
+                    }
+                    else if (event.type === 'message_delta' && 'usage' in event) {
+                        outputTokens = event.usage.output_tokens;
+                    }
+                }
+                catch (e) {
+                    // Skip invalid JSON
+                }
+            }
+        }
+    }
+    console.log('  Events received:', eventCount);
+    console.log('  Full content:', fullContent.trim());
+    console.log('  Input tokens:', inputTokens);
+    console.log('  Output tokens:', outputTokens);
+    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: 'claude-3-5-sonnet-20241022',
+        max_tokens: 1024,
+        messages: [
+            { role: 'user', content: 'What is the weather in Paris?' }
+        ],
+        tools: [
+            {
+                name: 'get_weather',
+                description: 'Get the current weather for a location',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        location: {
+                            type: 'string',
+                            description: 'The city and state, e.g. Paris, France',
+                        },
+                    },
+                    required: ['location'],
+                },
+            },
+        ],
+        tool_choice: { type: 'auto' },
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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('  Stop reason:', data.stop_reason);
+    const toolUseBlocks = data.content.filter(block => block.type === 'tool_use');
+    if (toolUseBlocks.length > 0) {
+        console.log('  Tool calls:', JSON.stringify(toolUseBlocks, 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 testWithSystemPrompt() {
+    console.log('Test 5: Message with system prompt');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        max_tokens: 100,
+        system: 'You are a pirate. Always respond in pirate speak.',
+        messages: [
+            { role: 'user', content: 'Hello, how are you?' }
+        ],
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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();
+    const textBlock = data.content.find(block => block.type === 'text');
+    const content = textBlock ? textBlock.text : 'No text content';
+    console.log('  Content:', content);
+    console.log('  ✅ System prompt test passed\n');
+}
+async function testMultiTurnConversation() {
+    console.log('Test 6: Multi-turn conversation');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        max_tokens: 100,
+        messages: [
+            { role: 'user', content: 'My name is Alice.' },
+            { role: 'assistant', content: 'Hello Alice! Nice to meet you.' },
+            { role: 'user', content: 'What is my name?' }
+        ],
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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();
+    const textBlock = data.content.find(block => block.type === 'text');
+    const content = textBlock ? textBlock.text : 'No text content';
+    console.log('  Content:', content);
+    if (content.toLowerCase().includes('alice')) {
+        console.log('  ✅ Multi-turn conversation test passed (remembered name)\n');
+    }
+    else {
+        console.log('  ⚠️  Multi-turn conversation test unclear (name not found in response)\n');
+    }
+}
+async function testTemperatureParameter() {
+    console.log('Test 7: Temperature parameter');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        max_tokens: 50,
+        temperature: 0.1,
+        messages: [
+            { role: 'user', content: 'Say "temperature test passed"' }
+        ],
+        gateId: GATE_ID,
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        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();
+    const textBlock = data.content.find(block => block.type === 'text');
+    const content = textBlock ? textBlock.text : 'No text content';
+    console.log('  Content:', content);
+    console.log('  ✅ Temperature parameter test passed\n');
+}
+async function testErrorHandlingMissingMaxTokens() {
+    console.log('Test 8: Error handling - missing max_tokens');
+    console.log('-'.repeat(80));
+    const request = {
+        model: 'claude-3-5-sonnet-20241022',
+        messages: [
+            { role: 'user', content: 'Hello' }
+        ],
+        gateId: GATE_ID,
+        // Intentionally omit max_tokens
+    };
+    const response = await fetch(`${BASE_URL}/v1/messages`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${API_KEY}`,
+        },
+        body: JSON.stringify(request),
+    });
+    if (response.ok) {
+        throw new Error('Expected error for missing max_tokens, but request succeeded');
+    }
+    const error = await response.json();
+    console.log('  Error response:', error);
+    if (error.type === 'error' && error.error.message.includes('max_tokens')) {
+        console.log('  ✅ Error handling test passed (correctly rejected missing max_tokens)\n');
+    }
+    else {
+        console.log('  ⚠️  Error handling test unclear (unexpected error format)\n');
+    }
+}
+(async () => {
+    try {
+        await testNonStreamingBasic();
+        await testNonStreamingWithGateIdInHeader();
+        await testStreamingBasic();
+        await testWithToolCalls();
+        await testWithSystemPrompt();
+        await testMultiTurnConversation();
+        await testTemperatureParameter();
+        await testErrorHandlingMissingMaxTokens();
+        console.log('='.repeat(80));
+        console.log('✅ ALL ANTHROPIC MESSAGES API ENDPOINT TESTS PASSED');
+        console.log('='.repeat(80));
+    }
+    catch (error) {
+        console.error('❌ Test failed:', error);
+        process.exit(1);
+    }
+})();
+export {};

package/dist/routes/v1/messages.d.ts

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

package/dist/routes/v1/messages.d.ts.map

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

package/dist/routes/v1/messages.js

@@ -0,0 +1,286 @@
+import { Router } from 'express';
+import { db } from '../../lib/db/postgres.js';
+import { authenticateAnthropicCompatible } from '../../middleware/auth.js';
+import { spendingTracker } from '../../lib/spending-tracker.js';
+import { convertAnthropicRequestToLayer, convertLayerResponseToAnthropic, convertLayerStreamToAnthropicEvents, } from '../../lib/anthropic-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('/', authenticateAnthropicCompatible, async (req, res) => {
+    const startTime = Date.now();
+    if (!req.userId) {
+        const error = {
+            type: 'error',
+            error: {
+                type: 'authentication_error',
+                message: 'Missing user ID',
+            },
+        };
+        res.status(401).json(error);
+        return;
+    }
+    const userId = req.userId;
+    let gateConfig = null;
+    let layerRequest = null;
+    try {
+        const anthropicReq = req.body;
+        // Extract gate ID from multiple possible sources
+        let gateId = anthropicReq.gateId || req.headers['x-layer-gate-id'];
+        // If not found in body or header, try to extract from model field
+        if (!gateId && anthropicReq.model) {
+            const modelStr = anthropicReq.model;
+            // Try to extract UUID from model field (e.g., "layer/82ab7591-..." or "layer:82ab7591-..." or just "82ab7591-...")
+            const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+            const match = modelStr.match(uuidPattern);
+            if (match) {
+                gateId = match[0];
+            }
+        }
+        if (!gateId) {
+            const error = {
+                type: 'error',
+                error: {
+                    type: 'invalid_request_error',
+                    message: 'Missing required field: gateId (provide in request body, X-Layer-Gate-Id header, or as part of model 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 = {
+                type: 'error',
+                error: {
+                    type: 'invalid_request_error',
+                    message: 'gateId must be a valid UUID',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        gateConfig = await db.getGateByUserAndId(userId, gateId);
+        if (!gateConfig) {
+            const error = {
+                type: 'error',
+                error: {
+                    type: 'not_found_error',
+                    message: `Gate with ID "${gateId}" not found`,
+                },
+            };
+            res.status(404).json(error);
+            return;
+        }
+        if (!anthropicReq.messages || !Array.isArray(anthropicReq.messages) || anthropicReq.messages.length === 0) {
+            const error = {
+                type: 'error',
+                error: {
+                    type: 'invalid_request_error',
+                    message: 'Missing required field: messages (must be a non-empty array)',
+                },
+            };
+            res.status(400).json(error);
+            return;
+        }
+        if (!anthropicReq.max_tokens) {
+            const error = {
+                type: 'error',
+                error: {
+                    type: 'invalid_request_error',
+                    message: 'Missing required field: max_tokens',
+                },
+            };
+            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/messages endpoint. Processing as chat request.`);
+        }
+        layerRequest = convertAnthropicRequestToLayer(anthropicReq, 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');
+            let promptTokens = 0;
+            let completionTokens = 0;
+            let totalCost = 0;
+            let modelUsed = finalRequest.model;
+            try {
+                const streamGenerator = executeWithRoutingStream(gateConfig, finalRequest, userId);
+                for await (const event of convertLayerStreamToAnthropicEvents(streamGenerator)) {
+                    // Track usage from message_start and message_delta events
+                    if (event.type === 'message_start' && event.message.usage) {
+                        promptTokens = event.message.usage.input_tokens;
+                    }
+                    if (event.type === 'message_delta' && event.usage) {
+                        completionTokens = event.usage.output_tokens;
+                    }
+                    if (event.type === 'message_start') {
+                        modelUsed = event.message.model;
+                    }
+                    // Write event to stream
+                    res.write(`event: ${event.type}\n`);
+                    res.write(`data: ${JSON.stringify(event)}\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));
+                spendingTracker.trackSpending(userId, totalCost).catch(err => {
+                    console.error('Failed to track spending:', err);
+                });
+            }
+            catch (streamError) {
+                const errorMessage = streamError instanceof Error ? streamError.message : 'Unknown streaming error';
+                const anthropicError = {
+                    type: 'error',
+                    error: {
+                        type: 'api_error',
+                        message: errorMessage,
+                    },
+                };
+                res.write(`event: error\n`);
+                res.write(`data: ${JSON.stringify(anthropicError)}\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));
+        spendingTracker.trackSpending(userId, result.cost || 0).catch(err => {
+            console.error('Failed to track spending:', err);
+        });
+        const anthropicResponse = convertLayerResponseToAnthropic(result);
+        res.json(anthropicResponse);
+    }
+    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('Anthropic messages error:', error);
+        const anthropicError = {
+            type: 'error',
+            error: {
+                type: 'api_error',
+                message: errorMessage,
+            },
+        };
+        res.status(500).json(anthropicError);
+    }
+});
+export default router;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layer-ai/core",
-  "version": "2.0.32",
+  "version": "2.0.34",
   "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.9"
+    "@layer-ai/sdk": "^2.5.10"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",