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

package/lib/types/vertexai/models/gemini.d.ts

@@ -1,5 +1,5 @@
 import { Content, GenerateContentResponseUsageMetadata } from "@google/genai";
-import { AIModel, Completion, CompletionChunkObject, ExecutionOptions, ExecutionTokenUsage, PromptSegment } from "@llumiverse/core";
+import { AIModel, Completion, CompletionChunkObject, ExecutionOptions, ExecutionTokenUsage, LlumiverseError, LlumiverseErrorContext, PromptSegment } from "@llumiverse/core";
 import { GenerateContentPrompt, VertexAIDriver } from "../index.js";
 import { ModelDefinition } from "../models.js";
 export declare function mergeConsecutiveRole(contents: Content[] | undefined): Content[];
@@ -14,5 +14,65 @@ export declare class GeminiModelDefinition implements ModelDefinition<GenerateCo
     usageMetadataToTokenUsage(usageMetadata: GenerateContentResponseUsageMetadata | undefined): ExecutionTokenUsage;
     requestTextCompletion(driver: VertexAIDriver, prompt: GenerateContentPrompt, options: ExecutionOptions): Promise<Completion>;
     requestTextCompletionStream(driver: VertexAIDriver, prompt: GenerateContentPrompt, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>>;
+    /**
+     * Format Google API errors into LlumiverseError with proper status codes and retryability.
+     *
+     * Google API errors follow AIP-193 standard:
+     * - ApiError.status: HTTP status code
+     * - ApiError.message: Error message
+     *
+     * Common error codes:
+     * - 400 (INVALID_ARGUMENT): Invalid request parameters
+     * - 401 (UNAUTHENTICATED): Authentication required
+     * - 403 (PERMISSION_DENIED): Insufficient permissions
+     * - 404 (NOT_FOUND): Resource not found
+     * - 429 (RESOURCE_EXHAUSTED): Rate limit/quota exceeded
+     * - 500 (INTERNAL): Internal server error
+     * - 503 (UNAVAILABLE): Service temporarily unavailable
+     * - 504 (DEADLINE_EXCEEDED): Request timeout
+     *
+     * @see https://google.aip.dev/193
+     * @see https://docs.cloud.google.com/vertex-ai/generative-ai/docs/model-reference/api-errors
+     */
+    formatLlumiverseError(_driver: VertexAIDriver, error: unknown, context: LlumiverseErrorContext): LlumiverseError;
+    /**
+     * Type guard to check if error is a Google API error.
+     */
+    private isGoogleApiError;
+    /**
+     * Determine if a Google API error is retryable based on HTTP status code.
+     *
+     * Retryable errors (per Google AIP-194):
+     * - 408 (REQUEST_TIMEOUT): Request timeout
+     * - 429 (RESOURCE_EXHAUSTED): Rate limit exceeded, quota exhausted
+     * - 500 (INTERNAL): Internal server error
+     * - 502 (BAD_GATEWAY): Bad gateway
+     * - 503 (UNAVAILABLE): Service temporarily unavailable
+     * - 504 (DEADLINE_EXCEEDED): Gateway timeout
+     *
+     * Non-retryable errors:
+     * - 400 (INVALID_ARGUMENT): Invalid request parameters
+     * - 401 (UNAUTHENTICATED): Authentication required
+     * - 403 (PERMISSION_DENIED): Insufficient permissions
+     * - 404 (NOT_FOUND): Resource not found
+     * - 409 (CONFLICT): Resource conflict
+     * - Other 4xx client errors
+     *
+     * @param httpStatusCode - The HTTP status code from the API error
+     * @returns True if retryable, false if not retryable, undefined if unknown
+     */
+    private isGeminiErrorRetryable;
+    /**
+     * Extract error type name from error message.
+     * Google errors often include the error type in the message.
+     * Examples: "INVALID_ARGUMENT", "RESOURCE_EXHAUSTED", "PERMISSION_DENIED"
+     */
+    private extractErrorName;
 }
