@layer-ai/core 2.0.16 → 2.0.17

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

@@ -195,6 +195,125 @@ async function testStreamingWithTools() {
         console.log('  ⚠️  Tool calls may not have been invoked (model chose not to use tools)\n');
     }
 }
+// Test 5: Claude/Anthropic streaming
+async function testClaudeStreaming() {
+    console.log('Test 5: Claude/Anthropic Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say "claude 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('  ✅ Claude streaming test passed\n');
+}
+// Test 6: Claude with tool calls streaming
+async function testClaudeToolCallsStreaming() {
+    console.log('Test 6: Claude Tool Calls Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in Tokyo?' }
+            ],
+            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 && finishReason === 'tool_call') {
+        console.log('  ✅ Claude tool calls streaming test passed\n');
+    }
+    else {
+        console.log('  ⚠️  Tool calls may not have been invoked (model chose not to use tools)\n');
+    }
+}
+// Test 7: Multi-provider fallback with streaming (OpenAI -> Claude)
+async function testMultiProviderFallback() {
+    console.log('Test 7: Multi-Provider Fallback (OpenAI -> Claude) with Streaming');
+    console.log('-'.repeat(80));
+    const request = {
+        gateId: 'test-gate',
+        model: 'invalid-openai-model',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'Say "multi-provider fallback worked" and nothing else.' }
+            ],
+            maxTokens: 15,
+            stream: true,
+        }
+    };
+    const modelsToTry = [
+        'invalid-openai-model',
+        'claude-3-7-sonnet-20250219',
+    ];
+    let chunkCount = 0;
+    let fullContent = '';
+    let succeeded = false;
+    try {
+        for await (const chunk of executeWithFallbackStream(request, modelsToTry)) {
+            chunkCount++;
+            if (chunk.content) {
+                fullContent += chunk.content;
+            }
+        }
+        succeeded = true;
+    }
+    catch (error) {
+        console.error('  ❌ Multi-provider fallback failed:', error instanceof Error ? error.message : error);
+    }
+    if (succeeded) {
+        console.log(`  Chunks received: ${chunkCount}`);
+        console.log(`  Content: ${fullContent.trim()}`);
+        console.log('  ✅ Multi-provider fallback test passed\n');
+    }
+}
 // Run all tests
 (async () => {
     try {
@@ -202,6 +321,9 @@ async function testStreamingWithTools() {
         await testFallbackRouting();
         await testRoundRobinRouting();
         await testStreamingWithTools();
+        await testClaudeStreaming();
+        await testClaudeToolCallsStreaming();
+        await testMultiProviderFallback();
         console.log('='.repeat(80));
         console.log('✅ ALL STREAMING ROUTE TESTS PASSED');
         console.log('='.repeat(80));

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

@@ -8,6 +8,8 @@ export declare class AnthropicAdapter extends BaseProviderAdapter {
     protected finishReasonMappings: Record<string, FinishReason>;
     protected mapToolChoice(choice: ToolChoice): string | object | undefined;
     call(request: LayerRequest, userId?: string): Promise<LayerResponse>;
+    callStream(request: LayerRequest, userId?: string): AsyncIterable<LayerResponse>;
     private handleChat;
+    private handleChatStream;
 }
 //# sourceMappingURL=anthropic-adapter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"anthropic-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/anthropic-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,UAAU,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAoB1E,qBAAa,gBAAiB,SAAQ,mBAAmB;IACvD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAsB;IAElD,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAI3D;IAEF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAM1D;IAEF,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAalE,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;YAoB5D,UAAU;CA6JzB"}
+{"version":3,"file":"anthropic-adapter.d.ts","sourceRoot":"","sources":["../../../src/services/providers/anthropic-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,YAAY,EACZ,aAAa,EACb,IAAI,EACJ,YAAY,EACZ,UAAU,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAkB1E,qBAAa,gBAAiB,SAAQ,mBAAmB;IACvD,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAsB;IAElD,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAQ1C;IAEF,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAI3D;IAEF,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAM1D;IAEF,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS;IAalE,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAmBnE,UAAU,CAAC,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,aAAa,CAAC;YAYzE,UAAU;YA8JT,gBAAgB;CA0KhC"}

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

@@ -4,11 +4,9 @@ import { PROVIDER } from "../../lib/provider-constants.js";
 import { resolveApiKey } from '../../lib/key-resolver.js';
 let anthropic = null;
 function getAnthropicClient(apiKey) {
-    // If custom API key provided, create new client
     if (apiKey) {
         return new Anthropic({ apiKey });
     }
-    // Otherwise use singleton with platform key
     if (!anthropic) {
         anthropic = new Anthropic({
             apiKey: process.env.ANTHROPIC_API_KEY,
@@ -54,7 +52,6 @@ export class AnthropicAdapter extends BaseProviderAdapter {
         return super.mapToolChoice(choice);
     }
     async call(request, userId) {
-        // Resolve API key (BYOK → Platform key)
         const resolved = await resolveApiKey(this.provider, userId, process.env.ANTHROPIC_API_KEY);
         switch (request.type) {
             case 'chat':
@@ -71,6 +68,16 @@ export class AnthropicAdapter extends BaseProviderAdapter {
                 throw new Error(`Unknown modality: ${request.type}`);
         }
     }
+    async *callStream(request, userId) {
+        const resolved = await resolveApiKey(this.provider, userId, process.env.ANTHROPIC_API_KEY);
+        switch (request.type) {
+            case 'chat':
+                yield* this.handleChatStream(request, resolved.key, resolved.usedPlatformKey);
+                break;
+            default:
+                throw new Error(`Streaming not supported for type: ${request.type}`);
+        }
+    }
     async handleChat(request, apiKey, usedPlatformKey) {
         const startTime = Date.now();
         const client = getAnthropicClient(apiKey);
@@ -215,4 +222,157 @@ export class AnthropicAdapter extends BaseProviderAdapter {
             raw: response,
         };
     }
+    async *handleChatStream(request, apiKey, usedPlatformKey) {
+        const startTime = Date.now();
+        const client = getAnthropicClient(apiKey);
+        const { data: chat, model } = request;
+        if (!model) {
+            throw new Error('Model is required for chat completions');
+        }
+        const systemPrompt = chat.systemPrompt || undefined;
+        const messages = [];
+        for (const msg of chat.messages) {
+            if (msg.role === 'system')
+                continue;
+            const role = this.mapRole(msg.role);
+            if (msg.toolCallId) {
+                messages.push({
+                    role: 'user',
+                    content: [{
+                            type: 'tool_result',
+                            tool_use_id: msg.toolCallId,
+                            content: msg.content || '',
+                        }],
+                });
+            }
+            else if (msg.images?.length || msg.toolCalls?.length) {
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: 'text', text: msg.content });
+                }
+                if (msg.images) {
+                    for (const image of msg.images) {
+                        if (image.url) {
+                            content.push({
+                                type: 'image',
+                                source: {
+                                    type: 'url',
+                                    url: image.url,
+                                }
+                            });
+                        }
+                        else if (image.base64) {
+                            content.push({
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: image.mimeType || 'image/jpeg',
+                                    data: image.base64
+                                }
+                            });
+                        }
+                    }
+                }
+                if (msg.toolCalls) {
+                    for (const toolCall of msg.toolCalls) {
+                        content.push({
+                            type: 'tool_use',
+                            id: toolCall.id,
+                            name: toolCall.function.name,
+                            input: JSON.parse(toolCall.function.arguments),
+                        });
+                    }
+                }
+                const messageRole = msg.images?.length ? 'user' : (msg.toolCalls?.length ? 'assistant' : role);
+                messages.push({ role: messageRole, content });
+            }
+            else {
+                messages.push({
+                    role: role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        const anthropicRequest = {
+            model: model,
+            messages,
+            max_tokens: chat.maxTokens || 4096,
+            stream: true,
+            ...(systemPrompt && { system: systemPrompt }),
+            ...(chat.temperature !== undefined && { temperature: chat.temperature }),
+            ...(chat.temperature === undefined && chat.topP !== undefined && { top_p: chat.topP }),
+            ...(chat.stopSequences && { stop_sequences: chat.stopSequences }),
+            ...(chat.tools && {
+                tools: chat.tools.map(tool => ({
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    input_schema: tool.function.parameters || { type: 'object', properties: {} },
+                })),
+                ...(chat.toolChoice && { tool_choice: this.mapToolChoice(chat.toolChoice) }),
+            }),
+        };
+        const stream = client.messages.stream(anthropicRequest);
+        let promptTokens = 0;
+        let completionTokens = 0;
+        let fullContent = '';
+        let currentToolCalls = [];
+        let stopReason = null;
+        for await (const event of stream) {
+            if (event.type === 'content_block_start') {
+                const block = event.content_block;
+                if (block.type === 'tool_use') {
+                    currentToolCalls.push({
+                        id: block.id,
+                        type: 'function',
+                        function: {
+                            name: block.name,
+                            arguments: '',
+                        },
+                    });
+                }
+            }
+            else if (event.type === 'content_block_delta') {
+                const delta = event.delta;
+                if (delta.type === 'text_delta') {
+                    fullContent += delta.text;
+                    yield {
+                        content: delta.text,
+                        model: model,
+                        stream: true,
+                    };
+                }
+                else if (delta.type === 'input_json_delta') {
+                    if (currentToolCalls.length > 0) {
+                        const lastToolCall = currentToolCalls[currentToolCalls.length - 1];
+                        lastToolCall.function.arguments += delta.partial_json;
+                    }
+                }
+            }
+            else if (event.type === 'message_start') {
+                promptTokens = event.message.usage.input_tokens;
+            }
+            else if (event.type === 'message_delta') {
+                completionTokens = event.usage.output_tokens;
+                stopReason = event.delta.stop_reason || stopReason;
+            }
+        }
+        const cost = this.calculateCost(model, promptTokens, completionTokens);
+        const latencyMs = Date.now() - startTime;
+        yield {
+            content: '',
+            model: model,
+            toolCalls: currentToolCalls.length > 0 ? currentToolCalls : undefined,
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+            },
+            cost,
+            latencyMs,
+            usedPlatformKey,
+            stream: true,
+            finishReason: this.mapFinishReason(stopReason || 'end_turn'),
+            rawFinishReason: stopReason || undefined,
+        };
+    }
 }

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

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

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

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

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

@@ -0,0 +1,139 @@
+import { AnthropicAdapter } from '../anthropic-adapter.js';
+const adapter = new AnthropicAdapter();
+async function testChatStreamingBasic() {
+    console.log('Testing basic chat streaming...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'claude-3-7-sonnet-20250219',
+        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: 'claude-3-7-sonnet-20250219',
+        type: 'chat',
+        data: {
+            messages: [
+                { role: 'user', content: 'What is the weather in San Francisco?' }
+            ],
+            tools: [
+                {
+                    type: 'function',
+                    function: {
+                        name: 'get_weather',
+                        description: 'Get the current weather for a location',
+                        parameters: {
+                            type: 'object',
+                            properties: {
+                                location: {
+                                    type: 'string',
+                                    description: 'The city and state, e.g. San Francisco, CA',
+                                },
+                            },
+                            required: ['location'],
+                        },
+                    },
+                },
+            ],
+            toolChoice: 'auto',
+            stream: true,
+        }
+    };
+    if (!adapter.callStream) {
+        throw new Error('callStream method not available');
+    }
+    let toolCallsReceived = false;
+    for await (const chunk of adapter.callStream(request)) {
+        if (chunk.toolCalls && chunk.toolCalls.length > 0) {
+            console.log('Tool calls received:', JSON.stringify(chunk.toolCalls, null, 2));
+            toolCallsReceived = true;
+        }
+        if (chunk.finishReason === 'tool_call') {
+            console.log('Finish reason: tool_call');
+        }
+    }
+    if (!toolCallsReceived) {
+        console.warn('⚠️  No tool calls received (model may have chosen not to use tools)');
+    }
+    else {
+        console.log('✅ Tool calls streaming test passed\n');
+    }
+}
+async function testChatStreamingError() {
+    console.log('Testing streaming with invalid model (error handling)...');
+    const request = {
+        gateId: 'test-gate',
+        model: 'invalid-model-name-that-does-not-exist',
+        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.16",
+  "version": "2.0.17",
   "description": "Core API routes and services for Layer AI",
   "type": "module",
   "main": "./dist/index.js",