illuma-agents 1.0.8 → 1.0.10

package/src/llm/openrouter/index.ts

@@ -1,4 +1,7 @@
 import { ChatOpenAI } from '@/llm/openai';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import { AIMessageChunk as AIMessageChunkClass } from '@langchain/core/messages';
 import type {
   FunctionMessageChunk,
   SystemMessageChunk,
@@ -6,12 +9,25 @@ import type {
   ToolMessageChunk,
   ChatMessageChunk,
   AIMessageChunk,
+  BaseMessage,
 } from '@langchain/core/messages';
 import type {
   ChatOpenAICallOptions,
   OpenAIChatInput,
   OpenAIClient,
 } from '@langchain/openai';
+import { _convertMessagesToOpenAIParams } from '@/llm/openai/utils';
+
+type OpenAICompletionParam =
+  OpenAIClient.Chat.Completions.ChatCompletionMessageParam;
+
+type OpenAIRoleEnum =
+  | 'system'
+  | 'developer'
+  | 'assistant'
+  | 'user'
+  | 'function'
+  | 'tool';
 
 export interface ChatOpenRouterCallOptions extends ChatOpenAICallOptions {
   include_reasoning?: boolean;
@@ -54,7 +70,212 @@ export class ChatOpenRouter extends ChatOpenAI {
       rawResponse,
       defaultRole
     );
-    messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    if (delta.reasoning != null) {
+      messageChunk.additional_kwargs.reasoning = delta.reasoning;
+    }
+    if (delta.reasoning_details != null) {
+      messageChunk.additional_kwargs.reasoning_details =
+        delta.reasoning_details;
+    }
     return messageChunk;
   }
+
+  async *_streamResponseChunks2(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningDetails: true,
+        convertReasoningDetailsToContent: true,
+      });
+
+    const params = {
+      ...this.invocationParams(options, {
+        streaming: true,
+      }),
+      messages: messagesMapped,
+      stream: true as const,
+    };
+    let defaultRole: OpenAIRoleEnum | undefined;
+
+    const streamIterable = await this.completionWithRetry(params, options);
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined;
+
+    // Store reasoning_details keyed by unique identifier to prevent incorrect merging
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningTextByIndex: Map<number, Record<string, any>> = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const reasoningEncryptedById: Map<string, Record<string, any>> = new Map();
+
+    for await (const data of streamIterable) {
+      const choice = data.choices[0] as
+        | Partial<OpenAIClient.Chat.Completions.ChatCompletionChunk.Choice>
+        | undefined;
+      if (data.usage) {
+        usage = data.usage;
+      }
+      if (!choice) {
+        continue;
+      }
+
+      const { delta } = choice;
+      if (!delta) {
+        continue;
+      }
+
+      // Accumulate reasoning_details from each delta
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const deltaAny = delta as Record<string, any>;
+      if (
+        deltaAny.reasoning_details != null &&
+        Array.isArray(deltaAny.reasoning_details)
+      ) {
+        for (const detail of deltaAny.reasoning_details) {
+          // For encrypted reasoning (thought signatures), store by ID - MUST be separate
+          if (detail.type === 'reasoning.encrypted' && detail.id) {
+            reasoningEncryptedById.set(detail.id, {
+              type: detail.type,
+              id: detail.id,
+              data: detail.data,
+              format: detail.format,
+              index: detail.index,
+            });
+          } else if (detail.type === 'reasoning.text') {
+            // For text reasoning, accumulate text by index
+            const idx = detail.index ?? 0;
+            const existing = reasoningTextByIndex.get(idx);
+            if (existing) {
+              // Only append text, keep other fields from first entry
+              existing.text = (existing.text || '') + (detail.text || '');
+            } else {
+              reasoningTextByIndex.set(idx, {
+                type: detail.type,
+                text: detail.text || '',
+                format: detail.format,
+                index: idx,
+              });
+            }
+          }
+        }
+      }
+
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+
+      // IMPORTANT: Only set reasoning_details on the FINAL chunk to prevent
+      // LangChain's chunk concatenation from corrupting the array
+      // Check if this is the final chunk (has finish_reason)
+      if (choice.finish_reason != null) {
+        // Build properly structured reasoning_details array
+        // Text entries first (but we only need the encrypted ones for thought signatures)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const finalReasoningDetails: Record<string, any>[] = [
+          ...reasoningTextByIndex.values(),
+          ...reasoningEncryptedById.values(),
+        ];
+
+        if (finalReasoningDetails.length > 0) {
+          chunk.additional_kwargs.reasoning_details = finalReasoningDetails;
+        }
+      } else {
+        // Clear reasoning_details from intermediate chunks to prevent concatenation issues
+        delete chunk.additional_kwargs.reasoning_details;
+      }
+
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: options.promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      };
+      if (typeof chunk.content !== 'string') {
+        // eslint-disable-next-line no-console
+        console.log(
+          '[WARNING]: Received non-string content from OpenAI. This is currently not supported.'
+        );
+        continue;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const generationInfo: Record<string, any> = { ...newTokenIndices };
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason;
+        generationInfo.system_fingerprint = data.system_fingerprint;
+        generationInfo.model_name = data.model;
+        generationInfo.service_tier = data.service_tier;
+      }
+      if (this.logprobs == true) {
+        generationInfo.logprobs = choice.logprobs;
+      }
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+      await runManager?.handleLLMNewToken(
+        generationChunk.text || '',
+        newTokenIndices,
+        undefined,
+        undefined,
+        undefined,
+        { chunk: generationChunk }
+      );
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens != null && {
+          audio: usage.prompt_tokens_details.audio_tokens,
+        }),
+        ...(usage.prompt_tokens_details?.cached_tokens != null && {
+          cache_read: usage.prompt_tokens_details.cached_tokens,
+        }),
+      };
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens != null && {
+          audio: usage.completion_tokens_details.audio_tokens,
+        }),
+        ...(usage.completion_tokens_details?.reasoning_tokens != null && {
+          reasoning: usage.completion_tokens_details.reasoning_tokens,
+        }),
+      };
+      const generationChunk = new ChatGenerationChunk({
+        message: new AIMessageChunkClass({
+          content: '',
+          response_metadata: {
+            usage: { ...usage },
+          },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && {
+              input_token_details: inputTokenDetails,
+            }),
+            ...(Object.keys(outputTokenDetails).length > 0 && {
+              output_token_details: outputTokenDetails,
+            }),
+          },
+        }),
+        text: '',
+      });
+      yield generationChunk;
+      if (this._lc_stream_delay != null) {
+        await new Promise((resolve) =>
+          setTimeout(resolve, this._lc_stream_delay)
+        );
+      }
+    }
+    if (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }

