@llumiverse/drivers 1.3.0 → 1.4.0-dev.20260629.090753Z

package/src/vertexai/models/claude-error-handling.test.ts

@@ -13,9 +13,18 @@ import {
 } from '@anthropic-ai/sdk/error';
 import { LlumiverseError } from '@llumiverse/core';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { VertexAIDriver } from '../index.js';
+import { exposePrivate } from '../../../test/__helpers__/test-utils.js';
+import type { VertexAIDriver } from '../index.js';
 import { ClaudeModelDefinition } from './claude.js';
 
+type ClaudeModelInternals = {
+    isClaudeErrorRetryable: (
+        error: unknown,
+        httpStatusCode: number | undefined,
+        errorType: string | undefined,
+    ) => boolean | undefined;
+};
+
 describe('ClaudeModelDefinition Error Handling', () => {
     let modelDef: ClaudeModelDefinition;
     let driver: VertexAIDriver;
@@ -24,8 +33,8 @@ describe('ClaudeModelDefinition Error Handling', () => {
         modelDef = new ClaudeModelDefinition('claude-haiku-4-5');
         driver = {
             provider: 'vertexai',
-            logger: { warn: () => { }, info: () => { }, error: () => { } },
-        } as any;
+            logger: { warn: () => {}, info: () => {}, error: () => {} },
+        } as unknown as VertexAIDriver;
     });
 
     describe('formatLlumiverseError', () => {
@@ -39,11 +48,11 @@ describe('ClaudeModelDefinition Error Handling', () => {
                     type: 'error',
                     error: {
                         type: 'invalid_request_error',
-                        message: 'temperature: range: 0..1'
-                    }
+                        message: 'temperature: range: 0..1',
+                    },
                 },
                 '400 {"type":"error","error":{"type":"invalid_request_error","message":"temperature: range: 0..1"},"request_id":"req_test_123"}',
-                headers
+                headers,
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -67,7 +76,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 429,
                 { type: 'error', error: { type: 'rate_limit_error', message: 'Rate limit exceeded' } },
                 'Rate limit exceeded',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -86,7 +95,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 500,
                 { type: 'error', error: { type: 'internal_error', message: 'Internal server error' } },
                 'Internal server error',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -105,7 +114,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 401,
                 { type: 'error', error: { type: 'authentication_error', message: 'Invalid API key' } },
                 'Invalid API key',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -124,7 +133,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 403,
                 { type: 'error', error: { type: 'permission_error', message: 'Insufficient permissions' } },
                 'Insufficient permissions',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -143,7 +152,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 404,
                 { type: 'error', error: { type: 'not_found_error', message: 'Model not found' } },
                 'Model not found',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -162,7 +171,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 409,
                 { type: 'error', error: { type: 'conflict_error', message: 'Resource conflict' } },
                 'Resource conflict',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -181,7 +190,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 422,
                 { type: 'error', error: { type: 'validation_error', message: 'Validation failed' } },
                 'Validation failed',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -230,11 +239,11 @@ describe('ClaudeModelDefinition Error Handling', () => {
                     type: 'error',
                     error: {
                         type: 'invalid_request_error',
-                        message: 'Missing required field'
-                    }
+                        message: 'Missing required field',
+                    },
                 },
                 'Missing required field',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -255,7 +264,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 400,
                 { type: 'error', error: { type: 'invalid_request_error', message: 'Bad request' } },
                 'Bad request',
-                headers
+                headers,
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -284,7 +293,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                 400,
                 { type: 'error', error: { type: 'invalid_request_error', message: 'Test error' } },
                 'Test error',
-                new Headers()
+                new Headers(),
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -307,7 +316,11 @@ describe('ClaudeModelDefinition Error Handling', () => {
             ];
 
             for (const error of retryableErrors) {
-                const result = (modelDef as any).isClaudeErrorRetryable(error, error.status, undefined);
+                const result = exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(
+                    error,
+                    error.status,
+                    undefined,
+                );
                 expect(result, `${error.constructor.name} should be retryable`).toBe(true);
             }
         });
@@ -322,54 +335,88 @@ describe('ClaudeModelDefinition Error Handling', () => {
             ];
 
             for (const error of nonRetryableErrors) {
-                const result = (modelDef as any).isClaudeErrorRetryable(error, error.status, undefined);
+                const result = exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(
+                    error,
+                    error.status,
+                    undefined,
+                );
                 expect(result, `${error.constructor.name} should not be retryable`).toBe(false);
             }
         });
 
         it('should use HTTP status codes when available', () => {
             const apiError = new APIError(429, {}, 'Too many requests', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError, 429, undefined)).toBe(true);
+            expect(exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError, 429, undefined)).toBe(
+                true,
+            );
 
             const apiError2 = new APIError(408, {}, 'Request timeout', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError2, 408, undefined)).toBe(true);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError2, 408, undefined),
