@librechat/agents 1.9.94 → 1.9.96

package/dist/types/splitStream.d.ts

@@ -0,0 +1,35 @@
+import type * as t from '@/types';
+import { ContentTypes } from '@/common';
+export declare const SEPARATORS: string[];
+export declare class SplitStreamHandler {
+    private inCodeBlock;
+    private inThinkBlock;
+    private accumulate;
+    tokens: string[];
+    lastToken: string;
+    reasoningTokens: string[];
+    currentStepId?: string;
+    currentMessageId?: string;
+    currentType?: ContentTypes.TEXT | ContentTypes.THINK;
+    currentLength: number;
+    reasoningKey: 'reasoning_content' | 'reasoning';
+    currentIndex: number;
+    blockThreshold: number;
+    /** The run ID AKA the Message ID associated with the complete generation */
+    runId: string;
+    handlers?: t.SplitStreamHandlers;
+    constructor({ runId, handlers, accumulate, reasoningKey, blockThreshold, }: {
+        runId: string;
+        accumulate?: boolean;
+        handlers: t.SplitStreamHandlers;
+        blockThreshold?: number;
+        reasoningKey?: 'reasoning_content' | 'reasoning';
+    });
+    getMessageId: () => string | undefined;
+    createMessageStep: (type?: ContentTypes.TEXT | ContentTypes.THINK) => [string, string];
+    dispatchRunStep: (stepId: string, stepDetails: t.StepDetails) => void;
+    dispatchMessageDelta: (stepId: string, delta: t.MessageDelta) => void;
+    dispatchReasoningDelta: (stepId: string, delta: t.ReasoningDelta) => void;
+    handleContent: (content: string, stepId: string, _type: ContentTypes.TEXT | ContentTypes.THINK) => void;
+    handle(chunk?: t.CustomChunk): void;
+}

package/dist/types/types/stream.d.ts

@@ -1,7 +1,8 @@
+import type OpenAITypes from 'openai';
 import type { MessageContentImageUrl, MessageContentText, ToolMessage, BaseMessage } from '@langchain/core/messages';
 import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
-import { StepTypes, ContentTypes } from '@/common/enum';
+import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
 export type HandleLLMEnd = (output: LLMResult, runId: string, parentRunId?: string, tags?: string[]) => void;
 export type MetadataAggregatorResult = {
     handleLLMEnd: HandleLLMEnd;
@@ -36,7 +37,7 @@ export type RunStep = {
     index: number;
     stepIndex?: number;
     stepDetails: StepDetails;
-    usage: null | {};
+    usage?: null | {};
 };
 /**
  * Represents a run step delta i.e. any changed fields on a run step during
@@ -139,16 +140,65 @@ export interface MessageDelta {
      */
     tool_call_ids?: string[];
 }
+/**
+ * Represents a reasoning delta i.e. any changed fields on a message during
+ * streaming.
+ */
+export interface ReasoningDeltaEvent {
+    /**
+     * The identifier of the message, which can be referenced in API endpoints.
+     */
+    id: string;
+    /**
+     * The delta containing the fields that have changed.
+     */
+    delta: ReasoningDelta;
+}
+/**
+ * The reasoning delta containing the fields that have changed on the Message.
+ */
+export interface ReasoningDelta {
+    /**
+     * The content of the message in array of text and/or images.
+     */
+    content?: MessageContentComplex[];
+}
 export type MessageDeltaUpdate = {
     type: ContentTypes.TEXT;
     text: string;
     tool_call_ids?: string[];
 };
-export type ContentType = 'text' | 'image_url' | 'tool_call' | string;
+export type ReasoningDeltaUpdate = {
+    type: ContentTypes.THINK;
+    think: string;
+};
+export type ContentType = 'text' | 'image_url' | 'tool_call' | 'think' | string;
 export type MessageContentComplex = (MessageContentText | MessageContentImageUrl | (Record<string, any> & {
-    type?: 'text' | 'image_url' | string;
+    type?: 'text' | 'image_url' | 'think' | string;
 }) | (Record<string, any> & {
     type?: never;
 })) & {
     tool_call_ids?: string[];
 };
