@llumiverse/drivers 1.3.0 → 1.4.0

package/src/openai/error-handling.test.ts

@@ -1,23 +1,32 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { BaseOpenAIDriver } from './index.js';
-import { LlumiverseError, LlumiverseErrorContext, Providers } from '@llumiverse/core';
+import { LlumiverseError, Providers } from '@llumiverse/core';
 import OpenAI from 'openai';
 import {
+    APIConnectionError,
+    APIConnectionTimeoutError,
     APIError,
-    BadRequestError,
     AuthenticationError,
-    PermissionDeniedError,
-    NotFoundError,
+    BadRequestError,
     ConflictError,
-    UnprocessableEntityError,
-    RateLimitError,
+    ContentFilterFinishReasonError,
     InternalServerError,
-    APIConnectionError,
-    APIConnectionTimeoutError,
     LengthFinishReasonError,
-    ContentFilterFinishReasonError,
-    OpenAIError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    UnprocessableEntityError,
 } from 'openai/error';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { exposePrivate, getProp } from '../../test/__helpers__/test-utils.js';
+import { BaseOpenAIDriver } from './index.js';
+
+type BaseOpenAIDriverInternals = {
+    isOpenAIErrorRetryable: (
+        error: unknown,
+        httpStatusCode: number | undefined,
+        errorCode: string | null | undefined,
+        errorType: string | undefined,
+    ) => boolean | undefined;
+};
 
 // Test implementation of BaseOpenAIDriver
 class TestOpenAIDriver extends BaseOpenAIDriver {
@@ -30,6 +39,38 @@ class TestOpenAIDriver extends BaseOpenAIDriver {
     }
 }
 