+/**
+ * Converts functionCall and functionResponse parts to text parts in Gemini Content[].
+ * Preserves tool call information while removing structured parts that require
+ * tools/toolConfig to be defined in the API request.
+ */
+export declare function convertGeminiFunctionPartsToText(contents: Content[]): Content[];
 //# sourceMappingURL=gemini.d.ts.map

package/lib/types/vertexai/models/gemini.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../../src/vertexai/models/gemini.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,OAAO,EACP,oCAAoC,EAEvC,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAoB,gBAAgB,EAC9E,mBAAmB,EAKnB,aAAa,EAMhB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAwd/C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CA2B/E;AAyDD,qBAAa,qBAAsB,YAAW,eAAe,CAAC,qBAAqB,CAAC;IAEhF,KAAK,EAAE,OAAO,CAAA;gBAEF,OAAO,EAAE,MAAM;IAU3B,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAAE;IAyBnH,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA+HjI,yBAAyB,CAAC,aAAa,EAAE,oCAAoC,GAAG,SAAS,GAAG,mBAAmB;IA0BzG,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IA6F5H,2BAA2B,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;CAyErK"}
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../../src/vertexai/models/gemini.ts"],"names":[],"mappings":"AACA,OAAO,EACH,OAAO,EACP,oCAAoC,EAMvC,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAoB,gBAAgB,EAC9E,mBAAmB,EAKK,eAAe,EAAE,sBAAsB,EAC/D,aAAa,EAOhB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AA4e/C,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS,GAAG,OAAO,EAAE,CA2B/E;AAgED,qBAAa,qBAAsB,YAAW,eAAe,CAAC,qBAAqB,CAAC;IAEhF,KAAK,EAAE,OAAO,CAAA;gBAEF,OAAO,EAAE,MAAM;IAU3B,uBAAuB,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAAE;IAyBnH,YAAY,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA+HjI,yBAAyB,CAAC,aAAa,EAAE,oCAAoC,GAAG,SAAS,GAAG,mBAAmB;IA0BzG,qBAAqB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC;IA8G5H,2BAA2B,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,qBAAqB,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC;IAiFlK;;;;;;;;;;;;;;;;;;;OAmBG;IACH,qBAAqB,CACjB,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,sBAAsB,GAChC,eAAe;IAwClB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,sBAAsB;IAgB9B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAkB3B;AAGD;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAsB/E"}

package/lib/types/vertexai/models.d.ts

@@ -1,4 +1,4 @@
-import { AIModel, Completion, PromptSegment, ExecutionOptions, CompletionChunkObject } from "@llumiverse/core";
+import { AIModel, Completion, CompletionChunkObject, ExecutionOptions, LlumiverseError, LlumiverseErrorContext, PromptSegment } from "@llumiverse/core";
 import { VertexAIDriver } from "./index.js";
 export interface ModelDefinition<PromptT = any> {
     model: AIModel;
@@ -10,6 +10,11 @@ export interface ModelDefinition<PromptT = any> {
         result: Completion;
         options: ExecutionOptions;
     };
+    /**
+     * Format provider-specific errors into standardized LlumiverseError.
+     * Optional - if not provided, VertexAIDriver will use default error handling.
+     */
+    formatLlumiverseError?(driver: VertexAIDriver, error: unknown, context: LlumiverseErrorContext): LlumiverseError;
 }
 export declare function getModelDefinition(model: string): ModelDefinition;
 //# sourceMappingURL=models.d.ts.map