package/src/llm/providers.ts

@@ -1,8 +1,5 @@
 // src/llm/providers.ts
 import { ChatMistralAI } from '@langchain/mistralai';
-import { ChatBedrockConverse } from '@langchain/aws';
-// import { ChatAnthropic } from '@langchain/anthropic';
-// import { ChatVertexAI } from '@langchain/google-vertexai';
 import type {
   ChatModelConstructorMap,
   ProviderOptionsMap,
@@ -15,16 +12,15 @@ import {
   ChatXAI,
 } from '@/llm/openai';
 import { CustomChatGoogleGenerativeAI } from '@/llm/google';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { ChatVertexAI } from '@/llm/vertexai';
-import { ChatOllama } from '@/llm/ollama';
 import { Providers } from '@/common';
 
 export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.XAI]: ChatXAI,
   [Providers.OPENAI]: ChatOpenAI,
-  [Providers.OLLAMA]: ChatOllama,
   [Providers.AZURE]: AzureChatOpenAI,
   [Providers.VERTEXAI]: ChatVertexAI,
   [Providers.DEEPSEEK]: ChatDeepSeek,
@@ -32,7 +28,7 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.MISTRAL]: ChatMistralAI,
   [Providers.ANTHROPIC]: CustomAnthropic,
   [Providers.OPENROUTER]: ChatOpenRouter,
-  [Providers.BEDROCK]: ChatBedrockConverse,
+  [Providers.BEDROCK]: CustomChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
   [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
 };