+export type CustomChunk = Partial<OpenAITypes.ChatCompletionChunk> & {
+    choices?: Partial<Array<Partial<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice> & {
+        delta?: Partial<OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice.Delta> & {
+            reasoning?: string | null;
+            reasoning_content?: string | null;
+        };
+    }>>;
+};
+export type SplitStreamHandlers = Partial<{
+    [GraphEvents.ON_RUN_STEP]: ({ event, data }: {
+        event: GraphEvents;
+        data: RunStep;
+    }) => void;
+    [GraphEvents.ON_MESSAGE_DELTA]: ({ event, data }: {
+        event: GraphEvents;
+        data: MessageDeltaEvent;
+    }) => void;
+    [GraphEvents.ON_REASONING_DELTA]: ({ event, data }: {
+        event: GraphEvents;
+        data: ReasoningDeltaEvent;
+    }) => void;
+}>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "1.9.94",
+  "version": "1.9.96",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -70,16 +70,16 @@
     "@aws-crypto/sha256-js": "^5.2.0",
     "@aws-sdk/credential-provider-node": "^3.613.0",
     "@aws-sdk/types": "^3.609.0",
-    "@langchain/anthropic": "^0.3.11",
+    "@langchain/anthropic": "^0.3.12",
     "@langchain/aws": "^0.1.3",
-    "@langchain/community": "^0.3.14",
-    "@langchain/core": "^0.3.26",
-    "@langchain/google-genai": "^0.1.6",
-    "@langchain/google-vertexai": "^0.1.6",
-    "@langchain/langgraph": "^0.2.34",
+    "@langchain/community": "^0.3.27",
+    "@langchain/core": "^0.3.36",
+    "@langchain/google-genai": "^0.1.7",
+    "@langchain/google-vertexai": "^0.1.8",
+    "@langchain/langgraph": "^0.2.41",
     "@langchain/mistralai": "^0.0.26",
-    "@langchain/ollama": "^0.1.1",
-    "@langchain/openai": "^0.3.14",
+    "@langchain/ollama": "^0.1.5",
+    "@langchain/openai": "^0.4.2",
     "@smithy/eventstream-codec": "^2.2.0",
     "@smithy/protocol-http": "^3.0.6",
     "@smithy/signature-v4": "^2.0.10",
@@ -108,7 +108,7 @@
     "@types/babel__generator": "^7.6.8",
     "@types/babel__template": "^7.4.4",
     "@types/istanbul-lib-report": "^3.0.3",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^29.5.14",
     "@types/node": "^20.14.11",
     "@types/rollup": "^0.54.0",
     "@types/yargs-parser": "^21.0.3",
@@ -132,7 +132,7 @@
     "rollup-plugin-cleaner": "^1.0.0",
     "rollup-plugin-obfuscator": "^1.1.0",
     "rollup-plugin-visualizer": "^5.12.0",
-    "ts-jest": "^29.2.0",
+    "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "ts-node-dev": "^2.0.0",
     "tsc-alias": "^1.8.10",

package/src/common/enum.ts

