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

package/src/adobe/firefly.ts

@@ -1,4 +1,15 @@
-import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, ModelSearchPayload, PromptSegment } from "@llumiverse/core";
+import type {
+    AIModel,
+    Completion,
+    CompletionChunkObject,
+    DriverOptions,
+    EmbeddingsOptions,
+    EmbeddingsResult,
+    ExecutionOptions,
+    ModelSearchPayload,
+    PromptSegment,
+} from '@llumiverse/core';
+import { AbstractDriver } from '@llumiverse/core/driver';
 
 interface FireflyImageSource {
     url?: string;
@@ -67,7 +78,7 @@ export interface FireflyDriverOptions extends DriverOptions {
 }
 
 export class FireflyDriver extends AbstractDriver<FireflyDriverOptions> {
-    static PROVIDER = "firefly";
+    static PROVIDER = 'firefly';
     provider = FireflyDriver.PROVIDER;
 
     private readonly endpoint: string;
@@ -76,37 +87,39 @@ export class FireflyDriver extends AbstractDriver<FireflyDriverOptions> {
         super(options);
 
         if (!options.apiKey) {
-            throw new Error("No API key provided for Firefly driver");
+            throw new Error('No API key provided for Firefly driver');
         }
 
-        this.endpoint = options.endpoint || "https://firefly-api.adobe.io/v3";
+        this.endpoint = options.endpoint || 'https://firefly-api.adobe.io/v3';
     }
 
     async requestTextCompletion(_prompt: string, _options: ExecutionOptions): Promise<Completion> {
-        throw new Error("Text completion not supported by Firefly");
+        throw new Error('Text completion not supported by Firefly');
     }
 
-    async requestTextCompletionStream(_prompt: string, _options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        throw new Error("Text completion streaming not supported by Firefly");
+    async requestTextCompletionStream(
+        _prompt: string,
+        _options: ExecutionOptions,
+    ): Promise<AsyncIterable<CompletionChunkObject>> {
+        throw new Error('Text completion streaming not supported by Firefly');
     }
 
     async requestImageGeneration(segments: PromptSegment[], options: ExecutionOptions): Promise<Completion> {
         this.logger.debug(`[${this.provider}] Generating image with model ${options.model}`);
-        const prompt = segments.map(s => s.content).join("\n\n");
-
+        const prompt = segments.map((s) => s.content).join('\n\n');
 
         try {
             const payload: FireflyGenerateRequest = {
                 prompt: prompt as string,
             };
 
-            const response = await fetch(`${this.endpoint}/images/generate`, {
+            const response = await this.getDriverFetch()(`${this.endpoint}/images/generate`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     'x-api-key': this.options.apiKey,
                 },
-                body: JSON.stringify(payload)
+                body: JSON.stringify(payload),
             });
 
             if (!response.ok) {
@@ -120,27 +133,31 @@ export class FireflyDriver extends AbstractDriver<FireflyDriverOptions> {
                 return {
                     result: [],
                     error: {
-                        message: "Prompt contains denied words or blocked artists",
-                        code: "content_policy_violation"
-                    }
+                        message: 'Prompt contains denied words or blocked artists',
+                        code: 'content_policy_violation',
+                    },
                 };
             }
 
             return {
-                result: result.outputs.map(output => ({
-                    type: "image" as const,
-                    value: output.image.url
-                }))
+                result: result.outputs.map((output) => ({
+                    type: 'image' as const,
+                    value: output.image.url,
+                })),
             };
-
-        } catch (error: any) {
-            this.logger.error({ error }, "[Firefly] Image generation failed");
+        } catch (error: unknown) {
+            this.logger.error({ error }, '[Firefly] Image generation failed');
+            const generationError = error instanceof Error ? error : new Error(String(error));
+            const errorCode =
+                (error as { code?: unknown })?.code === 'content_policy_violation'
+                    ? 'content_policy_violation'
+                    : 'validation_error';
             return {
                 result: [],
                 error: {
-                    message: error.message,
-                    code: error.code || 'GENERATION_FAILED'
-                }
+                    message: generationError.message,
+                    code: errorCode,
+                },
             };
         }
     }
@@ -156,44 +173,44 @@ export class FireflyDriver extends AbstractDriver<FireflyDriverOptions> {
     async listModels(_params?: ModelSearchPayload): Promise<AIModel[]> {
         return [
             {
-                id: "firefly-v3-text-to-image",
-                name: "Firefly v3 Text to Image",
+                id: 'firefly-v3-text-to-image',
+                name: 'Firefly v3 Text to Image',
                 provider: this.provider,
-                description: "Adobe Firefly v3 text to image generation model",
-                tags: ["image-generation"]
+                description: 'Adobe Firefly v3 text to image generation model',
+                tags: ['image-generation'],
             },
             {
-                id: "firefly-v3-image-to-image",
-                name: "Firefly v3 Image to Image",
+                id: 'firefly-v3-image-to-image',
+                name: 'Firefly v3 Image to Image',
                 provider: this.provider,
-                description: "Adobe Firefly v3 image to image generation model",
-                tags: ["image-generation"]
+                description: 'Adobe Firefly v3 image to image generation model',
+                tags: ['image-generation'],
             },
             {
-                id: "firefly-v3-inpainting",
-                name: "Firefly v3 Inpainting",
+                id: 'firefly-v3-inpainting',
+                name: 'Firefly v3 Inpainting',
                 provider: this.provider,
-                description: "Adobe Firefly v3 inpainting model",
-                tags: ["image-generation"]
-            }
+                description: 'Adobe Firefly v3 inpainting model',
+                tags: ['image-generation'],
+            },
         ];
     }
 
     async validateConnection(): Promise<boolean> {
         try {
-            const response = await fetch(`${this.endpoint}/auth/validate`, {
+            const response = await this.getDriverFetch()(`${this.endpoint}/auth/validate`, {
                 headers: {
-                    'x-api-key': this.options.apiKey
-                }
+                    'x-api-key': this.options.apiKey,
+                },
             });
             return response.ok;
         } catch (error) {
-            this.logger.error({ error }, "[Firefly] Connection validation failed");
+            this.logger.error({ error }, '[Firefly] Connection validation failed');
             return false;
         }
     }
 
     async generateEmbeddings(_options: EmbeddingsOptions): Promise<EmbeddingsResult> {
-        throw new Error("Embeddings not supported by Firefly");
+        throw new Error('Embeddings not supported by Firefly');
     }
-}
+}

package/src/anthropic/index.ts

@@ -1,7 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
-import type { AnthropicClaudeOptions } from "@llumiverse/common";
+import type { AnthropicClaudeOptions } from '@llumiverse/common';
 import {
-    AbstractDriver,
     type AIModel,
     type Completion,
     type CompletionChunkObject,
@@ -15,15 +14,17 @@ import {
     ModelType,
     type PromptSegment,
     Providers,
-} from "@llumiverse/core";
+} from '@llumiverse/core';
+import { AbstractDriver } from '@llumiverse/core/driver';
 import {
     buildClaudeStreamingConversation,
     type ClaudePrompt,
     executeClaudeCompletion,
     formatAnthropicLlumiverseError,
+    formatClaudeDebugPrompt,
     formatClaudePrompt,
     streamClaudeCompletion,
-} from "../shared/claude-messages.js";
+} from '../shared/claude-messages.js';
 
 export interface AnthropicDriverOptions extends DriverOptions {
     apiKey?: string;
@@ -31,44 +32,60 @@ export interface AnthropicDriverOptions extends DriverOptions {
 }
 
 export class AnthropicDriver extends AbstractDriver<AnthropicDriverOptions, ClaudePrompt> {
-
     provider = Providers.anthropic;
     client: Anthropic;
 
     constructor(opts: AnthropicDriverOptions) {
         super(opts);
-        this.client = new Anthropic({ apiKey: opts.apiKey, ...(opts.baseURL ? { baseURL: opts.baseURL } : {}) });
+        // Route requests through the driver's HTTP agent (configured by
+        // opts.httpTimeout) so a hung upstream surfaces in seconds rather
+        // than blocking on Node's 5-minute undici default.
+        this.client = new Anthropic({
+            apiKey: opts.apiKey,
+            ...(opts.baseURL ? { baseURL: opts.baseURL } : {}),
+            fetch: this.getDriverFetch(),
+        });
     }
 
     protected formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<ClaudePrompt> {
-        return formatClaudePrompt(segments, opts);
+        return formatClaudePrompt(segments, opts, this.logger);
+    }
+
+    public formatDebugPrompt(prompt: ClaudePrompt): ClaudePrompt {
+        return formatClaudeDebugPrompt(prompt);
     }
 
     async requestTextCompletion(prompt: ClaudePrompt, options: ExecutionOptions): Promise<Completion> {
         const model_options = options.model_options as AnthropicClaudeOptions | undefined;
-        if (model_options?._option_id !== undefined && model_options?._option_id !== "anthropic-claude") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        if (model_options?._option_id !== undefined && model_options?._option_id !== 'anthropic-claude') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         return executeClaudeCompletion(this.client, prompt, options);
     }
 
-    async requestTextCompletionStream(prompt: ClaudePrompt, options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
+    async requestTextCompletionStream(
+        prompt: ClaudePrompt,
+        options: ExecutionOptions,
+    ): Promise<AsyncIterable<CompletionChunkObject>> {
         const model_options = options.model_options as AnthropicClaudeOptions | undefined;
-        if (model_options?._option_id !== undefined && model_options?._option_id !== "anthropic-claude") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        if (model_options?._option_id !== undefined && model_options?._option_id !== 'anthropic-claude') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         return streamClaudeCompletion(this.client, prompt, options);
     }
 
     async listModels(_params?: ModelSearchPayload): Promise<AIModel[]> {
         const page = await this.client.models.list({ limit: 1000 });
-        return page.data.map((m) => ({
-            id: m.id,
-            name: m.display_name ?? m.id,
-            provider: Providers.anthropic,
-            type: ModelType.Text,
-            can_stream: true,
-        } satisfies AIModel));
+        return page.data.map(
+            (m) =>
+                ({
+                    id: m.id,
+                    name: m.display_name ?? m.id,
+                    provider: Providers.anthropic,
+                    type: ModelType.Text,
+                    can_stream: true,
+                }) satisfies AIModel,
+        );
     }
 
     async validateConnection(): Promise<boolean> {
@@ -93,7 +110,7 @@ export class AnthropicDriver extends AbstractDriver<AnthropicDriverOptions, Clau
         prompt: ClaudePrompt,
         result: unknown[],
         toolUse: unknown[] | undefined,
-        options: ExecutionOptions
+        options: ExecutionOptions,
     ): ClaudePrompt {
         return buildClaudeStreamingConversation(prompt, result, toolUse, options);
     }