@@ -40,7 +36,6 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
 export const manualToolStreamProviders = new Set<Providers | string>([
   Providers.ANTHROPIC,
   Providers.BEDROCK,
-  Providers.OLLAMA,
 ]);
 
 export const getChatModelClass = <P extends Providers>(

package/src/llm/text.ts

@@ -1,94 +1,94 @@
-export interface TextStreamOptions {
-  minChunkSize?: number;
-  maxChunkSize?: number;
-  delay?: number;
-  firstWordChunk?: boolean;
-}
-
-export type ProgressCallback = (chunk: string) => void;
-export type PostChunkCallback = (chunk: string) => void;
-
-export class TextStream {
-  private text: string;
-  private currentIndex: number;
-  private minChunkSize: number;
-  private maxChunkSize: number;
-  private delay: number;
-  private firstWordChunk: boolean;
-
-  constructor(text: string, options: TextStreamOptions = {}) {
-    this.text = text;
-    this.currentIndex = 0;
-    this.minChunkSize = options.minChunkSize ?? 4;
-    this.maxChunkSize = options.maxChunkSize ?? 8;
-    this.delay = options.delay ?? 20;
-    this.firstWordChunk = options.firstWordChunk ?? true;
-  }
-
-  private randomInt(min: number, max: number): number {
-    return Math.floor(Math.random() * (max - min)) + min;
-  }
-
-  private static readonly BOUNDARIES = new Set([
-    ' ',
-    '.',
-    ',',
-    '!',
-    '?',
-    ';',
-    ':',
-  ]);
-
-  private findFirstWordBoundary(text: string, minSize: number): number {
-    if (minSize >= text.length) return text.length;
-
-    // Ensure we meet the minimum size first
-    let pos = minSize;
-
-    // Look forward until we find a boundary
-    while (pos < text.length) {
-      if (TextStream.BOUNDARIES.has(text[pos])) {
-        return pos + 1; // Include the boundary character
-      }
-      pos++;
-    }
-
-    return text.length; // If no boundary found, return entire remaining text
-  }
-
-  async *generateText(
-    signal?: AbortSignal,
-    progressCallback?: ProgressCallback
-  ): AsyncGenerator<string, void, unknown> {
-    const { delay, minChunkSize, maxChunkSize } = this;
-
-    while (this.currentIndex < this.text.length) {
-      if (signal?.aborted === true) {
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, delay));
-
-      const remainingText = this.text.slice(this.currentIndex);
-      let chunkSize: number;
-
-      if (this.firstWordChunk) {
-        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
-      } else {
-        const remainingChars = remainingText.length;
-        chunkSize = Math.min(
-          this.randomInt(minChunkSize, maxChunkSize + 1),
-          remainingChars
-        );
-      }
-
-      const chunk = this.text.slice(
-        this.currentIndex,
-        this.currentIndex + chunkSize
-      );
-      progressCallback?.(chunk);
-
-      yield chunk;
-      this.currentIndex += chunkSize;
-    }
-  }
-}
+export interface TextStreamOptions {
+  minChunkSize?: number;
+  maxChunkSize?: number;
+  delay?: number;
+  firstWordChunk?: boolean;
+}
+
+export type ProgressCallback = (chunk: string) => void;
+export type PostChunkCallback = (chunk: string) => void;
+
+export class TextStream {
+  private text: string;
+  private currentIndex: number;
+  private minChunkSize: number;
+  private maxChunkSize: number;
+  private delay: number;
+  private firstWordChunk: boolean;
+
+  constructor(text: string, options: TextStreamOptions = {}) {
+    this.text = text;
+    this.currentIndex = 0;
+    this.minChunkSize = options.minChunkSize ?? 4;
+    this.maxChunkSize = options.maxChunkSize ?? 8;
+    this.delay = options.delay ?? 20;
+    this.firstWordChunk = options.firstWordChunk ?? true;
+  }
+
+  private randomInt(min: number, max: number): number {
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+
+  private static readonly BOUNDARIES = new Set([
+    ' ',
+    '.',
+    ',',
+    '!',
+    '?',
+    ';',
+    ':',
+  ]);
+
+  private findFirstWordBoundary(text: string, minSize: number): number {
+    if (minSize >= text.length) return text.length;
+
+    // Ensure we meet the minimum size first
+    let pos = minSize;
+
+    // Look forward until we find a boundary
+    while (pos < text.length) {
+      if (TextStream.BOUNDARIES.has(text[pos])) {
+        return pos + 1; // Include the boundary character
+      }
+      pos++;
+    }
+
+    return text.length; // If no boundary found, return entire remaining text
+  }
+
+  async *generateText(
+    signal?: AbortSignal,
+    progressCallback?: ProgressCallback
+  ): AsyncGenerator<string, void, unknown> {
+    const { delay, minChunkSize, maxChunkSize } = this;
+
+    while (this.currentIndex < this.text.length) {
+      if (signal?.aborted === true) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+
+      const remainingText = this.text.slice(this.currentIndex);
+      let chunkSize: number;
+
+      if (this.firstWordChunk) {
+        chunkSize = this.findFirstWordBoundary(remainingText, minChunkSize);
+      } else {
+        const remainingChars = remainingText.length;
+        chunkSize = Math.min(
+          this.randomInt(minChunkSize, maxChunkSize + 1),
+          remainingChars
+        );
+      }
+
+      const chunk = this.text.slice(
+        this.currentIndex,
+        this.currentIndex + chunkSize
+      );
+      progressCallback?.(chunk);
+
+      yield chunk;
+      this.currentIndex += chunkSize;
+    }
+  }
+}