illuma-agents 1.0.8 → 1.0.10

package/src/llm/openai/index.ts

@@ -643,6 +643,132 @@ export class ChatDeepSeek extends OriginalChatDeepSeek {
     } as OpenAICoreRequestOptions;
     return requestOptions;
   }
+
+  async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped: OpenAICompletionParam[] =
+      _convertMessagesToOpenAIParams(messages, this.model, {
+        includeReasoningContent: 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;
+    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;
+      }
+      const chunk = this._convertOpenAIDeltaToBaseMessageChunk(
+        delta,
+        data,
+        defaultRole
+      );
+      if ('reasoning_content' in delta) {
+        chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+      }
+      defaultRole = delta.role ?? defaultRole;
+      const newTokenIndices = {
+        prompt: (options as OpenAIChatCallOptions).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;
+      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 AIMessageChunk({
+          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 (options.signal?.aborted === true) {
+      throw new Error('AbortError');
+    }
+  }
 }
 
 /** xAI-specific usage metadata type */

package/src/llm/openai/types.ts

@@ -1,24 +1,24 @@
-import type { OpenAICallOptions } from '@langchain/openai';
-
-export interface OpenAIChatCallOptions extends OpenAICallOptions {
-  promptIndex?: number;
-}
-
-// TODO import from SDK when available
-export type OpenAIRoleEnum =
-  | 'system'
-  | 'developer'
-  | 'assistant'
-  | 'user'
-  | 'function'
-  | 'tool';
-
-export type HeaderValue = string | undefined | null;
-export type HeadersLike =
-  | Headers
-  | readonly HeaderValue[][]
-  | Record<string, HeaderValue | readonly HeaderValue[]>
-  | undefined
-  | null
-  // NullableHeaders
-  | { values: Headers; [key: string]: unknown };
+import type { OpenAICallOptions } from '@langchain/openai';
+
+export interface OpenAIChatCallOptions extends OpenAICallOptions {
+  promptIndex?: number;
+}
+
+// TODO import from SDK when available
+export type OpenAIRoleEnum =
+  | 'system'
+  | 'developer'
+  | 'assistant'
+  | 'user'
+  | 'function'
+  | 'tool';
+
+export type HeaderValue = string | undefined | null;
+export type HeadersLike =
+  | Headers
+  | readonly HeaderValue[][]
+  | Record<string, HeaderValue | readonly HeaderValue[]>
+  | undefined
+  | null
+  // NullableHeaders
+  | { values: Headers; [key: string]: unknown };

package/src/llm/openai/utils/index.ts

@@ -286,10 +286,21 @@ const completionsApiContentBlockConverter: StandardContentBlockConverter<{
   },
 };
 
+/** Options for converting messages to OpenAI params */
+export interface ConvertMessagesOptions {
+  /** Include reasoning_content field for DeepSeek thinking mode with tool calls */
+  includeReasoningContent?: boolean;
+  /** Include reasoning_details field for OpenRouter/Gemini thinking mode with tool calls */
+  includeReasoningDetails?: boolean;
+  /** Convert reasoning_details to content blocks for Claude (requires content array format) */
+  convertReasoningDetailsToContent?: boolean;
+}
+
 // Used in LangSmith, export is important here
 export function _convertMessagesToOpenAIParams(
   messages: BaseMessage[],
-  model?: string
+  model?: string,
+  options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
   // TODO: Function messages do not support array content, fix cast
   return messages.flatMap((message) => {
@@ -333,9 +344,113 @@ export function _convertMessagesToOpenAIParams(
         convertLangChainToolCallToOpenAI
       );
       completionParam.content = hasAnthropicThinkingBlock ? content : '';
+      if (
+        options?.includeReasoningContent === true &&
+        message.additional_kwargs.reasoning_content != null
+      ) {
+        completionParam.reasoning_content =
+          message.additional_kwargs.reasoning_content;
+      }
+      if (
+        options?.includeReasoningDetails === true &&
+        message.additional_kwargs.reasoning_details != null
+      ) {
+        // For Claude via OpenRouter, convert reasoning_details to content blocks
+        const isClaudeModel =
+          model?.includes('claude') === true ||
+          model?.includes('anthropic') === true;
+        if (
+          options.convertReasoningDetailsToContent === true &&
+          isClaudeModel
+        ) {
+          const reasoningDetails = message.additional_kwargs
+            .reasoning_details as Record<string, unknown>[];
+          const contentBlocks = [];
+
+          // Add thinking blocks from reasoning_details
+          for (const detail of reasoningDetails) {
+            if (detail.type === 'reasoning.text' && detail.text != null) {
+              contentBlocks.push({
+                type: 'thinking',
+                thinking: detail.text,
+              });
+            } else if (
+              detail.type === 'reasoning.encrypted' &&
+              detail.data != null
+            ) {
+              contentBlocks.push({
+                type: 'redacted_thinking',
+                data: detail.data,
+                id: detail.id,
+              });
+            }
+          }
+
+          // Set content to array with thinking blocks
+          if (contentBlocks.length > 0) {
+            completionParam.content = contentBlocks;
+          }
+        } else {
+          // For non-Claude models, pass as separate field
+          completionParam.reasoning_details =
+            message.additional_kwargs.reasoning_details;
+        }
+      }
     } else {
       if (message.additional_kwargs.tool_calls != null) {
         completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if (
+          options?.includeReasoningContent === true &&
+          message.additional_kwargs.reasoning_content != null
+        ) {
+          completionParam.reasoning_content =
+            message.additional_kwargs.reasoning_content;
+        }
+        if (
+          options?.includeReasoningDetails === true &&
+          message.additional_kwargs.reasoning_details != null
+        ) {
+          // For Claude via OpenRouter, convert reasoning_details to content blocks
+          const isClaudeModel =
+            model?.includes('claude') === true ||
+            model?.includes('anthropic') === true;
+          if (
+            options.convertReasoningDetailsToContent === true &&
+            isClaudeModel
+          ) {
+            const reasoningDetails = message.additional_kwargs
+              .reasoning_details as Record<string, unknown>[];
+            const contentBlocks = [];
+
+            // Add thinking blocks from reasoning_details
+            for (const detail of reasoningDetails) {
+              if (detail.type === 'reasoning.text' && detail.text != null) {
+                contentBlocks.push({
+                  type: 'thinking',
+                  thinking: detail.text,
+                });
+              } else if (
+                detail.type === 'reasoning.encrypted' &&
+                detail.data != null
+              ) {
+                contentBlocks.push({
+                  type: 'redacted_thinking',
+                  data: detail.data,
+                  id: detail.id,
+                });
+              }
+            }
+
+            // Set content to array with thinking blocks
+            if (contentBlocks.length > 0) {
+              completionParam.content = contentBlocks;
+            }
+          } else {
+            // For non-Claude models, pass as separate field
+            completionParam.reasoning_details =
+              message.additional_kwargs.reasoning_details;
+          }
+        }
       }
       if ((message as ToolMessage).tool_call_id != null) {
         completionParam.tool_call_id = (message as ToolMessage).tool_call_id;

package/src/llm/openai/utils/isReasoningModel.test.ts

@@ -1,90 +1,90 @@
-import { isReasoningModel } from './index';
-
-describe('isReasoningModel', () => {
-  describe('should return true for reasoning models', () => {
-    test('basic o-series models', () => {
-      expect(isReasoningModel('o1')).toBe(true);
-      expect(isReasoningModel('o2')).toBe(true);
-      expect(isReasoningModel('o9')).toBe(true);
-      expect(isReasoningModel('o1-preview')).toBe(true);
-      expect(isReasoningModel('o1-mini')).toBe(true);
-    });
-
-    test('gpt-5+ models', () => {
-      expect(isReasoningModel('gpt-5')).toBe(true);
-      expect(isReasoningModel('gpt-6')).toBe(true);
-      expect(isReasoningModel('gpt-7')).toBe(true);
-      expect(isReasoningModel('gpt-8')).toBe(true);
-      expect(isReasoningModel('gpt-9')).toBe(true);
-    });
-
-    test('with provider prefixes', () => {
-      expect(isReasoningModel('azure/o1')).toBe(true);
-      expect(isReasoningModel('azure/gpt-5')).toBe(true);
-      expect(isReasoningModel('openai/o1')).toBe(true);
-      expect(isReasoningModel('openai/gpt-5')).toBe(true);
-    });
-
-    test('with custom prefixes', () => {
-      expect(isReasoningModel('custom-provider/o1')).toBe(true);
-      expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
-      expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
-    });
-
-    test('case insensitive', () => {
-      expect(isReasoningModel('O1')).toBe(true);
-      expect(isReasoningModel('GPT-5')).toBe(true);
-      expect(isReasoningModel('gPt-6')).toBe(true);
-      expect(isReasoningModel('Azure/O1')).toBe(true);
-    });
-  });
-
-  describe('should return false for non-reasoning models', () => {
-    test('older GPT models', () => {
-      expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
-      expect(isReasoningModel('gpt-4')).toBe(false);
-      expect(isReasoningModel('gpt-4-turbo')).toBe(false);
-      expect(isReasoningModel('gpt-4o')).toBe(false);
-      expect(isReasoningModel('gpt-4o-mini')).toBe(false);
-    });
-
-    test('other model families', () => {
-      expect(isReasoningModel('claude-3')).toBe(false);
-      expect(isReasoningModel('claude-3-opus')).toBe(false);
-      expect(isReasoningModel('llama-2')).toBe(false);
-      expect(isReasoningModel('gemini-pro')).toBe(false);
-    });
-
-    test('partial matches that should not match', () => {
-      expect(isReasoningModel('proto1')).toBe(false);
-      expect(isReasoningModel('version-o1')).toBe(true);
-      expect(isReasoningModel('gpt-40')).toBe(false);
-      expect(isReasoningModel('gpt-3.5')).toBe(false);
-    });
-
-    test('empty, null, and undefined', () => {
-      expect(isReasoningModel('')).toBe(false);
-      expect(isReasoningModel()).toBe(false);
-      expect(isReasoningModel(undefined)).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    test('with special characters', () => {
-      expect(isReasoningModel('deployment_o1_model')).toBe(false);
-      expect(isReasoningModel('gpt-5-deployment')).toBe(true);
-      expect(isReasoningModel('o1@latest')).toBe(true);
-      expect(isReasoningModel('gpt-5.0')).toBe(true);
-    });
-
-    test('word boundary behavior', () => {
-      // These should match because o1 and gpt-5 are whole words
-      expect(isReasoningModel('use-o1-model')).toBe(true);
-      expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
-
-      // These should not match because o1/gpt-5 are not whole words
-      expect(isReasoningModel('proto1model')).toBe(false);
-      expect(isReasoningModel('supergpt-50')).toBe(false);
-    });
-  });
-});
+import { isReasoningModel } from './index';
+
+describe('isReasoningModel', () => {
+  describe('should return true for reasoning models', () => {
+    test('basic o-series models', () => {
+      expect(isReasoningModel('o1')).toBe(true);
+      expect(isReasoningModel('o2')).toBe(true);
+      expect(isReasoningModel('o9')).toBe(true);
+      expect(isReasoningModel('o1-preview')).toBe(true);
+      expect(isReasoningModel('o1-mini')).toBe(true);
+    });
+
+    test('gpt-5+ models', () => {
+      expect(isReasoningModel('gpt-5')).toBe(true);
+      expect(isReasoningModel('gpt-6')).toBe(true);
+      expect(isReasoningModel('gpt-7')).toBe(true);
+      expect(isReasoningModel('gpt-8')).toBe(true);
+      expect(isReasoningModel('gpt-9')).toBe(true);
+    });
+
+    test('with provider prefixes', () => {
+      expect(isReasoningModel('azure/o1')).toBe(true);
+      expect(isReasoningModel('azure/gpt-5')).toBe(true);
+      expect(isReasoningModel('openai/o1')).toBe(true);
+      expect(isReasoningModel('openai/gpt-5')).toBe(true);
+    });
+
+    test('with custom prefixes', () => {
+      expect(isReasoningModel('custom-provider/o1')).toBe(true);
+      expect(isReasoningModel('my-deployment/gpt-5')).toBe(true);
+      expect(isReasoningModel('company/azure/gpt-5')).toBe(true);
+    });
+
+    test('case insensitive', () => {
+      expect(isReasoningModel('O1')).toBe(true);
+      expect(isReasoningModel('GPT-5')).toBe(true);
+      expect(isReasoningModel('gPt-6')).toBe(true);
+      expect(isReasoningModel('Azure/O1')).toBe(true);
+    });
+  });
+
+  describe('should return false for non-reasoning models', () => {
+    test('older GPT models', () => {
+      expect(isReasoningModel('gpt-3.5-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4')).toBe(false);
+      expect(isReasoningModel('gpt-4-turbo')).toBe(false);
+      expect(isReasoningModel('gpt-4o')).toBe(false);
+      expect(isReasoningModel('gpt-4o-mini')).toBe(false);
+    });
+
+    test('other model families', () => {
+      expect(isReasoningModel('claude-3')).toBe(false);
+      expect(isReasoningModel('claude-3-opus')).toBe(false);
+      expect(isReasoningModel('llama-2')).toBe(false);
+      expect(isReasoningModel('gemini-pro')).toBe(false);
+    });
+
+    test('partial matches that should not match', () => {
+      expect(isReasoningModel('proto1')).toBe(false);
+      expect(isReasoningModel('version-o1')).toBe(true);
+      expect(isReasoningModel('gpt-40')).toBe(false);
+      expect(isReasoningModel('gpt-3.5')).toBe(false);
+    });
+
+    test('empty, null, and undefined', () => {
+      expect(isReasoningModel('')).toBe(false);
+      expect(isReasoningModel()).toBe(false);
+      expect(isReasoningModel(undefined)).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('with special characters', () => {
+      expect(isReasoningModel('deployment_o1_model')).toBe(false);
+      expect(isReasoningModel('gpt-5-deployment')).toBe(true);
+      expect(isReasoningModel('o1@latest')).toBe(true);
+      expect(isReasoningModel('gpt-5.0')).toBe(true);
+    });
+
+    test('word boundary behavior', () => {
+      // These should match because o1 and gpt-5 are whole words
+      expect(isReasoningModel('use-o1-model')).toBe(true);
+      expect(isReasoningModel('model-gpt-5-latest')).toBe(true);
+
+      // These should not match because o1/gpt-5 are not whole words
+      expect(isReasoningModel('proto1model')).toBe(false);
+      expect(isReasoningModel('supergpt-50')).toBe(false);
+    });
+  });
+});