@llumiverse/drivers 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llumiverse/drivers",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "LLM driver implementations. Currently supported are: openai, huggingface, bedrock, replicate.",
   "files": [
@@ -48,7 +48,7 @@
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.91.1",
+    "@anthropic-ai/sdk": "^0.96.0",
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@aws-sdk/client-bedrock": "^3.1033.0",
     "@aws-sdk/client-bedrock-runtime": "^3.1033.0",
@@ -63,9 +63,9 @@
     "@azure/identity": "^4.13.0",
     "@azure/openai": "2.0.0",
     "@google-cloud/aiplatform": "^6.5.0",
-    "@google/genai": "^1.49.0",
+    "@google/genai": "2.1.0",
     "@huggingface/inference": "4.13.11",
-    "@vertesia/api-fetch-client": "^0.82.4",
+    "@vertesia/api-fetch-client": "^1.2.0",
     "eventsource": "^4.1.0",
     "google-auth-library": "^10.6.2",
     "groq-sdk": "^0.37.0",
@@ -73,13 +73,14 @@
     "node-web-stream-adapters": "^0.2.1",
     "openai": "^6.33.0",
     "replicate": "^1.4.0",
-    "@llumiverse/core": "1.2.0",
-    "@llumiverse/common": "1.2.0"
+    "@llumiverse/common": "1.3.0",
+    "@llumiverse/core": "1.3.0"
   },
   "ts_dual_module": {
     "outDir": "lib"
   },
   "scripts": {
+    "lint": "biome lint src",
     "test": "vitest run --retry 3",
     "build": "pnpm exec tsmod build",
     "clean": "rimraf ./lib tsconfig.tsbuildinfo"

package/src/anthropic/index.ts

@@ -0,0 +1,104 @@
+import Anthropic from '@anthropic-ai/sdk';
+import type { AnthropicClaudeOptions } from "@llumiverse/common";
+import {
+    AbstractDriver,
+    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 {
+    buildClaudeStreamingConversation,
+    type ClaudePrompt,
+    executeClaudeCompletion,
+    formatAnthropicLlumiverseError,
+    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);
+        this.client = new Anthropic({ apiKey: opts.apiKey, ...(opts.baseURL ? { baseURL: opts.baseURL } : {}) });
+    }
+
+    protected formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<ClaudePrompt> {
+        return formatClaudePrompt(segments, opts);
+    }
+
+    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);
+    }
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./anthropic/index.js";
 export * from "./azure/azure_foundry.js";
 export * from "./bedrock/index.js";
 export * from "./groq/index.js";

package/src/openai/index.ts

@@ -880,21 +880,25 @@ function createAssistantMessageFromCompletion(completion: Completion): ResponseI
     return result;
 }
 
-function mapResponseStream(stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncIterable<CompletionChunkObject> {
-    const toolCallMetadata = new Map<string, { syntheticId: string, name?: string }>();
+export function mapResponseStream(stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncIterable<CompletionChunkObject> {
+    const toolCallMetadata = new Map<string, { syntheticId: string, callId?: string, name?: string }>();
 
     return {
         async *[Symbol.asyncIterator]() {
             for await (const event of stream) {
                 if (event.type === 'response.output_item.added' && event.item.type === 'function_call') {
                     const syntheticId = `tool_${event.output_index}`;
-                    const actualId = event.item.id ?? event.item.call_id;
-                    if (actualId) {
-                        toolCallMetadata.set(actualId, { syntheticId, name: event.item.name });
+                    const callId = event.item.call_id ?? event.item.id;
+                    const metadata = { syntheticId, callId, name: event.item.name };
+                    if (event.item.id) {
+                        toolCallMetadata.set(event.item.id, metadata);
+                    }
+                    if (event.item.call_id) {
+                        toolCallMetadata.set(event.item.call_id, metadata);
                     }
                     const toolUse: ToolUse & { _actual_id?: string } = {
                         id: syntheticId,
-                        _actual_id: actualId,
+                        _actual_id: callId,
                         tool_name: event.item.name,
                         tool_input: '' as any,
                     };
@@ -905,9 +909,10 @@ function mapResponseStream(stream: AsyncIterable<OpenAI.Responses.ResponseStream
                 } else if (event.type === 'response.function_call_arguments.delta') {
                     const metadata = toolCallMetadata.get(event.item_id);
                     const syntheticId = metadata?.syntheticId ?? `tool_${event.output_index}`;
+                    const callId = metadata?.callId ?? event.item_id;
                     const toolUse: ToolUse & { _actual_id?: string } = {
                         id: syntheticId,
-                        _actual_id: event.item_id,
+                        _actual_id: callId,
                         tool_name: metadata?.name ?? '',
                         tool_input: event.delta as any,
                     };
@@ -925,7 +930,7 @@ function mapResponseStream(stream: AsyncIterable<OpenAI.Responses.ResponseStream
                     const syntheticId = metadata?.syntheticId ?? `tool_${event.output_index}`;
                     const tool_name = metadata?.name ?? event.name ?? '';
                     if (event.item_id) {
-                        toolCallMetadata.set(event.item_id, { syntheticId, name: tool_name });
+                        toolCallMetadata.set(event.item_id, { syntheticId, callId: metadata?.callId, name: tool_name });
                     }
                 } else if (event.type === 'response.output_text.delta') {
                     yield {