package/lib/types/vertexai/models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/vertexai/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAC/G,OAAO,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,GAAG;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjH,qBAAqB,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACnH,2BAA2B,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;IACnJ,uBAAuB,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAAE,CAAC;CAC9H;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CA2BjE"}
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../src/vertexai/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,eAAe,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACxJ,OAAO,EAAE,cAAc,EAAiB,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,GAAG;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjH,qBAAqB,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;IACnH,2BAA2B,EAAE,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC;IACnJ,uBAAuB,CAAC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,gBAAgB,GAAG;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,gBAAgB,CAAA;KAAE,CAAC;IAC3H;;;OAGG;IACH,qBAAqB,CAAC,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,GAAG,eAAe,CAAC;CACpH;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CA2BjE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llumiverse/drivers",
-  "version": "1.0.0-dev.20260224.234313Z",
+  "version": "1.0.0-dev.20260331.080752Z",
   "type": "module",
   "description": "LLM driver implementations. Currently supported are: openai, huggingface, bedrock, replicate.",
   "files": [
@@ -48,8 +48,8 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
-    "@anthropic-ai/vertex-sdk": "^0.14.3",
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@anthropic-ai/vertex-sdk": "^0.14.4",
     "@aws-sdk/client-bedrock": "^3.985.0",
     "@aws-sdk/client-bedrock-runtime": "^3.985.0",
     "@aws-sdk/client-s3": "^3.985.0",
@@ -62,19 +62,19 @@
     "@azure/core-sse": "^2.3.0",
     "@azure/identity": "^4.13.0",
     "@azure/openai": "2.0.0",
-    "@google-cloud/aiplatform": "^6.4.0",
-    "@google/genai": "^1.40.0",
+    "@google-cloud/aiplatform": "^6.5.0",
+    "@google/genai": "^1.46.0",
     "@huggingface/inference": "4.13.11",
-    "@vertesia/api-fetch-client": "^0.79.3",
+    "@vertesia/api-fetch-client": "^0.82.4",
     "eventsource": "^4.1.0",
     "google-auth-library": "^10.5.0",
     "groq-sdk": "^0.37.0",
     "mnemonist": "^0.40.3",
     "node-web-stream-adapters": "^0.2.1",
-    "openai": "^6.18.0",
+    "openai": "^6.22.0",
     "replicate": "^1.4.0",
-    "@llumiverse/common": "1.0.0-dev.20260224.234313Z",
-    "@llumiverse/core": "1.0.0-dev.20260224.234313Z"
+    "@llumiverse/core": "1.0.0-dev.20260331.080752Z",
+    "@llumiverse/common": "1.0.0-dev.20260331.080752Z"
   },
   "ts_dual_module": {
     "outDir": "lib"

package/src/bedrock/converse.ts

@@ -1,39 +1,110 @@
-import { DataSource, ExecutionOptions, readStreamAsString, readStreamAsUint8Array } from "@llumiverse/core";
-import { PromptSegment, PromptRole } from "@llumiverse/core";
 import {
+    ContentBlock,
     ConversationRole,
     ConverseRequest,
     Message,
     SystemContentBlock,
-    ContentBlock,
     ToolResultContentBlock,
 } from "@aws-sdk/client-bedrock-runtime";
+import { DataSource, ExecutionOptions, PromptRole, PromptSegment, readStreamAsString, readStreamAsUint8Array } from "@llumiverse/core";
 import { parseS3UrlToUri } from "./s3.js";
 
 function roleConversion(role: PromptRole): ConversationRole {
     return role === PromptRole.assistant ? ConversationRole.ASSISTANT : ConversationRole.USER;
 }
 
-function mimeToImageType(mime: string): "png" | "jpeg" | "gif" | "webp" {
+type BedrockImageFormat = "png" | "jpeg" | "gif" | "webp";
+const BEDROCK_IMAGE_FORMATS = new Set<string>(["png", "jpeg", "gif", "webp"]);
+const mimeToImageMap: Record<string, BedrockImageFormat> = {
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+};
+function mimeToImageType(mime: string): BedrockImageFormat {
+    const mapped = mimeToImageMap[mime];
+    if (mapped) return mapped;
     if (mime.startsWith("image/")) {
-        return mime.split("/")[1] as "png" | "jpeg" | "gif" | "webp";
+        const subtype = mime.split("/")[1];
+        if (subtype && BEDROCK_IMAGE_FORMATS.has(subtype)) {
+            return subtype as BedrockImageFormat;
+        }
     }
     return "png";
 }
 
-function mimeToDocType(mime: string): "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md" {
+type BedrockDocFormat = "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+const BEDROCK_DOC_FORMATS = new Set<string>(["pdf", "csv", "doc", "docx", "xls", "xlsx", "html", "txt", "md"]);
+const mimeToDocMap: Record<string, BedrockDocFormat> = {
+    "application/pdf": "pdf",
+    "text/csv": "csv",
+    "application/msword": "doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+    "application/vnd.ms-excel": "xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+    "text/html": "html",
+    "text/plain": "txt",
+    "text/markdown": "md",
+};
+function mimeToDocType(mime: string): BedrockDocFormat {
+    // 1. Exact map lookup (handles complex MIME types like vnd.openxmlformats-*)
+    const mapped = mimeToDocMap[mime];
+    if (mapped) return mapped;
+    // 2. Fallback: extract subtype for simple application/ or text/ MIME types
     if (mime.startsWith("application/") || mime.startsWith("text/")) {
-        return mime.split("/")[1] as "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+        const subtype = mime.split("/")[1];
+        if (subtype && BEDROCK_DOC_FORMATS.has(subtype)) {
+            return subtype as BedrockDocFormat;
+        }
     }
     return "txt";
 }
-function mimeToVideoType(mime: string): "mov" | "mkv" | "mp4" | "webm" | "flv" | "mpeg" | "mpg" | "wmv" | "three_gp" {
+type BedrockVideoFormat = "mov" | "mkv" | "mp4" | "webm" | "flv" | "mpeg" | "mpg" | "wmv" | "three_gp";
+const BEDROCK_VIDEO_FORMATS = new Set<string>(["mov", "mkv", "mp4", "webm", "flv", "mpeg", "mpg", "wmv", "three_gp"]);
+const mimeToVideoMap: Record<string, BedrockVideoFormat> = {
+    "video/quicktime": "mov",
+    "video/x-matroska": "mkv",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/x-flv": "flv",
+    "video/mpeg": "mpeg",
+    "video/x-ms-wmv": "wmv",
+    "video/3gpp": "three_gp",
+};
+function mimeToVideoType(mime: string): BedrockVideoFormat {
+    const mapped = mimeToVideoMap[mime];
+    if (mapped) return mapped;
     if (mime.startsWith("video/")) {
-        return mime.split("/")[1] as "mov" | "mkv" | "mp4" | "webm" | "flv" | "mpeg" | "mpg" | "wmv" | "three_gp";
+        const subtype = mime.split("/")[1];
+        if (subtype && BEDROCK_VIDEO_FORMATS.has(subtype)) {
+            return subtype as BedrockVideoFormat;
+        }
     }
     return "mp4";
 }
 
+/**
+ * Cleans a filename to conform to Bedrock's restrictions:
+ * - Alphanumeric characters, whitespace, hyphens, parentheses, square brackets.
+ * - No more than one consecutive whitespace character.
+ * - Decodes URI components (e.g., %20 -> space).
+ */
+function cleanBedrockFilename(name: string | undefined): string | undefined {
+    if (!name) return name;
+
+    try {
+        // Decode URI components like %20
+        name = decodeURIComponent(name);
+    } catch {
+        // Ignore decoding errors
+    }
+
+    return name
+        .replace(/[^\w\s\-()[\]]/g, " ") // Replace invalid characters with space
+        .replace(/\s+/g, " ") // Collapse consecutive whitespaces
+        .trim();
+}
+
 type FileProcessingMode = 'content' | 'tool';
 
 async function processFile<T extends FileProcessingMode>(
@@ -78,7 +149,7 @@ async function processFile<T extends FileProcessingMode>(
             const documentBlock = {
                 document: {
                     format: mimeToDocType(f.mime_type),
-                    name: f.name,
+                    name: cleanBedrockFilename(f.name),
                     source: { bytes: await readStreamAsUint8Array(source) },
                 },
             };
@@ -235,6 +306,10 @@ export async function formatConversePrompt(segments: PromptSegment[], options: E
             for (const file of segment.files ?? []) {
                 toolContentBlocks.push(await processFileToToolContentBlock(file));
             }
+            // Bedrock requires at least one content block in toolResult
+            if (toolContentBlocks.length === 0) {
+                toolContentBlocks.push({ text: '[No output]' });
+            }
             messages.push({
                 content: [{
                     toolResult: {

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

@@ -0,0 +1,352 @@
+import { LlumiverseError } from '@llumiverse/core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BedrockDriver } from './index.js';
+
+describe('BedrockDriver Error Handling', () => {
+    let driver: BedrockDriver;
+
+    beforeEach(() => {
+        driver = new BedrockDriver({ region: 'us-east-1' });
+    });
+
+    describe('formatLlumiverseError', () => {
+        it('should handle ValidationException with status code in message', () => {
+            const awsError = {
+                name: 'ValidationException',
+                message: "1 validation error detected: Value '32424.0' at 'inferenceConfig.temperature' failed to satisfy constraint: Member must have value less than or equal to 1",
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 400,
+                    requestId: 'e3ed39d8-bdf5-40e6-9d2c-9a1cc8323f61',
+                    attempts: 1,
+                    totalRetryDelay: 0,
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                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('validation error detected');
+            expect(error.message).toContain('Request ID: e3ed39d8-bdf5-40e6-9d2c-9a1cc8323f61');
+            expect(error.context.provider).toBe('bedrock');
+        });
+
+        it('should handle ThrottlingException as retryable', () => {
+            const awsError = {
+                name: 'ThrottlingException',
+                message: 'The number of requests exceeds the limit',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 429,
+                    requestId: 'abc123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(429);
+            expect(error.message).toContain('[429]');
+            expect(error.message).toContain('Request ID: abc123');
+        });
+
+        it('should handle InternalServerException as retryable', () => {
+            const awsError = {
+                name: 'InternalServerException',
+                message: 'An internal server error occurred',
+                $fault: 'server',
+                $metadata: {
+                    httpStatusCode: 500,
+                    requestId: 'server-error-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(500);
+            expect(error.message).toContain('[500]');
+        });
+
+        it('should handle ServiceUnavailableException as retryable', () => {
+            const awsError = {
+                name: 'ServiceUnavailableException',
+                message: 'Service is temporarily unavailable',
+                $fault: 'server',
+                $metadata: {
+                    httpStatusCode: 503,
+                    requestId: 'unavail-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+            expect(error.code).toBe(503);
+        });
+
+        it('should handle AccessDeniedException as not retryable', () => {
+            const awsError = {
+                name: 'AccessDeniedException',
+                message: 'Access denied',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 403,
+                    requestId: 'access-denied-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(403);
+        });
+
+        it('should handle ResourceNotFoundException as not retryable', () => {
+            const awsError = {
+                name: 'ResourceNotFoundException',
+                message: 'Resource not found',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 404,
+                    requestId: 'not-found-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(404);
+        });
+
+        it('should handle ServiceQuotaExceededException as retryable', () => {
+            const awsError = {
+                name: 'ServiceQuotaExceededException',
+                message: 'Service quota exceeded',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 402,
+                    requestId: 'quota-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true);
+        });
+
+        it('should handle ConflictException as not retryable', () => {
+            const awsError = {
+                name: 'ConflictException',
+                message: 'Conflict',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 409,
+                    requestId: 'conflict-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+            expect(error.code).toBe(409);
+        });
+
+        it('should handle ResourceInUseException as not retryable', () => {
+            const awsError = {
+                name: 'ResourceInUseException',
+                message: 'Resource in use',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 400,
+                    requestId: 'in-use-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(false);
+        });
+
+        it('should handle error without status code using error name', () => {
+            const awsError = {
+                name: 'ThrottlingException',
+                message: 'Rate limited',
+                $fault: 'client',
+                $metadata: {
+                    requestId: 'no-status-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.code).toBeUndefined(); // No status code available
+            expect(error.name).toBe('ThrottlingException'); // Error name preserved
+            expect(error.retryable).toBe(true);
+            expect(error.message).not.toContain('[ThrottlingException]'); // status code format only for numbers
+            expect(error.message).toContain('Rate limited');
+        });
+
+        it('should fall back to fault type for unknown errors', () => {
+            const serverError = {
+                name: 'UnknownServerError',
+                message: 'Unknown error',
+                $fault: 'server',
+                $metadata: {
+                    httpStatusCode: 599,
+                },
+            };
+
+            const error = driver.formatLlumiverseError(serverError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.retryable).toBe(true); // 5xx is retryable
+
+            const clientError = {
+                name: 'UnknownClientError',
+                message: 'Unknown error',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 499,
+                },
+            };
+
+            const error2 = driver.formatLlumiverseError(clientError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error2.retryable).toBe(false); // 4xx is not retryable
+        });
+
+        it('should handle non-AWS errors by delegating to parent', () => {
+            const regularError = new Error('Regular error');
+
+            const error = driver.formatLlumiverseError(regularError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error).toBeInstanceOf(LlumiverseError);
+            expect(error.code).toBeUndefined(); // No numeric status code available
+            expect(error.retryable).toBeUndefined(); // Unknown errors - let consumer decide
+        });
+
+        it('should preserve original error for debugging', () => {
+            const awsError = {
+                name: 'ValidationException',
+                message: 'Validation failed',
+                $fault: 'client',
+                $metadata: {
+                    httpStatusCode: 400,
+                    requestId: 'test-123',
+                },
+            };
+
+            const error = driver.formatLlumiverseError(awsError, {
+                provider: 'bedrock',
+                model: 'test-model',
+                operation: 'execute',
+            });
+
+            expect(error.originalError).toBe(awsError);
+            expect((error.originalError as any).$metadata.requestId).toBe('test-123');
+        });
+    });
+
+    describe('isBedrockErrorRetryable', () => {
+        it('should classify retryable errors correctly', () => {
+            const retryableErrors = [
+                'ThrottlingException',
+                'ServiceUnavailableException',
+                'InternalServerException',
+                'ServiceQuotaExceededException',
+            ];
+
+            retryableErrors.forEach((errorName) => {
+                const result = (driver as any).isBedrockErrorRetryable(errorName, undefined, undefined);
+                expect(result, `${errorName} should be retryable`).toBe(true);
+            });
+        });
+
+        it('should classify non-retryable errors correctly', () => {
+            const nonRetryableErrors = [
+                'ValidationException',
+                'AccessDeniedException',
+                'ResourceNotFoundException',
+                'ConflictException',
+                'ResourceInUseException',
+                'TooManyTagsException',
+            ];
+
+            nonRetryableErrors.forEach((errorName) => {
+                const result = (driver as any).isBedrockErrorRetryable(errorName, undefined, undefined);
+                expect(result, `${errorName} should not be retryable`).toBe(false);
+            });
+        });
+
+        it('should use HTTP status codes when available', () => {
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 429, undefined)).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 408, undefined)).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 529, undefined)).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 500, undefined)).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 503, undefined)).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 400, undefined)).toBe(false);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 403, undefined)).toBe(false);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', 404, undefined)).toBe(false);
+        });
+
+        it('should use fault type as fallback', () => {
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', undefined, 'server')).toBe(true);
+            expect((driver as any).isBedrockErrorRetryable('UnknownError', undefined, 'client')).toBe(false);
+        });
+    });
+});