genai-lite 0.11.0 → 0.12.0

package/dist/llm/clients/AnthropicClientAdapter.d.ts

@@ -1,4 +1,4 @@
-import type { LLMResponse, LLMFailureResponse } from "../types";
+import type { LLMResponse, LLMFailureResponse, LLMStreamEvent } from "../types";
 import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
 import type { Logger } from "../../logging/types";
 /**
@@ -33,6 +33,7 @@ export declare class AnthropicClientAdapter implements ILLMClientAdapter {
      * @returns Promise resolving to success or failure response
      */
     sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
+    streamMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): AsyncIterable<LLMStreamEvent>;
     /**
      * Validates Anthropic API key format
      *
@@ -48,6 +49,10 @@ export declare class AnthropicClientAdapter implements ILLMClientAdapter {
         name: string;
         version: string;
     };
+    private prepareMessageRequest;
+    private mapAnthropicUsage;
+    private mergeAnthropicUsage;
+    private createSyntheticMessage;
     /**
      * Recursively adds additionalProperties: false to all object schemas
      * Required by Anthropic's strict mode for structured outputs

package/dist/llm/clients/AnthropicClientAdapter.js

@@ -42,89 +42,7 @@ class AnthropicClientAdapter {
      */
     async sendMessage(request, apiKey, options) {
         try {
-            // Check if structured output is requested - need beta API
-            const useStructuredOutput = request.settings.structuredOutput?.schema &&
-                request.settings.structuredOutput.enabled !== false;
-            // Initialize Anthropic client
-            const anthropic = new sdk_1.default({
-                apiKey,
-                ...(this.baseURL && { baseURL: this.baseURL }),
-                maxRetries: 0, // retries are owned by the unified LLMService retry layer
-            });
-            // Per-request transport options (abort signal, timeout)
-            const requestTransportOptions = {
-                ...(options?.signal && { signal: options.signal }),
-                ...(options?.timeoutMs !== undefined && { timeout: options.timeoutMs }),
-            };
-            // Format messages for Anthropic API (Claude has specific requirements)
-            const { messages, systemMessage } = this.formatMessagesForAnthropic(request);
-            // Prepare API call parameters
-            const messageParams = {
-                model: request.modelId,
-                messages: messages,
-                max_tokens: request.settings.maxTokens,
-                temperature: request.settings.temperature,
-                top_p: request.settings.topP,
-                ...(request.settings.topK !== undefined && {
-                    top_k: request.settings.topK,
-                }),
-                ...(systemMessage && { system: systemMessage }),
-                ...(request.settings.stopSequences.length > 0 && {
-                    stop_sequences: request.settings.stopSequences,
-                }),
-            };
-            // Handle structured output configuration for Anthropic
-            // Note: Structured output requires the beta API endpoint
-            if (useStructuredOutput) {
-                const so = request.settings.structuredOutput;
-                // Anthropic requires additionalProperties: false on all object schemas
-                const processedSchema = so.strict !== false
-                    ? this.addAdditionalPropertiesFalse(so.schema)
-                    : so.schema;
-                // Anthropic's format: output_format.schema is the schema directly
-                messageParams.output_format = {
-                    type: 'json_schema',
-                    name: so.name,
-                    schema: processedSchema,
-                    strict: so.strict !== false,
-                };
-            }
-            // Handle reasoning/thinking configuration for Claude models
-            if (request.settings.reasoning && !request.settings.reasoning.exclude) {
-                const reasoning = request.settings.reasoning;
-                let budgetTokens;
-                // Convert reasoning settings to Anthropic's thinking format
-                if (reasoning.maxTokens !== undefined) {
-                    budgetTokens = Math.max(reasoning.maxTokens, 1024); // Minimum 1024
-                }
-                else if (reasoning.effort) {
-                    // Convert effort levels to token budgets
-                    // Max budget for Anthropic is 32000
-                    const maxBudget = 32000;
-                    switch (reasoning.effort) {
-                        case 'high':
-                            budgetTokens = Math.floor(maxBudget * 0.8);
-                            break;
-                        case 'medium':
-                            budgetTokens = Math.floor(maxBudget * 0.5);
-                            break;
-                        case 'low':
-                            budgetTokens = Math.floor(maxBudget * 0.2);
-                            break;
-                    }
-                }
-                else if (reasoning.enabled !== false) {
-                    // Use default budget
-                    budgetTokens = 10000;
-                }
-                if (budgetTokens !== undefined) {
-                    // Add thinking configuration to the request
-                    messageParams.thinking = {
-                        type: "enabled",
-                        budget_tokens: Math.min(budgetTokens, 32000) // Cap at max
-                    };
-                }
-            }
+            const { anthropic, messageParams, requestTransportOptions, useStructuredOutput, messages, } = this.prepareMessageRequest(request, apiKey, options);
             this.logger.info(`Making Anthropic API call for model: ${request.modelId}`);
             this.logger.debug(`Anthropic API parameters:`, {
                 model: messageParams.model,
@@ -163,6 +81,127 @@ class AnthropicClientAdapter {
             return this.createErrorResponse(error, request);
         }
     }
+    async *streamMessage(request, apiKey, options) {
+        const accumulator = {
+            id: "",
+            model: request.modelId,
+            created: Math.floor(Date.now() / 1000),
+            content: "",
+            reasoning: "",
+            stopReason: null,
+        };
+        let sawEvent = false;
+        let started = false;
+        try {
+            const { anthropic, messageParams, requestTransportOptions, useStructuredOutput, } = this.prepareMessageRequest(request, apiKey, options);
+            this.logger.info(`Making Anthropic streaming API call for model: ${request.modelId}`);
+            const streamOptions = useStructuredOutput
+                ? {
+                    headers: {
+                        "anthropic-beta": "structured-outputs-2025-11-13",
+                    },
+                    ...requestTransportOptions,
+                }
+                : requestTransportOptions;
+            const stream = Object.keys(streamOptions).length > 0
+                ? anthropic.messages.stream(messageParams, streamOptions)
+                : anthropic.messages.stream(messageParams);
+            for await (const event of stream) {
+                sawEvent = true;
+                if (event.type === "message_start") {
+                    accumulator.id = event.message.id || accumulator.id;
+                    accumulator.model = event.message.model || accumulator.model;
+                    accumulator.stopReason = event.message.stop_reason ?? accumulator.stopReason;
+                    accumulator.usage = this.mergeAnthropicUsage(accumulator.usage, event.message.usage);
+                    if (!started) {
+                        started = true;
+                        yield {
+                            type: "start",
+                            provider: request.providerId,
+                            model: accumulator.model,
+                            id: accumulator.id,
+                            created: accumulator.created,
+                        };
+                    }
+                    if (event.message.usage) {
+                        yield {
+                            type: "usage",
+                            usage: this.mapAnthropicUsage(accumulator.usage),
+                        };
+                    }
+                    continue;
+                }
+                if (!started) {
+                    started = true;
+                    yield {
+                        type: "start",
+                        provider: request.providerId,
+                        model: accumulator.model,
+                        id: accumulator.id,
+                        created: accumulator.created,
+                    };
+                }
+                if (event.type === "content_block_start") {
+                    const block = event.content_block;
+                    if (block?.type === "text" && typeof block.text === "string" && block.text.length > 0) {
+                        accumulator.content += block.text;
+                        yield { type: "content_delta", delta: block.text, index: event.index };
+                    }
+                    else if (block?.type === "thinking" &&
+                        typeof block.thinking === "string" &&
+                        block.thinking.length > 0) {
+                        accumulator.reasoning += block.thinking;
+                        if (request.settings.reasoning?.exclude !== true) {
+                            yield { type: "reasoning_delta", delta: block.thinking, index: event.index };
+                        }
+                    }
+                }
+                else if (event.type === "content_block_delta") {
+                    const delta = event.delta;
+                    if (delta?.type === "text_delta" && typeof delta.text === "string" && delta.text.length > 0) {
+                        accumulator.content += delta.text;
+                        yield { type: "content_delta", delta: delta.text, index: event.index };
+                    }
+                    else if (delta?.type === "thinking_delta" &&
+                        typeof delta.thinking === "string" &&
+                        delta.thinking.length > 0) {
+                        accumulator.reasoning += delta.thinking;
+                        if (request.settings.reasoning?.exclude !== true) {
+                            yield { type: "reasoning_delta", delta: delta.thinking, index: event.index };
+                        }
+                    }
+                }
+                else if (event.type === "message_delta") {
+                    accumulator.stopReason = event.delta.stop_reason ?? accumulator.stopReason;
+                    accumulator.usage = this.mergeAnthropicUsage(accumulator.usage, event.usage);
+                    if (event.usage) {
+                        yield {
+                            type: "usage",
+                            usage: this.mapAnthropicUsage(accumulator.usage),
+                        };
+                    }
+                }
+            }
+            const response = this.createSuccessResponse(this.createSyntheticMessage(request, accumulator), request);
+            yield { type: "complete", response };
+        }
+        catch (error) {
+            this.logger.error("Anthropic streaming API error:", error);
+            const errorResponse = this.createErrorResponse(error, request);
+            if (sawEvent || accumulator.content.length > 0 || accumulator.reasoning.length > 0) {
+                const partial = this.createSuccessResponse(this.createSyntheticMessage(request, accumulator), request);
+                errorResponse.partialResponse = {
+                    id: partial.id,
+                    provider: partial.provider,
+                    model: partial.model,
+                    created: partial.created,
+                    choices: partial.choices,
+                    usage: partial.usage,
+                };
+            }
+            yield { type: "error", error: errorResponse };
+        }
+    }
     /**
      * Validates Anthropic API key format
      *
@@ -183,6 +222,142 @@ class AnthropicClientAdapter {
             version: "1.0.0",
         };
     }
+    prepareMessageRequest(request, apiKey, options) {
+        // Check if structured output is requested - need beta API
+        const useStructuredOutput = !!(request.settings.structuredOutput?.schema &&
+            request.settings.structuredOutput.enabled !== false);
+        // Initialize Anthropic client
+        const anthropic = new sdk_1.default({
+            apiKey,
+            ...(this.baseURL && { baseURL: this.baseURL }),
+            maxRetries: 0, // retries are owned by the unified LLMService retry layer
+        });
+        // Per-request transport options (abort signal, timeout)
+        const requestTransportOptions = {
+            ...(options?.signal && { signal: options.signal }),
+            ...(options?.timeoutMs !== undefined && { timeout: options.timeoutMs }),
+        };
+        // Format messages for Anthropic API (Claude has specific requirements)
+        const { messages, systemMessage } = this.formatMessagesForAnthropic(request);
+        // Prepare API call parameters
+        const messageParams = {
+            model: request.modelId,
+            messages: messages,
+            max_tokens: request.settings.maxTokens,
+            temperature: request.settings.temperature,
+            top_p: request.settings.topP,
+            ...(request.settings.topK !== undefined && {
+                top_k: request.settings.topK,
+            }),
+            ...(systemMessage && { system: systemMessage }),
+            ...(request.settings.stopSequences.length > 0 && {
+                stop_sequences: request.settings.stopSequences,
+            }),
+        };
+        // Handle structured output configuration for Anthropic
+        // Note: Structured output requires the beta API endpoint
+        if (useStructuredOutput) {
+            const so = request.settings.structuredOutput;
+            // Anthropic requires additionalProperties: false on all object schemas
+            const processedSchema = so.strict !== false
+                ? this.addAdditionalPropertiesFalse(so.schema)
+                : so.schema;
+            // Anthropic's format: output_format.schema is the schema directly
+            messageParams.output_format = {
+                type: 'json_schema',
+                name: so.name,
+                schema: processedSchema,
+                strict: so.strict !== false,
+            };
+        }
+        // Handle reasoning/thinking configuration for Claude models
+        if (request.settings.reasoning && !request.settings.reasoning.exclude) {
+            const reasoning = request.settings.reasoning;
+            let budgetTokens;
+            // Convert reasoning settings to Anthropic's thinking format
+            if (reasoning.maxTokens !== undefined) {
+                budgetTokens = Math.max(reasoning.maxTokens, 1024); // Minimum 1024
+            }
+            else if (reasoning.effort) {
+                // Convert effort levels to token budgets
+                // Max budget for Anthropic is 32000
+                const maxBudget = 32000;
+                switch (reasoning.effort) {
+                    case 'high':
+                        budgetTokens = Math.floor(maxBudget * 0.8);
+                        break;
+                    case 'medium':
+                        budgetTokens = Math.floor(maxBudget * 0.5);
+                        break;
+                    case 'low':
+                        budgetTokens = Math.floor(maxBudget * 0.2);
+                        break;
+                }
+            }
+            else if (reasoning.enabled !== false) {
+                // Use default budget
+                budgetTokens = 10000;
+            }
+            if (budgetTokens !== undefined) {
+                // Add thinking configuration to the request
+                messageParams.thinking = {
+                    type: "enabled",
+                    budget_tokens: Math.min(budgetTokens, 32000), // Cap at max
+                };
+            }
+        }
+        return {
+            anthropic,
+            messageParams,
+            requestTransportOptions,
+            useStructuredOutput,
+            messages,
+        };
+    }
+    mapAnthropicUsage(usage) {
+        const promptTokens = usage.input_tokens ?? 0;
+        const completionTokens = usage.output_tokens ?? 0;
+        return {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+        };
+    }
+    mergeAnthropicUsage(current, next) {
+        if (!next) {
+            return current;
+        }
+        return {
+            ...(current || {}),
+            ...next,
+            input_tokens: next.input_tokens ?? current?.input_tokens ?? 0,
+            output_tokens: next.output_tokens ?? current?.output_tokens ?? 0,
+        };
+    }
+    createSyntheticMessage(request, accumulator) {
+        const content = [];
+        if (accumulator.reasoning) {
+            content.push({
+                type: "thinking",
+                thinking: accumulator.reasoning,
+                signature: "",
+            });
+        }
+        content.push({
+            type: "text",
+            text: accumulator.content,
+        });
+        return {
+            id: accumulator.id || `anthropic-stream-${Date.now()}`,
+            type: "message",
+            role: "assistant",
+            model: accumulator.model || request.modelId,
+            content,
+            stop_reason: accumulator.stopReason,
+            stop_sequence: null,
+            usage: accumulator.usage,
+        };
+    }
     /**
      * Recursively adds additionalProperties: false to all object schemas
      * Required by Anthropic's strict mode for structured outputs
@@ -322,9 +497,11 @@ class AnthropicClientAdapter {
      * @returns Standardized LLM response
      */
     createSuccessResponse(completion, request) {
-        // Anthropic returns content as an array of content blocks
-        const contentBlock = completion.content[0];
-        if (!contentBlock || contentBlock.type !== "text") {
+        // Anthropic returns content as an array of content blocks. Thinking-capable
+        // models may place a thinking block before the text block.
+        const textBlocks = completion.content.filter((block) => block.type === "text");
+        const textContent = textBlocks.map((block) => block.text || "").join("");
+        if (textBlocks.length === 0) {
             throw new Error("Invalid completion structure from Anthropic API");
         }
         // Extract thinking/reasoning content if available
@@ -334,6 +511,13 @@ class AnthropicClientAdapter {
         if (completion.thinking_content) {
             reasoning = completion.thinking_content;
         }
+        const thinkingContent = completion.content
+            .filter((block) => block.type === "thinking" && typeof block.thinking === "string")
+            .map((block) => block.thinking)
+            .join("");
+        if (!reasoning && thinkingContent) {
+            reasoning = thinkingContent;
+        }
         // Check for reasoning details that need to be preserved
         if (completion.reasoning_details) {
             reasoning_details = completion.reasoning_details;
@@ -343,7 +527,7 @@ class AnthropicClientAdapter {
         const choice = {
             message: {
                 role: "assistant",
-                content: contentBlock.text,
+                content: textContent,
             },
             finish_reason: finishReason,
             index: 0,

package/dist/llm/clients/GeminiClientAdapter.d.ts

@@ -1,4 +1,4 @@
-import type { LLMResponse, LLMFailureResponse } from "../types";
+import type { LLMResponse, LLMFailureResponse, LLMStreamEvent } from "../types";
 import type { ILLMClientAdapter, InternalLLMChatRequest, AdapterRequestOptions } from "./types";
 import type { Logger } from "../../logging/types";
 /**
@@ -33,6 +33,7 @@ export declare class GeminiClientAdapter implements ILLMClientAdapter {
      * @returns Promise resolving to success or failure response
      */
     sendMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): Promise<LLMResponse | LLMFailureResponse>;
+    streamMessage(request: InternalLLMChatRequest, apiKey: string, options?: AdapterRequestOptions): AsyncIterable<LLMStreamEvent>;
     /**
      * Validates Gemini API key format
      *
@@ -48,6 +49,12 @@ export declare class GeminiClientAdapter implements ILLMClientAdapter {
         name: string;
         version: string;
     };
+    private prepareGenerateContentRequest;
+    private createTransportState;
+    private getTransportErrorContext;
+    private updateGeminiAccumulatorMetadata;
+    private processGeminiStreamChunk;
+    private createSyntheticGeminiResponse;
     /**
      * Formats the internal LLM request for Gemini API
      *