@llumiverse/drivers 1.2.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

@@ -0,0 +1,121 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AnthropicClaudeOptions } from '@llumiverse/common';
+import {
+    type AIModel,
+    type Completion,
+    type CompletionChunkObject,
+    type DriverOptions,
+    type EmbeddingsOptions,
+    type EmbeddingsResult,
+    type ExecutionOptions,
+    LlumiverseError,
+    type LlumiverseErrorContext,
+    type ModelSearchPayload,
+    ModelType,
+    type PromptSegment,
+    Providers,
+} from '@llumiverse/core';
+import { AbstractDriver } from '@llumiverse/core/driver';
+import {
+    buildClaudeStreamingConversation,
+    type ClaudePrompt,
+    executeClaudeCompletion,
+    formatAnthropicLlumiverseError,
+    formatClaudeDebugPrompt,
+    formatClaudePrompt,
+    streamClaudeCompletion,
+} from '../shared/claude-messages.js';
+
+export interface AnthropicDriverOptions extends DriverOptions {
+    apiKey?: string;
+    baseURL?: string;
+}
+
+export class AnthropicDriver extends AbstractDriver<AnthropicDriverOptions, ClaudePrompt> {
+    provider = Providers.anthropic;
+    client: Anthropic;
+
+    constructor(opts: AnthropicDriverOptions) {
+        super(opts);
+        // 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, 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');
+        }
+        return executeClaudeCompletion(this.client, prompt, options);
+    }
+
+    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');
+        }
+        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,
+        );
+    }
+
+    async validateConnection(): Promise<boolean> {
+        try {
+            await this.client.models.list({ limit: 1 });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async generateEmbeddings(_opts: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        throw new LlumiverseError(
+            '[anthropic] Anthropic does not support embeddings',
+            false,
+            { provider: Providers.anthropic, model: _opts.model ?? 'unknown', operation: 'execute' },
+            undefined,
+        );
+    }
+
+    buildStreamingConversation(
+        prompt: ClaudePrompt,
+        result: unknown[],
+        toolUse: unknown[] | undefined,
+        options: ExecutionOptions,
+    ): ClaudePrompt {
+        return buildClaudeStreamingConversation(prompt, result, toolUse, options);
+    }
+
+    formatLlumiverseError(error: unknown, context: LlumiverseErrorContext): LlumiverseError {
+        return formatAnthropicLlumiverseError(error, context);
+    }
+}