+            ).toBe(true);
 
             const apiError3 = new APIError(529, {}, 'Overloaded', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError3, 529, undefined)).toBe(true);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError3, 529, undefined),
+            ).toBe(true);
 
             const apiError4 = new APIError(503, {}, 'Service unavailable', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError4, 503, undefined)).toBe(true);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError4, 503, undefined),
+            ).toBe(true);
         });
 
         it('should classify 4xx as non-retryable', () => {
             const apiError = new APIError(400, {}, 'Bad request', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError, 400, undefined)).toBe(false);
+            expect(exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError, 400, undefined)).toBe(
+                false,
+            );
 
             const apiError2 = new APIError(403, {}, 'Forbidden', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError2, 403, undefined)).toBe(false);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError2, 403, undefined),
+            ).toBe(false);
         });
 
         it('should classify 5xx as retryable', () => {
             const apiError = new APIError(500, {}, 'Internal error', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError, 500, undefined)).toBe(true);
+            expect(exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError, 500, undefined)).toBe(
+                true,
+            );
 
             const apiError2 = new APIError(502, {}, 'Bad gateway', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError2, 502, undefined)).toBe(true);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError2, 502, undefined),
+            ).toBe(true);
         });
 
         it('should classify invalid_request_error as non-retryable', () => {
             const apiError = new APIError(400, {}, 'Invalid request', new Headers());
-            expect((modelDef as any).isClaudeErrorRetryable(apiError, 400, 'invalid_request_error')).toBe(false);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(
+                    apiError,
+                    400,
+                    'invalid_request_error',
+                ),
+            ).toBe(false);
         });
 
         it('should classify APIConnectionError (non-timeout) as retryable', () => {
             const connectionError = new APIConnectionError({ message: 'Network failure' });
-            expect((modelDef as any).isClaudeErrorRetryable(connectionError, undefined, undefined)).toBe(true);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(
+                    connectionError,
+                    undefined,
+                    undefined,
+                ),
+            ).toBe(true);
         });
 
         it('should return undefined for unknown errors', () => {
-            const apiError = new APIError(undefined, {}, 'Unknown error', undefined as any);
-            expect((modelDef as any).isClaudeErrorRetryable(apiError, undefined, undefined)).toBeUndefined();
+            const apiError = new APIError(undefined, {}, 'Unknown error', undefined);
+            expect(
+                exposePrivate<ClaudeModelInternals>(modelDef).isClaudeErrorRetryable(apiError, undefined, undefined),
+            ).toBeUndefined();
         });
     });
 
@@ -384,11 +431,11 @@ describe('ClaudeModelDefinition Error Handling', () => {
                     type: 'error',
                     error: {
                         type: 'rate_limit_error',
-                        message: 'Rate limit exceeded'
-                    }
+                        message: 'Rate limit exceeded',
+                    },
                 },
                 'Rate limit exceeded',
