@librechat/agents 3.2.21 → 3.2.31

package/src/llm/google/utils/common.ts

@@ -1,16 +1,8 @@
-import {
-  POSSIBLE_ROLES,
-  type Part,
-  type Content,
-  type TextPart,
-  type FileDataPart,
-  type InlineDataPart,
-  type FunctionCallPart,
-  type GenerateContentCandidate,
-  type EnhancedGenerateContentResponse,
-  type FunctionDeclaration as GenerativeAIFunctionDeclaration,
-  type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool,
-} from '@google/generative-ai';
+import { v4 as uuidv4 } from 'uuid';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ToolCallChunk } from '@langchain/core/messages/tool';
+import { isOpenAITool } from '@langchain/core/language_models/base';
+import { isLangChainTool } from '@langchain/core/utils/function_calling';
 import {
   AIMessage,
   AIMessageChunk,
@@ -29,18 +21,26 @@ import {
   convertToProviderContentBlock,
   isDataContentBlock,
 } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
+import {
+  POSSIBLE_ROLES,
+  type Part,
+  type Content,
+  type TextPart,
+  type FileDataPart,
+  type InlineDataPart,
+  type FunctionCallPart,
+  type GenerateContentCandidate,
+  type EnhancedGenerateContentResponse,
+  type FunctionDeclaration as GenerativeAIFunctionDeclaration,
+  type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool,
+} from '@google/generative-ai';
 import type { ChatGeneration, ChatResult } from '@langchain/core/outputs';
-import { isLangChainTool } from '@langchain/core/utils/function_calling';
-import { isOpenAITool } from '@langchain/core/language_models/base';
-import { ToolCallChunk } from '@langchain/core/messages/tool';
-import { v4 as uuidv4 } from 'uuid';
 import {
   jsonSchemaToGeminiParameters,
   schemaToGenerativeAIParameters,
 } from './zod_to_genai_parameters';
-import { GoogleGenerativeAIToolType } from '../types';
 import { toLangChainContent } from '@/messages/langchain';
+import { GoogleGenerativeAIToolType } from '../types';
 
 export const _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY =
   '__gemini_function_call_thought_signatures__';
@@ -48,6 +48,49 @@ export const _FUNCTION_CALL_THOUGHT_SIGNATURES_MAP_KEY =
 const DUMMY_SIGNATURE =
   'ErYCCrMCAdHtim9kOoOkrPiCNVsmlpMIKd7ZMxgiFbVQOkgp7nlLcDMzVsZwIzvuT7nQROivoXA72ccC2lSDvR0Gh7dkWaGuj7ctv6t7ZceHnecx0QYa+ix8tYpRfjhyWozQ49lWiws6+YGjCt10KRTyWsZ2h6O7iHTYJwKIRwGUHRKy/qK/6kFxJm5ML00gLq4D8s5Z6DBpp2ZlR+uF4G8jJgeWQgyHWVdx2wGYElaceVAc66tZdPQRdOHpWtgYSI1YdaXgVI8KHY3/EfNc2YqqMIulvkDBAnuMhkAjV9xmBa54Tq+ih3Im4+r3DzqhGqYdsSkhS0kZMwte4Hjs65dZzCw9lANxIqYi1DJ639WNPYihp/DCJCos7o+/EeSPJaio5sgWDyUnMGkY1atsJZ+m7pj7DD5tvQ==';
 
+type GoogleServerSideToolPart = Part & {
+  type?: 'toolCall' | 'toolResponse';
+  toolCall?: object;
+  toolResponse?: object;
+};
+
+type GoogleServerSideToolPartMetadata = {
+  thought?: boolean;
+  thoughtSignature?: string;
+};
+
+type GoogleFunctionCallWithId = FunctionCallPart['functionCall'] & {
+  id?: string;
+};
+
+type GoogleFunctionResponseWithId = {
+  name: string;
+  response: object;
+  id?: string;
+};
+
+function getGoogleFunctionId(id?: string): string | undefined {
+  return id != null && id !== '' ? id : undefined;
+}
+
+function createGoogleFunctionResponsePart({
+  name,
+  response,
+  id,
+}: {
+  name: string;
+  response: object;
+  id?: string;
+}): Part {
+  const functionId = getGoogleFunctionId(id);
+  const functionResponse: GoogleFunctionResponseWithId = {
+    name,
+    response,
+    ...(functionId != null ? { id: functionId } : {}),
+  };
+  return { functionResponse };
+}
+
 /**
  * Executes a function immediately and returns its result.
  * Functional utility similar to an Immediately Invoked Function Expression (IIFE).
@@ -118,6 +161,63 @@ function messageContentMedia(content: MessageContentComplex): Part {
   throw new Error('Invalid media content');
 }
 
+function isGoogleServerSideToolPart(
+  content: MessageContentComplex
+): content is MessageContentComplex & GoogleServerSideToolPart {
+  return (
+    'toolCall' in content ||
+    'toolResponse' in content ||
+    content.type === 'toolCall' ||
+    content.type === 'toolResponse'
+  );
+}
+
+function convertGoogleServerSideToolPart(
+  content: MessageContentComplex & GoogleServerSideToolPart
+): Part {
+  const metadata: GoogleServerSideToolPartMetadata = {};
+  if ('thought' in content && typeof content.thought === 'boolean') {
+    metadata.thought = content.thought;
+  }
+  if (
+    'thoughtSignature' in content &&
+    typeof content.thoughtSignature === 'string'
+  ) {
+    metadata.thoughtSignature = content.thoughtSignature;
+  }
+  if ('toolCall' in content && content.toolCall != null) {
+    return { toolCall: content.toolCall, ...metadata } as unknown as Part;
+  }
+  if ('toolResponse' in content && content.toolResponse != null) {
+    return {
+      toolResponse: content.toolResponse,
+      ...metadata,
+    } as unknown as Part;
+  }
+
+  return content as Part;
+}
+
+function convertGoogleServerSideToolResponsePart(
+  part: Part
+): GoogleServerSideToolPart | undefined {
+  if (
+    'toolCall' in part &&
+    typeof part.toolCall === 'object' &&
+    part.toolCall != null
+  ) {
+    return { ...part, type: 'toolCall', toolCall: part.toolCall };
+  }
+  if (
+    'toolResponse' in part &&
+    typeof part.toolResponse === 'object' &&
+    part.toolResponse != null
+  ) {
+    return { ...part, type: 'toolResponse', toolResponse: part.toolResponse };
+  }
+  return undefined;
+}
+
 function inferToolNameFromPreviousMessages(
   message: ToolMessage | ToolMessageChunk,
   previousMessages: BaseMessage[]
@@ -280,6 +380,10 @@ function _convertLangChainContentToPart(
     );
   }
 
+  if (isGoogleServerSideToolPart(content)) {
+    return convertGoogleServerSideToolPart(content);
+  }
+
   if (content.type === 'text') {
     return { text: content.text };
   } else if (content.type === 'executableCode') {
@@ -375,25 +479,23 @@ export function convertMessageContentToParts(
 
     if (message.status === 'error') {
       return [
-        {
-          functionResponse: {
-            name: messageName,
-            // The API expects an object with an `error` field if the function call fails.
-            // `error` must be a valid object (not a string or array), so we wrap `message.content` here
-            response: { error: { details: result } },
-          },
-        },
+        createGoogleFunctionResponsePart({
+          name: messageName,
+          // The API expects an object with an `error` field if the function call fails.
+          // `error` must be a valid object (not a string or array), so we wrap `message.content` here
+          response: { error: { details: result } },
+          id: message.tool_call_id,
+        }),
       ];
     }
 
     return [
-      {
-        functionResponse: {
-          name: messageName,
-          // again, can't have a string or array value for `response`, so we wrap it as an object here
-          response: { result },
-        },
-      },
+      createGoogleFunctionResponsePart({
+        name: messageName,
+        // again, can't have a string or array value for `response`, so we wrap it as an object here
+        response: { result },
+        id: message.tool_call_id,
+      }),
     ];
   }
 
@@ -432,12 +534,15 @@ export function convertMessageContentToParts(
         }
         return '';
       });
+      const functionId = getGoogleFunctionId(tc.id);
+      const functionCall: GoogleFunctionCallWithId = {
+        name: tc.name,
+        args: tc.args,
+        ...(functionId != null ? { id: functionId } : {}),
+      };
 
       return {
-        functionCall: {
-          name: tc.name,
-          args: tc.args,
-        },
+        functionCall,
         ...(thoughtSignature ? { thoughtSignature } : {}),
       };
     });
@@ -598,6 +703,10 @@ export function convertResponseContentToChatGenerationChunk(
               codeExecutionResult: p.codeExecutionResult,
             };
           }
+          const serverSideToolPart = convertGoogleServerSideToolResponsePart(p);
+          if (serverSideToolPart !== undefined) {
+            return serverSideToolPart;
+          }
           return p;
         })
         .filter((p) => p !== undefined)
@@ -685,11 +794,7 @@ export function mapGenerateContentResultToChatResult(
     usageMetadata: UsageMetadata | undefined;
   }
 ): ChatResult {
-  if (
-    !response.candidates ||
-    response.candidates.length === 0 ||
-    !response.candidates[0]
-  ) {
+  if (!response.candidates || response.candidates.length === 0) {
     return {
       generations: [],
       llmOutput: {
@@ -725,7 +830,7 @@ export function mapGenerateContentResultToChatResult(
   if (
     Array.isArray(candidateContent?.parts) &&
     candidateContent.parts.length === 1 &&
-    candidateContent.parts[0].text &&
+    (candidateContent.parts[0].text ?? '') !== '' &&
     !(
       'thought' in candidateContent.parts[0] &&
       candidateContent.parts[0].thought === true
@@ -758,6 +863,10 @@ export function mapGenerateContentResultToChatResult(
               codeExecutionResult: p.codeExecutionResult,
             };
           }
+          const serverSideToolPart = convertGoogleServerSideToolResponsePart(p);
+          if (serverSideToolPart !== undefined) {
+            return serverSideToolPart;
+          }
           return p;
         })
         .filter((p) => p !== undefined)
@@ -807,7 +916,7 @@ export function mapGenerateContentResultToChatResult(
   const generation: ChatGeneration = {
     text,
     message: new AIMessage({
-      content: content ?? '',
+      content,
       tool_calls,
       additional_kwargs,
       usage_metadata: extra?.usageMetadata,

package/src/llm/google/utils/tools.ts

@@ -1,3 +1,10 @@
+import { StructuredToolInterface } from '@langchain/core/tools';
+import { ToolChoice } from '@langchain/core/language_models/chat_models';
+import { isLangChainTool } from '@langchain/core/utils/function_calling';
+import {
+  isOpenAITool,
+  ToolDefinition,
+} from '@langchain/core/language_models/base';
 import {
   Tool as GenerativeAITool,
   ToolConfig,
@@ -6,16 +13,9 @@ import {
   FunctionDeclarationsTool,
   FunctionDeclarationSchema,
 } from '@google/generative-ai';
-import { ToolChoice } from '@langchain/core/language_models/chat_models';
-import { StructuredToolInterface } from '@langchain/core/tools';
-import { isLangChainTool } from '@langchain/core/utils/function_calling';
-import {
-  isOpenAITool,
-  ToolDefinition,
-} from '@langchain/core/language_models/base';
+import { removeAdditionalProperties } from './zod_to_genai_parameters';
 import { convertToGenerativeAITools } from './common';
 import { GoogleGenerativeAIToolType } from '../types';
-import { removeAdditionalProperties } from './zod_to_genai_parameters';
 
 export function convertToolsToGenAI(
   tools: GoogleGenerativeAIToolType[],

package/src/llm/google/utils/zod_to_genai_parameters.ts

@@ -1,7 +1,3 @@
-import {
-  type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema,
-  type SchemaType as FunctionDeclarationSchemaType,
-} from '@google/generative-ai';
 import {
   InteropZodType,
   isInteropZodSchema,
@@ -10,6 +6,10 @@ import {
   type JsonSchema7Type,
   toJsonSchema,
 } from '@langchain/core/utils/json_schema';
+import {
+  type FunctionDeclarationSchema as GenerativeAIFunctionDeclarationSchema,
+  type SchemaType as FunctionDeclarationSchemaType,
+} from '@google/generative-ai';
 
 export interface GenerativeAIJsonSchema extends Record<string, unknown> {
   properties?: Record<string, GenerativeAIJsonSchema>;

package/src/llm/invoke.test.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
+import { describe, it, expect, jest } from '@jest/globals';
 import {
   AIMessage,
   AIMessageChunk,
   HumanMessage,
   ToolMessage,
 } from '@langchain/core/messages';
-import { describe, it, expect, jest } from '@jest/globals';
-import type { BaseMessage } from '@langchain/core/messages';
 import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { BaseMessage } from '@langchain/core/messages';
 import type * as t from '@/types';
-import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
 import { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
+import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
 import { ToolNode } from '@/tools/ToolNode';
 import { Providers } from '@/common';
 

package/src/llm/invoke.ts

@@ -5,8 +5,8 @@ import type { ToolCall } from '@langchain/core/messages/tool';
 import type { BaseMessage } from '@langchain/core/messages';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
-import { manualToolStreamProviders } from '@/llm/providers';
 import { annotateMessagesForLLM } from '@/tools/toolOutputReferences';
+import { manualToolStreamProviders } from '@/llm/providers';
 import { modifyDeltaProperties } from '@/messages';
 import { ChatModelStreamHandler } from '@/stream';
 import { GraphEvents, Providers } from '@/common';
@@ -51,6 +51,127 @@ export type InvokeContext = NonNullable<
  */
 export type OnChunk = (chunk: AIMessageChunk) => void | Promise<void>;
 
+function getRegisteredDefaultChatStreamHandler(
+  context?: InvokeContext
+): ChatModelStreamHandler | undefined {
+  const handler = context?.handlerRegistry?.getHandler(
+    GraphEvents.CHAT_MODEL_STREAM
+  );
+  return handler instanceof ChatModelStreamHandler ? handler : undefined;
+}
+
+function hasReasoningDetails(chunk: AIMessageChunk): boolean {
+  const reasoningDetails = chunk.additional_kwargs.reasoning_details;
+  return Array.isArray(reasoningDetails) && reasoningDetails.length > 0;
+}
+
+function removeOpenRouterFinalReasoningReplayContent({
+  current,
+  next,
+  provider,
+}: {
+  current?: AIMessageChunk;
+  next: AIMessageChunk;
+  provider: Providers;
+}): AIMessageChunk {
+  const content = getOpenRouterFinalReasoningContent({
+    current,
+    next,
+    provider,
+  });
+  if (content == null || content === next.content) {
+    return next;
+  }
+
+  return new AIMessageChunk(
+    Object.assign({}, next, {
+      content,
+    })
+  );
+}
+
+function getOpenRouterFinalReasoningContent({
+  current,
+  next,
+  provider,
+}: {
+  current?: AIMessageChunk;
+  next: AIMessageChunk;
+  provider: Providers;
+}): string | undefined {
+  if (
+    provider !== Providers.OPENROUTER ||
+    current == null ||
+    !hasReasoningDetails(next) ||
+    typeof current.content !== 'string' ||
+    current.content === '' ||
+    typeof next.content !== 'string' ||
+    next.content === ''
+  ) {
+    return undefined;
+  }
+  if (!next.content.startsWith(current.content)) {
+    return next.content;
+  }
+  return next.content.slice(current.content.length);
+}
+
+function removeReasoningDetails(
+  additionalKwargs: AIMessageChunk['additional_kwargs']
+): AIMessageChunk['additional_kwargs'] {
+  return Object.fromEntries(
+    Object.entries(additionalKwargs).filter(
+      ([key]) => key !== 'reasoning_details'
+    )
+  );
+}
+
+function getStreamHandlingChunk({
+  current,
+  next,
+  provider,
+}: {
+  current?: AIMessageChunk;
+  next: AIMessageChunk;
+  provider: Providers;
+}): AIMessageChunk | undefined {
+  const content = getOpenRouterFinalReasoningContent({
+    current,
+    next,
+    provider,
+  });
+  if (content == null) {
+    return next;
+  }
+  if (content === '') {
+    return undefined;
+  }
+  return new AIMessageChunk(
+    Object.assign({}, next, {
+      content,
+      additional_kwargs: removeReasoningDetails(next.additional_kwargs),
+    })
+  );
+}
+
+function appendStreamChunk({
+  current,
+  next,
+  provider,
+}: {
+  current?: AIMessageChunk;
+  next: AIMessageChunk;
+  provider: Providers;
+}): AIMessageChunk {
+  if (current == null) {
+    return next;
+  }
+  return concat(
+    current,
+    removeOpenRouterFinalReasoningReplayContent({ current, next, provider })
+  );
+}
+
 /**
  * Invokes a chat model with the given messages, handling both streaming and
  * non-streaming paths.
@@ -90,23 +211,62 @@ export async function attemptInvoke(
   if (model.stream) {
     const stream = await model.stream(messagesForProvider, config);
     let finalChunk: AIMessageChunk | undefined;
+    const registeredStreamHandler =
+      getRegisteredDefaultChatStreamHandler(context);
 
     if (onChunk) {
       for await (const chunk of stream) {
         await onChunk(chunk);
-        finalChunk = finalChunk ? concat(finalChunk, chunk) : chunk;
+        finalChunk = appendStreamChunk({
+          current: finalChunk,
+          next: chunk,
+          provider,
+        });
       }
-    } else {
+    } else if (registeredStreamHandler == null) {
       const metadata = config?.metadata as Record<string, unknown> | undefined;
       const streamHandler = new ChatModelStreamHandler();
       for await (const chunk of stream) {
-        await streamHandler.handle(
-          GraphEvents.CHAT_MODEL_STREAM,
-          { chunk },
-          metadata,
-          context
-        );
-        finalChunk = finalChunk ? concat(finalChunk, chunk) : chunk;
+        const handlingChunk = getStreamHandlingChunk({
+          current: finalChunk,
+          next: chunk,
+          provider,
+        });
+        if (handlingChunk != null) {
+          await streamHandler.handle(
+            GraphEvents.CHAT_MODEL_STREAM,
+            { chunk: handlingChunk },
+            metadata,
+            context
+          );
+        }
+        finalChunk = appendStreamChunk({
+          current: finalChunk,
+          next: chunk,
+          provider,
+        });
+      }
+    } else {
+      const metadata = config?.metadata as Record<string, unknown> | undefined;
+      for await (const chunk of stream) {
+        const handlingChunk = getStreamHandlingChunk({
+          current: finalChunk,
+          next: chunk,
+          provider,
+        });
+        if (handlingChunk != null && handlingChunk !== chunk) {
+          await registeredStreamHandler.handle(
+            GraphEvents.CHAT_MODEL_STREAM,
+            { chunk: handlingChunk },
+            metadata,
+            context
+          );
+        }
+        finalChunk = appendStreamChunk({
+          current: finalChunk,
+          next: chunk,
+          provider,
+        });
       }
     }
 

package/src/llm/openai/index.ts

@@ -1,18 +1,18 @@
 import { AzureOpenAI as AzureOpenAIClient } from 'openai';
 import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
 import { ChatGenerationChunk } from '@langchain/core/outputs';
+import { ToolDefinition } from '@langchain/core/language_models/base';
+import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
+import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import {
   AIMessage,
   AIMessageChunk,
   isAIMessage,
 } from '@langchain/core/messages';
-import { ToolDefinition } from '@langchain/core/language_models/base';
 import {
   convertToOpenAITool,
   isLangChainTool,
 } from '@langchain/core/utils/function_calling';
-import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
-import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import {
   getEndpoint,
   OpenAIClient,
@@ -24,7 +24,6 @@ import {
   AzureChatOpenAIResponses as OriginalAzureChatOpenAIResponses,
   AzureChatOpenAICompletions as OriginalAzureChatOpenAICompletions,
 } from '@langchain/openai';
-import type { HeaderValue, HeadersLike } from './types';
 import type {
   BaseMessage,
   BaseMessageChunk,
@@ -34,6 +33,7 @@ import type { BindToolsInput } from '@langchain/core/language_models/chat_models
 import type { ChatGeneration, ChatResult } from '@langchain/core/outputs';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
+import type { HeaderValue, HeadersLike } from './types';
 import { isReasoningModel, _convertMessagesToOpenAIParams } from './utils';
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type

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

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 import { type OpenAI as OpenAIClient } from 'openai';
-import type {
-  ChatCompletionContentPartText,
-  ChatCompletionContentPartImage,
-  ChatCompletionContentPartInputAudio,
-  ChatCompletionContentPart,
-} from 'openai/resources/chat/completions';
+import { ChatGenerationChunk } from '@langchain/core/outputs';
+import {
+  convertLangChainToolCallToOpenAI,
+  makeInvalidToolCall,
+  parseToolCall,
+} from '@langchain/core/output_parsers/openai_tools';
 import {
   AIMessage,
   AIMessageChunk,
@@ -25,24 +25,24 @@ import {
   convertToProviderContentBlock,
   isDataContentBlock,
 } from '@langchain/core/messages';
-import { ChatGenerationChunk } from '@langchain/core/outputs';
-import {
-  convertLangChainToolCallToOpenAI,
-  makeInvalidToolCall,
-  parseToolCall,
-} from '@langchain/core/output_parsers/openai_tools';
-import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
+import type {
+  ChatCompletionContentPartText,
+  ChatCompletionContentPartImage,
+  ChatCompletionContentPartInputAudio,
+  ChatCompletionContentPart,
+} from 'openai/resources/chat/completions';
 import type {
   OpenAICallOptions,
   OpenAIChatInput,
   ChatOpenAIReasoningSummary,
 } from '@langchain/openai';
-import { toLangChainContent } from '@/messages/langchain';
+import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
   OPENAI_RESPONSES_STREAMED_TOOL_CALL_ADAPTER,
 } from '@/tools/streamedToolCallSeals';
+import { toLangChainContent } from '@/messages/langchain';
 
 export type { OpenAICallOptions, OpenAIChatInput };
 

package/src/llm/openrouter/index.ts

@@ -1,12 +1,12 @@
-import { ChatOpenAI, emitStreamChunkCallback } from '@/llm/openai';
-import type { BaseMessage } from '@langchain/core/messages';
-import type { ChatGenerationChunk } from '@langchain/core/outputs';
-import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type {
   ChatOpenAICallOptions,
   OpenAIChatInput,
   OpenAIClient,
 } from '@langchain/openai';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type { ChatGenerationChunk } from '@langchain/core/outputs';
+import type { BaseMessage } from '@langchain/core/messages';
+import { ChatOpenAI, emitStreamChunkCallback } from '@/llm/openai';
 
 export type OpenRouterReasoningEffort =
   | 'xhigh'

package/src/llm/openrouter/reasoning.test.ts

@@ -1,6 +1,6 @@
-import { ChatOpenRouter } from './index';
-import type { OpenRouterReasoning, ChatOpenRouterCallOptions } from './index';
 import type { OpenAIChatInput } from '@langchain/openai';
+import type { OpenRouterReasoning, ChatOpenRouterCallOptions } from './index';
+import { ChatOpenRouter } from './index';
 
 type CreateRouterOptions = Partial<
   ChatOpenRouterCallOptions &