@llumiverse/drivers 1.0.0-dev.20260224.234313Z → 1.0.0-dev.20260331.080752Z

package/src/vertexai/models/claude.ts

@@ -1,14 +1,37 @@
+import {
+    APIConnectionError,
+    APIConnectionTimeoutError,
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    ConflictError,
+    InternalServerError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    UnprocessableEntityError,
+} from '@anthropic-ai/sdk/error';
 import { ContentBlock, ContentBlockParam, DocumentBlockParam, ImageBlockParam, Message, MessageParam, TextBlockParam, ToolResultBlockParam } from "@anthropic-ai/sdk/resources/index.js";
+import { MessageStreamParams } from "@anthropic-ai/sdk/resources/index.mjs";
+import { MessageCreateParamsBase, MessageCreateParamsNonStreaming, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages.js";
 import {
-    AIModel, Completion, CompletionChunkObject, ExecutionOptions, getMaxTokensLimitVertexAi, JSONObject, ModelType,
-    PromptRole, PromptSegment, readStreamAsBase64, readStreamAsString, StatelessExecutionOptions, ToolUse, VertexAIClaudeOptions,
-    getConversationMeta, incrementConversationTurn, stripBase64ImagesFromConversation, truncateLargeTextInConversation
+    AIModel, Completion, CompletionChunkObject, ExecutionOptions,
+    getConversationMeta,
+    getMaxTokensLimitVertexAi,
+    incrementConversationTurn,
+    JSONObject,
+    LlumiverseError, LlumiverseErrorContext,
+    ModelType,
+    PromptRole, PromptSegment, readStreamAsBase64, readStreamAsString, StatelessExecutionOptions,
+    stripBase64ImagesFromConversation,
+    stripHeartbeatsFromConversation,
+    ToolUse,
+    truncateLargeTextInConversation,
+    VertexAIClaudeOptions
 } from "@llumiverse/core";
 import { asyncMap } from "@llumiverse/core/async";
 import { VertexAIDriver } from "../index.js";
 import { ModelDefinition } from "../models.js";
-import { MessageCreateParamsBase, MessageCreateParamsNonStreaming, RawMessageStreamEvent } from "@anthropic-ai/sdk/resources/messages.js";
-import { MessageStreamParams } from "@anthropic-ai/sdk/resources/index.mjs";
 
 export const ANTHROPIC_REGIONS: Record<string, string> = {
     us: "us-east5",
@@ -301,6 +324,10 @@ export class ClaudeModelDefinition implements ModelDefinition<ClaudePrompt> {
         };
         let processedConversation = stripBase64ImagesFromConversation(conversation, stripOptions);
         processedConversation = truncateLargeTextInConversation(processedConversation, stripOptions);
+        processedConversation = stripHeartbeatsFromConversation(processedConversation, {
+            keepForTurns: options.stripHeartbeatsAfterTurns ?? 1,
+            currentTurn,
+        });
 
         return {
             result: text ? [{ type: "text", value: text }] : [{ type: "text", value: '' }],
@@ -444,6 +471,170 @@ export class ClaudeModelDefinition implements ModelDefinition<ClaudePrompt> {
 
         return stream;
     }
+
+    /**
+     * Format Anthropic API errors into LlumiverseError with proper status codes and retryability.
+     * 
+     * Anthropic API errors have a specific structure:
+     * - APIError.status: HTTP status code (400, 401, 403, 404, 409, 422, 429, 500+)
+     * - APIError.error: Nested error object with type and message
+     * - APIError.requestID: Request ID for support (can be null)
+     * 
+     * Common error types:
+     * - BadRequestError (400): Invalid request parameters
+     * - AuthenticationError (401): Authentication required
+     * - PermissionDeniedError (403): Insufficient permissions
+     * - NotFoundError (404): Resource not found
+     * - ConflictError (409): Resource conflict
+     * - UnprocessableEntityError (422): Validation error
+     * - RateLimitError (429): Rate limit exceeded
+     * - InternalServerError (500+): Server-side errors
+     * - APIConnectionError: Connection issues (no status code)
+     * - APIConnectionTimeoutError: Request timeout (no status code)
+     * 
+     * @see https://docs.anthropic.com/en/api/errors
+     */
+    formatLlumiverseError(
+        _driver: VertexAIDriver,
+        error: unknown,
+        context: LlumiverseErrorContext
+    ): LlumiverseError {
+        // Check if it's an Anthropic API error
+        const isAnthropicError = this.isAnthropicApiError(error);
+
+        if (!isAnthropicError) {
+            // Not an Anthropic API error, use default handling
+            throw error;
+        }
+
+        const apiError = error as APIError;
+        const httpStatusCode = apiError.status;
+
+        // Extract error message and nested error details
+        let message = apiError.message || String(error);
+
+        // Extract error type from nested error object if available
+        let errorType: string | undefined;
+        if (apiError.error && typeof apiError.error === 'object') {
+            const nestedError = apiError.error as any;
+            if (nestedError.error && typeof nestedError.error === 'object') {
+                errorType = nestedError.error.type;
+                // Use the nested error message if it's more specific
+                if (nestedError.error.message) {
+                    message = nestedError.error.message;
+                }
+            }
+        }
+
+        // Build user-facing message with status code
+        let userMessage = message;
+
+        // Include status code in message (for end-user visibility)
+        if (httpStatusCode) {
+            userMessage = `[${httpStatusCode}] ${userMessage}`;
+        }
+
+        // Include error type if available
+        if (errorType && errorType !== 'error') {
+            userMessage = `${errorType}: ${userMessage}`;
+        }
+
+        // Add request ID if available (useful for Anthropic support)
+        if (apiError.requestID) {
+            userMessage += ` (Request ID: ${apiError.requestID})`;
+        }
+
+        // Determine retryability based on Anthropic error types
+        const retryable = this.isClaudeErrorRetryable(error, httpStatusCode, errorType);
+
+        // Use the error constructor name as the error name
+        const errorName = error.constructor?.name || 'AnthropicError';
+
+        return new LlumiverseError(
+            `[${context.provider}] ${userMessage}`,
+            retryable,
+            context,
+            error,
+            httpStatusCode,
+            errorName
+        );
+    }
+
+    /**
+     * Type guard to check if error is an Anthropic API error.
+     */
+    private isAnthropicApiError(error: unknown): error is APIError {
+        return (
+            error !== null &&
+            typeof error === 'object' &&
+            error instanceof APIError
+        );
+    }
+
+    /**
+     * Determine if an Anthropic API error is retryable.
+     * 
+     * Retryable errors:
+     * - RateLimitError (429): Rate limit exceeded, retry with backoff
+     * - InternalServerError (500+): Server-side errors
+     * - APIConnectionTimeoutError: Request timeout
+     * - 408 (Request Timeout): Request timeout
+     * - 529 (Overloaded): Service overloaded
+     * 
+     * Non-retryable errors:
+     * - BadRequestError (400): Invalid request parameters
+     * - AuthenticationError (401): Authentication failure
+     * - PermissionDeniedError (403): Insufficient permissions
+     * - NotFoundError (404): Resource not found
+     * - ConflictError (409): Resource conflict
+     * - UnprocessableEntityError (422): Validation error
+     * - Other 4xx client errors
+     * - invalid_request_error: Invalid request structure
+     * 
+     * @param error - The error object
+     * @param httpStatusCode - The HTTP status code if available
+     * @param errorType - The nested error type if available
+     * @returns True if retryable, false if not retryable, undefined if unknown
+     */
+    private isClaudeErrorRetryable(
+        error: unknown,
+        httpStatusCode: number | undefined,
+        errorType: string | undefined
+    ): boolean | undefined {
+        // Check specific Anthropic error types by class
+        if (error instanceof RateLimitError) return true;
+        if (error instanceof InternalServerError) return true;
+        if (error instanceof APIConnectionTimeoutError) return true;
+
+        // Non-retryable by error type
+        if (error instanceof BadRequestError) return false;
+        if (error instanceof AuthenticationError) return false;
+        if (error instanceof PermissionDeniedError) return false;
+        if (error instanceof NotFoundError) return false;
+        if (error instanceof ConflictError) return false;
+        if (error instanceof UnprocessableEntityError) return false;
+
+        // Check nested error type
+        if (errorType === 'invalid_request_error') return false;
+
+        // Use HTTP status code
+        if (httpStatusCode !== undefined) {
+            if (httpStatusCode === 429) return true; // Rate limit
+            if (httpStatusCode === 408) return true; // Request timeout
+            if (httpStatusCode === 529) return true; // Overloaded
+            if (httpStatusCode >= 500 && httpStatusCode < 600) return true; // Server errors
+            if (httpStatusCode >= 400 && httpStatusCode < 500) return false; // Client errors
+        }
+
+        // Connection errors without status codes
+        if (error instanceof APIConnectionError && !(error instanceof APIConnectionTimeoutError)) {
+            // Generic connection errors might be retryable (network issues)
+            return true;
+        }
+
+        // Unknown error type - let consumer decide retry strategy
+        return undefined;
+    }
 }
 
 function createPromptFromResponse(response: Message): ClaudePrompt {
@@ -679,7 +870,7 @@ function getClaudePayload(options: ExecutionOptions, prompt: ClaudePrompt): { pa
     // Fix orphaned tool_use blocks (can occur when agent is stopped mid-tool-execution)
     const fixedMessages = fixOrphanedToolUse(prompt.messages);
     // Sanitize messages to remove empty text blocks (can occur from interrupted streaming)
-    const sanitizedMessages = sanitizeMessages(fixedMessages);
+    let sanitizedMessages = sanitizeMessages(fixedMessages);
 
     // Validate tools have input_schema.type set to 'object' as required by the Anthropic SDK
     if (options.tools) {
@@ -690,10 +881,17 @@ function getClaudePayload(options: ExecutionOptions, prompt: ClaudePrompt): { pa
         }
     }
 
+    // When no tools are provided but conversation contains tool_use/tool_result blocks
+    // (e.g. checkpoint summary calls), convert tool blocks to text to avoid API errors
+    const hasTools = options.tools && options.tools.length > 0;
+    if (!hasTools && claudeMessagesContainToolBlocks(sanitizedMessages)) {
+        sanitizedMessages = convertClaudeToolBlocksToText(sanitizedMessages);
+    }
+
     const payload = {
         messages: sanitizedMessages,
         system: prompt.system,
-        tools: options.tools as MessageCreateParamsBase['tools'],
+        tools: hasTools ? options.tools as MessageCreateParamsBase['tools'] : undefined,
         temperature: model_options?.temperature,
         model: modelName,
         max_tokens: maxToken(options),
@@ -711,3 +909,71 @@ function getClaudePayload(options: ExecutionOptions, prompt: ClaudePrompt): { pa
 
     return { payload, requestOptions };
 }
+
+/**
+ * Checks whether any Claude message contains tool_use or tool_result content blocks.
+ */
+export function claudeMessagesContainToolBlocks(messages: MessageParam[]): boolean {
+    for (const msg of messages) {
+        if (!Array.isArray(msg.content)) continue;
+        for (const block of msg.content) {
+            if (typeof block === 'object' && block !== null && 'type' in block) {
+                if (block.type === 'tool_use' || block.type === 'tool_result') return true;
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Converts tool_use and tool_result blocks to text in Claude messages.
+ * Preserves tool call information while removing structured blocks that
+ * require tools to be defined in the API request.
+ */
+export function convertClaudeToolBlocksToText(messages: MessageParam[]): MessageParam[] {
+    return messages.map(msg => {
+        if (!Array.isArray(msg.content)) return msg;
+        let hasToolBlocks = false;
+        for (const block of msg.content) {
+            if (typeof block === 'object' && block !== null && 'type' in block &&
+                (block.type === 'tool_use' || block.type === 'tool_result')) {
+                hasToolBlocks = true;
+                break;
+            }
+        }
+        if (!hasToolBlocks) return msg;
+
+        const newContent: MessageParam['content'] = [];
+        for (const block of msg.content) {
+            if (typeof block === 'string') {
+                newContent.push(block);
+                continue;
+            }
+            if (block.type === 'tool_use') {
+                const inputStr = block.input ? JSON.stringify(block.input) : '';
+                const truncated = inputStr.length > 500 ? inputStr.substring(0, 500) + '...' : inputStr;
+                (newContent as Array<{ type: 'text'; text: string }>).push({
+                    type: 'text',
+                    text: `[Tool call: ${block.name}(${truncated})]`,
+                });
+            } else if (block.type === 'tool_result') {
+                let resultStr = 'No content';
+                if (typeof block.content === 'string') {
+                    resultStr = block.content.length > 500 ? block.content.substring(0, 500) + '...' : block.content;
+                } else if (Array.isArray(block.content)) {
+                    const texts = block.content
+                        .filter((c): c is { type: 'text'; text: string } => c.type === 'text')
+                        .map(c => c.text.length > 500 ? c.text.substring(0, 500) + '...' : c.text);
+                    resultStr = texts.join('\n') || 'No text content';
+                }
+                (newContent as Array<{ type: 'text'; text: string }>).push({
+                    type: 'text',
+                    text: `[Tool result: ${resultStr}]`,
+                });
+            } else {
+                newContent.push(block as any);
+            }
+        }
+        return { ...msg, content: newContent };
+    });
+}

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

@@ -0,0 +1,353 @@
+import { LlumiverseError } from '@llumiverse/core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { VertexAIDriver } from '../index.js';
+import { GeminiModelDefinition } from './gemini.js';
+
+describe('GeminiModelDefinition Error Handling', () => {
+    let driver: VertexAIDriver;
+    let modelDef: GeminiModelDefinition;
+
+    beforeEach(() => {
+        driver = new VertexAIDriver({
+            project: 'test-project',
+            region: 'us-central1',
+        });
+        modelDef = new GeminiModelDefinition('gemini-2.0-flash');
+    });
+
+    describe('formatLlumiverseError', () => {
+        it('should handle INVALID_ARGUMENT error (400)', () => {
+            const googleError = {
+                status: 400,
+                message: 'INVALID_ARGUMENT: Invalid value for temperature. Must be between 0 and 2.',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error).toBeInstanceOf(LlumiverseError);
+            expect(error.code).toBe(400);
+            expect(error.retryable).toBe(false);
+            expect(error.message).toContain('[400]');
+            expect(error.message).toContain('Invalid value for temperature');
+            expect(error.name).toBe('INVALID_ARGUMENT');
+            expect(error.context.provider).toBe('vertexai');
+        });
+
+        it('should handle UNAUTHENTICATED error (401)', () => {
+            const googleError = {
+                status: 401,
+                message: 'UNAUTHENTICATED: Request had invalid authentication credentials.',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(401);
+            expect(error.name).toBe('UNAUTHENTICATED');
+        });
+
+        it('should handle PERMISSION_DENIED error (403)', () => {
+            const googleError = {
+                status: 403,
+                message: 'PERMISSION_DENIED: The caller does not have permission to execute the specified operation.',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(403);
+            expect(error.name).toBe('PERMISSION_DENIED');
+        });
+
+        it('should handle NOT_FOUND error (404)', () => {
+            const googleError = {
+                status: 404,
+                message: 'NOT_FOUND: Requested entity was not found.',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(404);
+            expect(error.name).toBe('NOT_FOUND');
+        });
+
+        it('should handle RESOURCE_EXHAUSTED error (429) as retryable', () => {
+            const googleError = {
+                status: 429,
+                message: 'RESOURCE_EXHAUSTED: Quota exceeded for quota metric',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(429);
+            expect(error.message).toContain('[429]');
+            expect(error.name).toBe('RESOURCE_EXHAUSTED');
+        });
+
+        it('should handle INTERNAL error (500) as retryable', () => {
+            const googleError = {
+                status: 500,
+                message: 'INTERNAL: Internal server error',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(500);
+            expect(error.message).toContain('[500]');
+        });
+
+        it('should handle BAD_GATEWAY error (502) as retryable', () => {
+            const googleError = {
+                status: 502,
+                message: 'Bad gateway',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(502);
+        });
+
+        it('should handle UNAVAILABLE error (503) as retryable', () => {
+            const googleError = {
+                status: 503,
+                message: 'UNAVAILABLE: The service is currently unavailable.',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(503);
+            expect(error.name).toBe('UNAVAILABLE');
+        });
+
+        it('should handle DEADLINE_EXCEEDED error (504) as retryable', () => {
+            const googleError = {
+                status: 504,
+                message: 'DEADLINE_EXCEEDED: Request timeout',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(504);
+            expect(error.name).toBe('DEADLINE_EXCEEDED');
+        });
+
+        it('should handle REQUEST_TIMEOUT error (408) as retryable', () => {
+            const googleError = {
+                status: 408,
+                message: 'Request timeout',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(408);
+        });
+
+        it('should preserve original error for debugging', () => {
+            const googleError = {
+                status: 429,
+                message: 'RESOURCE_EXHAUSTED: Quota exceeded',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.originalError).toBe(googleError);
+            expect((error.originalError as any).status).toBe(429);
+        });
+
+        it('should throw for non-Google API errors', () => {
+            const regularError = new Error('Regular error');
+
+            expect(() => {
+                modelDef.formatLlumiverseError(driver, regularError, {
+                    provider: 'vertexai',
+                    model: 'gemini-2.0-flash',
+                    operation: 'execute',
+                });
+            }).toThrow();
+        });
+
+        it('should extract error name from bracket format', () => {
+            const googleError = {
+                status: 400,
+                message: '[INVALID_ARGUMENT] Invalid parameter',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.name).toBe('INVALID_ARGUMENT');
+        });
+
+        it('should extract error name from Error suffix format', () => {
+            const googleError = {
+                status: 400,
+                message: 'ValidationError: Invalid input',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error.name).toBe('ValidationError');
+        });
+
+        it('should handle errors without extractable name', () => {
+            const googleError = {
+                status: 500,
+                message: 'Something went wrong',
+            };
+
+            const error = modelDef.formatLlumiverseError(driver, googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            // When no name is extracted, defaults to 'LlumiverseError'
+            expect(error.name).toBe('LlumiverseError');
+            expect(error.code).toBe(500);
+        });
+    });
+
+    describe('isGeminiErrorRetryable', () => {
+        it('should classify retryable status codes correctly', () => {
+            const retryableStatusCodes = [408, 429, 500, 502, 503, 504];
+
+            retryableStatusCodes.forEach((statusCode) => {
+                const result = (modelDef as any).isGeminiErrorRetryable(statusCode);
+                expect(result, `Status code ${statusCode} should be retryable`).toBe(true);
+            });
+        });
+
+        it('should classify non-retryable status codes correctly', () => {
+            const nonRetryableStatusCodes = [400, 401, 403, 404, 409];
+
+            nonRetryableStatusCodes.forEach((statusCode) => {
+                const result = (modelDef as any).isGeminiErrorRetryable(statusCode);
+                expect(result, `Status code ${statusCode} should not be retryable`).toBe(false);
+            });
+        });
+
+        it('should classify other 5xx errors as retryable', () => {
+            expect((modelDef as any).isGeminiErrorRetryable(501)).toBe(true);
+            expect((modelDef as any).isGeminiErrorRetryable(505)).toBe(true);
+            expect((modelDef as any).isGeminiErrorRetryable(599)).toBe(true);
+        });
+
+        it('should classify other 4xx errors as non-retryable', () => {
+            expect((modelDef as any).isGeminiErrorRetryable(402)).toBe(false);
+            expect((modelDef as any).isGeminiErrorRetryable(405)).toBe(false);
+            expect((modelDef as any).isGeminiErrorRetryable(499)).toBe(false);
+        });
+    });
+
+    describe('VertexAIDriver error routing', () => {
+        it('should route to Gemini-specific error handler', () => {
+            const googleError = {
+                status: 429,
+                message: 'RESOURCE_EXHAUSTED: Quota exceeded',
+            };
+
+            const error = driver.formatLlumiverseError(googleError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error).toBeInstanceOf(LlumiverseError);
+            expect(error.code).toBe(429);
+            expect(error.retryable).toBe(true);
+            expect(error.name).toBe('RESOURCE_EXHAUSTED');
+        });
+
+        it('should fall back to default handler for non-Google errors', () => {
+            const regularError = new Error('Regular error');
+
+            const error = driver.formatLlumiverseError(regularError, {
+                provider: 'vertexai',
+                model: 'gemini-2.0-flash',
+                operation: 'execute',
+            });
+
+            expect(error).toBeInstanceOf(LlumiverseError);
+            expect(error.code).toBeUndefined();
+            expect(error.retryable).toBeUndefined(); // Unknown errors - let consumer decide
+        });
+
+        it('should work with different Gemini model versions', () => {
+            const googleError = {
+                status: 400,
+                message: 'INVALID_ARGUMENT: Invalid parameter',
+            };
+
+            const models = ['gemini-2.0-flash', 'gemini-2.5-flash', 'gemini-1.5-pro'];
+
+            models.forEach((model) => {
+                const error = driver.formatLlumiverseError(googleError, {
+                    provider: 'vertexai',
+                    model,
+                    operation: 'execute',
+                });
+
+                expect(error.code).toBe(400);
+                expect(error.retryable).toBe(false);
+            });
+        });
+    });
+});