@@ -15,6 +15,8 @@ export enum GraphEvents {
   ON_RUN_STEP_COMPLETED = 'on_run_step_completed',
   /** [Custom] Delta events for messages */
   ON_MESSAGE_DELTA = 'on_message_delta',
+  /** [Custom] Reasoning Delta events for messages */
+  ON_REASONING_DELTA = 'on_reasoning_delta',
 
   /* Official Events */
 
@@ -101,6 +103,7 @@ export enum StepTypes {
 
 export enum ContentTypes {
   TEXT = 'text',
+  THINK = 'think',
   TOOL_CALL = 'tool_call',
   IMAGE_FILE = 'image_file',
   IMAGE_URL = 'image_url',

package/src/graphs/Graph.ts

@@ -76,7 +76,7 @@ export class StandardGraph extends Graph<
   GraphNode
 > {
   private graphState: t.GraphStateChannels<t.BaseGraphState>;
-  private clientOptions: t.ClientOptions;
+  clientOptions: t.ClientOptions;
   boundModel: Runnable;
   /** The last recorded timestamp that a stream API call was invoked */
   lastStreamCall: number | undefined;

package/src/index.ts

@@ -1,6 +1,7 @@
 /* Main Operations */
 export * from './run';
 export * from './stream';
+export * from './splitStream';
 export * from './events';
 export * from './messages';
 

package/src/mockStream.ts

@@ -0,0 +1,99 @@
+/* eslint-disable no-console */
+// import { nanoid } from 'nanoid';
+import type OpenAITypes from 'openai';
+import type * as t from '@/types';
+// import { SplitStreamHandler } from '@/splitStream';
+// import { GraphEvents } from '@/common';
+import { sleep } from '@/utils';
+
+const choiceProps: OpenAITypes.Chat.Completions.ChatCompletionChunk.Choice = { finish_reason: null, index: 0, delta: {} };
+const reasoningSplitRegex = /(?<=\s+)|(?=\s+)/;
+const contentSplitRegex = /(?<=<\/?think>)|(?=<\/?think>)|(?<=\s+)|(?=\s+)/;
+export const createMockStream = (options: {
+  text?: string;
+  reasoningText?: string;
+  streamRate?: number;
+  reasoningKey?: 'reasoning' | 'reasoning_content';
+} = {}) => {
+  const {
+    text,
+    reasoningText,
+    streamRate = 25,
+    reasoningKey = 'reasoning_content'
+  } = options;
+
+  return async function* mockOpenAIStream(): AsyncGenerator<t.CustomChunk> {
+    const content = text ?? `Here's a sample message that includes code:
+\`\`\`python
+def hello_world():
+    print("Hello, World!")
+    # This is a long code block
+    # That shouldn't be split
+    return True
+\`\`\`
+Now we're back to regular text. This is a very long sentence that should probably be split at some point because it exceeds our threshold and contains multiple natural breaking points. Let's see how it handles this case properly.
+
+Here's another code block:
+\`\`\`javascript
+console.log("Another test");
+// More code here
+\`\`\`
+And finally some more regular text to test our splitting logic.`;
+
+    if (reasoningText != null && reasoningText) {
+      // Split reasoning text into "token-like" chunks
+      const reasoningTokens = reasoningText.split(reasoningSplitRegex);
+      for (const token of reasoningTokens) {
+        yield {
+          choices: [{
+            ...choiceProps,
+            delta: {
+              [reasoningKey]: token,
+            },
+          }]
+        };
+        await sleep(streamRate);
+      }
+    }
+
+    // Split main content into "token-like" chunks
+    const tokens = content.split(contentSplitRegex);
+    for (const token of tokens) {
+      yield {
+        choices: [{
+          ...choiceProps,
+          delta: {
+            content: token
+          }
+        }]
+      };
+      await sleep(streamRate);
+    }
+  };
+};
+
+/**
+(async function testStream(): Promise<void> {
+  const runId = nanoid();
+
+  const streamHandler = new SplitStreamHandler({
+    runId,
+    handlers: {
+      [GraphEvents.ON_RUN_STEP]: (data): void => {
+        console.dir(data, { depth: null });
+      },
+      [GraphEvents.ON_MESSAGE_DELTA]: (): void => {
+        // console.dir(data, { depth: null });
+      },
+    },
+  });
+  const stream = createMockStream({
+    reasoningText: 'This is a test reasoning text.',
+    streamRate: 5,
+  })();
+
+  for await (const chunk of stream) {
+    streamHandler.handle(chunk);
+  }
+})();
+ */