-                headers
+                headers,
             );
 
             const error = modelDef.formatLlumiverseError(driver, anthropicError, {
@@ -414,7 +461,7 @@ describe('ClaudeModelDefinition Error Handling', () => {
                     400,
                     { type: 'error', error: { type: 'invalid_request_error', message: 'Invalid parameter' } },
                     'Invalid parameter',
-                    new Headers()
+                    new Headers(),
                 );
 
                 const error = modelDef.formatLlumiverseError(driver, anthropicError, {

package/src/vertexai/models/claude-streaming-spacing.test.ts

@@ -1,9 +1,10 @@
-import { ExecutionOptions } from '@llumiverse/core';
+import type { CompletionChunkObject, ExecutionOptions } from '@llumiverse/core';
 import { describe, expect, it } from 'vitest';
-import { VertexAIDriver } from '../index.js';
+import type { ClaudePrompt } from '../../shared/claude-messages.js';
+import type { VertexAIDriver } from '../index.js';
 import { ClaudeModelDefinition } from './claude.js';
 
-function createAsyncStream(events: any[]): AsyncIterable<any> {
+function createAsyncStream(events: unknown[]): AsyncIterable<unknown> {
     return (async function* () {
         for (const event of events) {
             yield event;
@@ -11,8 +12,8 @@ function createAsyncStream(events: any[]): AsyncIterable<any> {
     })();
 }
 
-async function collectChunks(stream: AsyncIterable<any>) {
-    const chunks: any[] = [];
+async function collectChunks(stream: AsyncIterable<CompletionChunkObject>): Promise<CompletionChunkObject[]> {
+    const chunks: CompletionChunkObject[] = [];
     for await (const chunk of stream) {
         chunks.push(chunk);
     }
@@ -23,37 +24,38 @@ describe('ClaudeModelDefinition streaming spacing', () => {
     it('does not leak deferred spacing when tool use follows thinking', async () => {
         const modelDef = new ClaudeModelDefinition('claude-sonnet-4-5');
         const driver = {
-            logger: { warn: () => { }, info: () => { }, error: () => { } },
+            logger: { warn: () => {}, info: () => {}, error: () => {} },
             getAnthropicClient: async () => ({
                 messages: {
-                    stream: async () => createAsyncStream([
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'thinking_delta', thinking: 'Thinking...' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'signature_delta' },
-                        },
-                        {
-                            type: 'content_block_start',
-                            content_block: { type: 'tool_use', id: 'tool-1', name: 'get_weather' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'input_json_delta', partial_json: '{"city":"Paris"}' },
-                        },
-                        {
-                            type: 'content_block_stop',
-                        },
-                    ]),
+                    stream: async () =>
+                        createAsyncStream([
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'thinking_delta', thinking: 'Thinking...' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'signature_delta' },
+                            },
+                            {
+                                type: 'content_block_start',
+                                content_block: { type: 'tool_use', id: 'tool-1', name: 'get_weather' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'input_json_delta', partial_json: '{"city":"Paris"}' },
+                            },
+                            {
+                                type: 'content_block_stop',
+                            },
+                        ]),
                 },
             }),
         } as unknown as VertexAIDriver;
 
         const prompt = {
             messages: [{ role: 'user', content: [{ type: 'text', text: 'Weather?' }] }],
-        } as any;
+        } as unknown as ClaudePrompt;
 
         const options = {
             model: 'publishers/anthropic/models/claude-sonnet-4-5',
@@ -66,8 +68,11 @@ describe('ClaudeModelDefinition streaming spacing', () => {
         const stream = await modelDef.requestTextCompletionStream(driver, prompt, options);
         const chunks = await collectChunks(stream);
 
-        const textOutput = chunks.flatMap(chunk => chunk.result ?? []).map(part => part.value).join('');
-        const toolChunks = chunks.flatMap(chunk => chunk.tool_use ?? []);
+        const textOutput = chunks
+            .flatMap((chunk) => chunk.result ?? [])
+            .map((part) => part.value)
+            .join('');
+        const toolChunks = chunks.flatMap((chunk) => chunk.tool_use ?? []);
 
         expect(textOutput).toBe('Thinking...');
         expect(toolChunks).toHaveLength(2);
@@ -78,30 +83,31 @@ describe('ClaudeModelDefinition streaming spacing', () => {
     it('flushes deferred spacing into the first text delta after thinking', async () => {
         const modelDef = new ClaudeModelDefinition('claude-sonnet-4-5');
         const driver = {
-            logger: { warn: () => { }, info: () => { }, error: () => { } },
+            logger: { warn: () => {}, info: () => {}, error: () => {} },
             getAnthropicClient: async () => ({
                 messages: {
-                    stream: async () => createAsyncStream([
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'thinking_delta', thinking: 'Thinking...' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'signature_delta' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'text_delta', text: 'Answer' },
-                        },
-                    ]),
+                    stream: async () =>
+                        createAsyncStream([
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'thinking_delta', thinking: 'Thinking...' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'signature_delta' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'text_delta', text: 'Answer' },
+                            },
+                        ]),
                 },
             }),
         } as unknown as VertexAIDriver;
 
         const prompt = {
             messages: [{ role: 'user', content: [{ type: 'text', text: 'Question?' }] }],
-        } as any;
+        } as unknown as ClaudePrompt;
 
         const options = {
             model: 'publishers/anthropic/models/claude-sonnet-4-5',
@@ -114,48 +120,49 @@ describe('ClaudeModelDefinition streaming spacing', () => {
         const stream = await modelDef.requestTextCompletionStream(driver, prompt, options);
         const chunks = await collectChunks(stream);
 
-        const textParts = chunks.flatMap(chunk => chunk.result ?? []).map(part => part.value);
+        const textParts = chunks.flatMap((chunk) => chunk.result ?? []).map((part) => part.value);
         expect(textParts).toEqual(['Thinking...', '\n\nAnswer']);
     });
 
     it('does not reintroduce deferred spacing when text arrives after a tool call', async () => {
         const modelDef = new ClaudeModelDefinition('claude-sonnet-4-5');
         const driver = {
-            logger: { warn: () => { }, info: () => { }, error: () => { } },
+            logger: { warn: () => {}, info: () => {}, error: () => {} },
             getAnthropicClient: async () => ({
                 messages: {
-                    stream: async () => createAsyncStream([
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'thinking_delta', thinking: 'Thinking...' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'signature_delta' },
-                        },
-                        {
-                            type: 'content_block_start',
-                            content_block: { type: 'tool_use', id: 'tool-1', name: 'get_weather' },
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'input_json_delta', partial_json: '{"city":"Paris"}' },
-                        },
-                        {
-                            type: 'content_block_stop',
-                        },
-                        {
-                            type: 'content_block_delta',
-                            delta: { type: 'text_delta', text: 'Answer after tool' },
-                        },
-                    ]),
+                    stream: async () =>
+                        createAsyncStream([
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'thinking_delta', thinking: 'Thinking...' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'signature_delta' },
+                            },
+                            {
+                                type: 'content_block_start',
+                                content_block: { type: 'tool_use', id: 'tool-1', name: 'get_weather' },
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'input_json_delta', partial_json: '{"city":"Paris"}' },
+                            },
+                            {
+                                type: 'content_block_stop',
+                            },
+                            {
+                                type: 'content_block_delta',
+                                delta: { type: 'text_delta', text: 'Answer after tool' },
+                            },
+                        ]),
                 },
             }),
         } as unknown as VertexAIDriver;
 
         const prompt = {
             messages: [{ role: 'user', content: [{ type: 'text', text: 'Weather?' }] }],
-        } as any;
+        } as unknown as ClaudePrompt;
 
         const options = {
             model: 'publishers/anthropic/models/claude-sonnet-4-5',
@@ -168,7 +175,7 @@ describe('ClaudeModelDefinition streaming spacing', () => {
         const stream = await modelDef.requestTextCompletionStream(driver, prompt, options);
         const chunks = await collectChunks(stream);
 
-        const textParts = chunks.flatMap(chunk => chunk.result ?? []).map(part => part.value);
+        const textParts = chunks.flatMap((chunk) => chunk.result ?? []).map((part) => part.value);
         expect(textParts).toEqual(['Thinking...', 'Answer after tool']);
     });
 });