+describe('BaseOpenAIDriver usage mapping', () => {
+    it('maps Together flat cached_tokens usage into prompt_cached', () => {
+        const driver = new TestOpenAIDriver();
+        const response = {
+            status: 'completed',
+            output: [
+                {
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text: 'ok', annotations: [] }],
+                },
+            ],
+            usage: {
+                input_tokens: 100,
+                output_tokens: 20,
+                total_tokens: 120,
+                cached_tokens: 45,
+            },
+        } as unknown as OpenAI.Responses.Response;
+
+        const completion = driver.extractDataFromResponse({ model: 'test-model' }, response);
+
+        expect(completion.token_usage).toEqual({
+            prompt: 100,
+            result: 20,
+            total: 120,
+            prompt_cached: 45,
+            prompt_new: 55,
+        });
+    });
+});
+
 describe('BaseOpenAIDriver Error Handling', () => {
     let driver: TestOpenAIDriver;
 
@@ -41,20 +82,21 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should handle BadRequestError with status code and parameter', () => {
             const headers = new Headers();
             headers.set('x-request-id', 'req_test_123');
-            
+
             const openaiError = new BadRequestError(
                 400,
                 {
-                    message: "Invalid 'temperature': decimal above maximum value. Expected a value <= 2, but got 31313 instead.",
+                    message:
+                        "Invalid 'temperature': decimal above maximum value. Expected a value <= 2, but got 31313 instead.",
                     type: 'invalid_request_error',
                     param: 'temperature',
-                    code: 'decimal_above_max_value'
+                    code: 'decimal_above_max_value',
                 },
                 "Invalid 'temperature': decimal above maximum value. Expected a value <= 2, but got 31313 instead.",
-                headers
+                headers,
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -77,13 +119,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 {
                     message: 'Rate limit exceeded',
                     type: 'rate_limit_error',
-                    code: 'rate_limit_exceeded'
+                    code: 'rate_limit_exceeded',
                 },
                 'Rate limit exceeded',
-                headers
+                headers,
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -100,13 +142,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 {
                     message: 'Internal server error',
                     type: 'server_error',
-                    code: 'server_error'
+                    code: 'server_error',
                 },
                 'Internal server error',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -123,13 +165,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 {
                     message: 'Invalid API key',
                     type: 'authentication_error',
-                    code: 'invalid_api_key'
+                    code: 'invalid_api_key',
                 },
                 'Invalid API key',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -145,13 +187,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 403,
                 {
                     message: 'Insufficient permissions',
-                    type: 'permission_error'
+                    type: 'permission_error',
                 },
                 'Insufficient permissions',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -168,13 +210,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 {
                     message: 'Model not found',
                     type: 'invalid_request_error',
-                    code: 'model_not_found'
+                    code: 'model_not_found',
                 },
                 'Model not found',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-invalid',
                 operation: 'execute',
@@ -190,13 +232,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 409,
                 {
                     message: 'Resource conflict',
-                    type: 'conflict_error'
+                    type: 'conflict_error',
                 },
                 'Resource conflict',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -212,13 +254,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 422,
                 {
                     message: 'Validation failed',
-                    type: 'validation_error'
+                    type: 'validation_error',
                 },
                 'Validation failed',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -232,7 +274,7 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should handle APIConnectionTimeoutError as retryable', () => {
             const openaiError = new APIConnectionTimeoutError({ message: 'Request timed out' });
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -246,7 +288,7 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should handle APIConnectionError as retryable', () => {
             const openaiError = new APIConnectionError({ message: 'Connection failed' });
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -260,7 +302,7 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should handle LengthFinishReasonError as not retryable', () => {
             const openaiError = new LengthFinishReasonError();
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -273,7 +315,7 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should handle ContentFilterFinishReasonError as not retryable', () => {
             const openaiError = new ContentFilterFinishReasonError();
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -289,13 +331,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 400,
                 {
                     message: 'Invalid parameter',
-                    code: 'invalid_parameter'
+                    code: 'invalid_parameter',
                 },
                 'Invalid parameter',
-                headers
+                headers,
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -311,13 +353,13 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 {
                     message: 'Invalid value',
                     param: 'max_tokens',
-                    code: 'invalid_value'
+                    code: 'invalid_value',
                 },
                 'Invalid value',
-                headers
+                headers,
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -329,15 +371,10 @@ describe('BaseOpenAIDriver Error Handling', () => {
         it('should include request ID when available', () => {
             const headers = new Headers();
             headers.set('x-request-id', 'req_xyz789');
-            
-            const openaiError = new BadRequestError(
-                400,
-                { message: 'Bad request' },
-                'Bad request',
-                headers
-            );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const openaiError = new BadRequestError(400, { message: 'Bad request' }, 'Bad request', headers);
+
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -350,7 +387,7 @@ describe('BaseOpenAIDriver Error Handling', () => {
             const regularError = new Error('Regular error');
 
             expect(() => {
-                driver.formatLlumiverseError( regularError, {
+                driver.formatLlumiverseError(regularError, {
                     provider: 'openai',
                     model: 'gpt-4',
                     operation: 'execute',
@@ -359,14 +396,9 @@ describe('BaseOpenAIDriver Error Handling', () => {
         });
 
         it('should preserve original error for debugging', () => {
-            const openaiError = new BadRequestError(
-                400,
-                { message: 'Test error' },
-                'Test error',
-                new Headers()
-            );
+            const openaiError = new BadRequestError(400, { message: 'Test error' }, 'Test error', new Headers());
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -385,7 +417,12 @@ describe('BaseOpenAIDriver Error Handling', () => {
             ];
 
             for (const error of retryableErrors) {
-                const result = (driver as any).isOpenAIErrorRetryable(error, error.status, null, undefined);
+                const result = exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    error,
+                    error.status,
+                    null,
+                    undefined,
+                );
                 expect(result, `${error.constructor.name} should be retryable`).toBe(true);
             }
         });
@@ -403,83 +440,241 @@ describe('BaseOpenAIDriver Error Handling', () => {
             ];
 
             for (const error of nonRetryableErrors) {
-                const status = 'status' in error ? (error as any).status : undefined;
-                const result = (driver as any).isOpenAIErrorRetryable(error, status, null, undefined);
+                const status = getProp<number>(error, 'status');
+                const result = exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    error,
+                    status,
+                    null,
+                    undefined,
+                );
                 expect(result, `${error.constructor.name} should not be retryable`).toBe(false);
             }
         });
 
         it('should classify retryable error codes correctly', () => {
-            const apiError = new APIError(undefined as any, {}, 'Error', new Headers());
-            
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'timeout', undefined)).toBe(true);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'server_error', undefined)).toBe(true);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'service_unavailable', undefined)).toBe(true);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'rate_limit_exceeded', undefined)).toBe(true);
+            const apiError = new APIError(undefined, {}, 'Error', new Headers());
+
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'timeout',
+                    undefined,
+                ),
+            ).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'server_error',
+                    undefined,
+                ),
+            ).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'service_unavailable',
+                    undefined,
+                ),
+            ).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'rate_limit_exceeded',
+                    undefined,
+                ),
+            ).toBe(true);
         });
 
         it('should classify non-retryable error codes correctly', () => {
-            const apiError = new APIError(undefined as any, {}, 'Error', new Headers());
-            
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'invalid_api_key', undefined)).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'invalid_request_error', undefined)).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'model_not_found', undefined)).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'insufficient_quota', undefined)).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'invalid_model', undefined)).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, 'invalid_parameter', undefined)).toBe(false);
+            const apiError = new APIError(undefined, {}, 'Error', new Headers());
+
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'invalid_api_key',
+                    undefined,
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'invalid_request_error',
+                    undefined,
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'model_not_found',
+                    undefined,
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'insufficient_quota',
+                    undefined,
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'invalid_model',
+                    undefined,
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    'invalid_parameter',
+                    undefined,
+                ),
+            ).toBe(false);
         });
 
         it('should classify error types correctly', () => {
-            const apiError = new APIError(undefined as any, {}, 'Error', new Headers());
-            
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, null, 'invalid_request_error')).toBe(false);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, null, 'authentication_error')).toBe(false);
+            const apiError = new APIError(undefined, {}, 'Error', new Headers());
+
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    null,
+                    'invalid_request_error',
+                ),
+            ).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    null,
+                    'authentication_error',
+                ),
+            ).toBe(false);
         });
 
         it('should use HTTP status codes when available', () => {
             const apiError = new APIError(429, {}, 'Too many requests', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError, 429, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(apiError, 429, null, undefined),
+            ).toBe(true);
+
             const apiError2 = new APIError(408, {}, 'Request timeout', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError2, 408, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError2,
+                    408,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
+
             const apiError3 = new APIError(502, {}, 'Bad gateway', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError3, 502, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError3,
+                    502,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
+
             const apiError4 = new APIError(503, {}, 'Service unavailable', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError4, 503, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError4,
+                    503,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
+
             const apiError5 = new APIError(504, {}, 'Gateway timeout', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError5, 504, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError5,
+                    504,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
+
             const apiError6 = new APIError(529, {}, 'Overloaded', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError6, 529, null, undefined)).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError6,
+                    529,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
         });
 
         it('should classify 4xx as non-retryable', () => {
             const apiError = new APIError(400, {}, 'Bad request', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError, 400, null, undefined)).toBe(false);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(apiError, 400, null, undefined),
+            ).toBe(false);
+
             const apiError2 = new APIError(403, {}, 'Forbidden', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError2, 403, null, undefined)).toBe(false);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError2,
+                    403,
+                    null,
+                    undefined,
+                ),
+            ).toBe(false);
         });
 
         it('should classify 5xx as retryable', () => {
             const apiError = new APIError(500, {}, 'Internal error', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError, 500, null, undefined)).toBe(true);
-            
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(apiError, 500, null, undefined),
+            ).toBe(true);
+
             const apiError2 = new APIError(502, {}, 'Bad gateway', new Headers());
-            expect((driver as any).isOpenAIErrorRetryable(apiError2, 502, null, undefined)).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError2,
+                    502,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
         });
 
         it('should classify APIConnectionError (non-timeout) as retryable', () => {
             const connectionError = new APIConnectionError({ message: 'Network failure' });
-            expect((driver as any).isOpenAIErrorRetryable(connectionError, undefined, null, undefined)).toBe(true);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    connectionError,
+                    undefined,
+                    null,
+                    undefined,
+                ),
+            ).toBe(true);
         });
 
         it('should return undefined for unknown errors', () => {
-            const apiError = new APIError(undefined as any, {}, 'Unknown error', undefined as any);
-            expect((driver as any).isOpenAIErrorRetryable(apiError, undefined, null, undefined)).toBeUndefined();
+            const apiError = new APIError(undefined, {}, 'Unknown error', undefined);
+            expect(
+                exposePrivate<BaseOpenAIDriverInternals>(driver).isOpenAIErrorRetryable(
+                    apiError,
+                    undefined,
+                    null,
+                    undefined,
+                ),
+            ).toBeUndefined();
         });
     });
 
@@ -489,10 +684,10 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 429,
                 { message: 'Rate limit exceeded' },
                 'Rate limit exceeded',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'azure_openai',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -509,10 +704,10 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 400,
                 { message: 'Invalid parameter' },
                 'Invalid parameter',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'xai',
                 model: 'grok-2',
                 operation: 'execute',
@@ -529,10 +724,10 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 500,
                 { message: 'Server error' },
                 'Server error',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'azure_foundry',
                 model: 'gpt-4',
                 operation: 'execute',
@@ -549,10 +744,10 @@ describe('BaseOpenAIDriver Error Handling', () => {
                 401,
                 { message: 'Invalid API key' },
                 'Invalid API key',
-                new Headers()
+                new Headers(),
             );
 
-            const error = driver.formatLlumiverseError( openaiError, {
+            const error = driver.formatLlumiverseError(openaiError, {
                 provider: 'openai_compatible',
                 model: 'custom-model',
                 operation: 'execute',