@librechat/agents 3.1.54 → 3.1.56

package/src/scripts/tools.ts

@@ -18,13 +18,7 @@ async function testStandardStreaming(): Promise<void> {
   const { userName, location, provider, currentDate } = await getArgs();
   const { contentParts, aggregateContent } = createContentAggregator();
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(
-      undefined,
-      undefined,
-      (name?: string) => {
-        return true;
-      }
-    ),
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_START]: {
       handle: (

package/src/specs/token-memoization.test.ts

@@ -1,39 +1,40 @@
 import { HumanMessage } from '@langchain/core/messages';
-import { createTokenCounter } from '@/utils/tokens';
+import { createTokenCounter, TokenEncoderManager } from '@/utils/tokens';
+
+jest.setTimeout(5000);
 
 describe('Token encoder memoization', () => {
-  jest.setTimeout(45000);
-
-  test('fetches BPE once and reuses encoder across counters', async () => {
-    const originalFetch = global.fetch;
-    let fetchCalls = 0;
-    global.fetch = (async (...args: Parameters<typeof fetch>) => {
-      fetchCalls += 1;
-      // Delegate to real fetch
-      return await originalFetch(...args);
-    }) as typeof fetch;
-
-    try {
-      const counter1 = await createTokenCounter();
-      const counter2 = await createTokenCounter();
-
-      const m1 = new HumanMessage('hello world');
-      const m2 = new HumanMessage('another short text');
-
-      const c11 = counter1(m1);
-      const c12 = counter1(m2);
-      const c21 = counter2(m1);
-      const c22 = counter2(m2);
-
-      expect(c11).toBeGreaterThan(0);
-      expect(c12).toBeGreaterThan(0);
-      expect(c21).toBe(c11);
-      expect(c22).toBe(c12);
-
-      // Only one fetch for the shared encoder
-      expect(fetchCalls).toBe(1);
-    } finally {
-      global.fetch = originalFetch;
-    }
+  beforeEach(() => {
+    TokenEncoderManager.reset();
+  });
+
+  test('reuses the same tokenizer across counter calls', async () => {
+    expect(TokenEncoderManager.isInitialized()).toBe(false);
+
+    const counter1 = await createTokenCounter();
+    expect(TokenEncoderManager.isInitialized()).toBe(true);
+
+    const counter2 = await createTokenCounter();
+
+    const m1 = new HumanMessage('hello world');
+    const m2 = new HumanMessage('another short text');
+
+    const c11 = counter1(m1);
+    const c12 = counter1(m2);
+    const c21 = counter2(m1);
+    const c22 = counter2(m2);
+
+    expect(c11).toBeGreaterThan(0);
+    expect(c12).toBeGreaterThan(0);
+    expect(c21).toBe(c11);
+    expect(c22).toBe(c12);
+  });
+
+  test('reset clears cached tokenizers', async () => {
+    await createTokenCounter();
+    expect(TokenEncoderManager.isInitialized()).toBe(true);
+
+    TokenEncoderManager.reset();
+    expect(TokenEncoderManager.isInitialized()).toBe(false);
   });
 });

package/src/specs/tokens.test.ts

@@ -0,0 +1,64 @@
+import { HumanMessage } from '@langchain/core/messages';
+import {
+  encodingForModel,
+  createTokenCounter,
+  TokenEncoderManager,
+} from '@/utils/tokens';
+
+describe('encodingForModel', () => {
+  test('returns claude for Claude model strings', () => {
+    expect(encodingForModel('claude-3-5-sonnet-20241022')).toBe('claude');
+    expect(encodingForModel('claude-3-haiku-20240307')).toBe('claude');
+  });
+
+  test('handles Bedrock Claude ARNs', () => {
+    expect(encodingForModel('anthropic.claude-3-5-sonnet-20241022-v2:0')).toBe(
+      'claude'
+    );
+  });
+
+  test('is case-insensitive', () => {
+    expect(encodingForModel('CLAUDE-3-HAIKU')).toBe('claude');
+    expect(encodingForModel('Claude-3-Opus')).toBe('claude');
+  });
+
+  test('returns o200k_base for non-Claude models', () => {
+    expect(encodingForModel('gpt-4o')).toBe('o200k_base');
+    expect(encodingForModel('gemini-2.0-flash')).toBe('o200k_base');
+    expect(encodingForModel('mistral-large')).toBe('o200k_base');
+  });
+
+  test('returns o200k_base for empty string', () => {
+    expect(encodingForModel('')).toBe('o200k_base');
+  });
+});
+
+describe('createTokenCounter with different encodings', () => {
+  beforeEach(() => {
+    TokenEncoderManager.reset();
+  });
+
+  test('claude encoding produces valid token counts', async () => {
+    const counter = await createTokenCounter('claude');
+    const msg = new HumanMessage('Hello, world!');
+    const count = counter(msg);
+    expect(count).toBeGreaterThan(0);
+  });
+
+  test('o200k_base encoding produces valid token counts', async () => {
+    const counter = await createTokenCounter('o200k_base');
+    const msg = new HumanMessage('Hello, world!');
+    const count = counter(msg);
+    expect(count).toBeGreaterThan(0);
+  });
+
+  test('both encodings can be initialized and used independently', async () => {
+    const claudeCounter = await createTokenCounter('claude');
+    const o200kCounter = await createTokenCounter('o200k_base');
+    expect(TokenEncoderManager.isInitialized()).toBe(true);
+
+    const msg = new HumanMessage('Test message for both encodings');
+    expect(claudeCounter(msg)).toBeGreaterThan(0);
+    expect(o200kCounter(msg)).toBeGreaterThan(0);
+  });
+});

package/src/stream.ts

@@ -576,6 +576,16 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         type: ToolCallTypes.TOOL_CALL,
       };
 
+      const auth =
+        contentPart.tool_call.auth ?? existingContent?.tool_call?.auth;
+      const expiresAt =
+        contentPart.tool_call.expires_at ??
+        existingContent?.tool_call?.expires_at;
+      if (auth != null) {
+        newToolCall.auth = auth;
+        newToolCall.expires_at = expiresAt;
+      }
+
       if (finalUpdate) {
         newToolCall.progress = 1;
         newToolCall.output = contentPart.tool_call.output;
@@ -713,6 +723,8 @@ export function createContentAggregator(): t.ContentAggregatorResult {
               args: toolCallDelta.args ?? '',
               name: toolCallDelta.name,
               id: toolCallId,
+              auth: runStepDelta.delta.auth,
+              expires_at: runStepDelta.delta.expires_at,
             },
           };
 

package/src/types/graph.ts

@@ -300,6 +300,8 @@ export type PartMetadata = {
   status?: string;
   action?: boolean;
   output?: string;
+  auth?: string;
+  expires_at?: number;
 };
 
 export type ModelEndData =

package/src/types/stream.ts

@@ -164,6 +164,8 @@ export type ToolCallsDetails = {
 export type ToolCallDelta = {
   type: StepTypes;
   tool_calls?: ToolCallChunk[]; // #new
+  auth?: string;
+  expires_at?: number;
 };
 
 export type AgentToolCall =

package/src/utils/tokens.ts

@@ -1,7 +1,34 @@
-import { Tiktoken } from 'js-tiktoken/lite';
+import { Tokenizer } from 'ai-tokenizer';
 import type { BaseMessage } from '@langchain/core/messages';
 import { ContentTypes } from '@/common/enum';
 
+export type EncodingName = 'o200k_base' | 'claude';
+
+const tokenizers: Partial<Record<EncodingName, Tokenizer>> = {};
+
+async function getTokenizer(
+  encoding: EncodingName = 'o200k_base'
+): Promise<Tokenizer> {
+  const cached = tokenizers[encoding];
+  if (cached) {
+    return cached;
+  }
+  const data =
+    encoding === 'claude'
+      ? await import('ai-tokenizer/encoding/claude')
+      : await import('ai-tokenizer/encoding/o200k_base');
+  const instance = new Tokenizer(data);
+  tokenizers[encoding] = instance;
+  return instance;
+}
+
+export function encodingForModel(model: string): EncodingName {
+  if (model.toLowerCase().includes('claude')) {
+    return 'claude';
+  }
+  return 'o200k_base';
+}
+
 export function getTokenCountForMessage(
   message: BaseMessage,
   getTokenCount: (text: string) => number
@@ -60,70 +87,32 @@ export function getTokenCountForMessage(
   return numTokens;
 }
 
-let encoderPromise: Promise<Tiktoken> | undefined;
-let tokenCounterPromise: Promise<(message: BaseMessage) => number> | undefined;
-
-async function getSharedEncoder(): Promise<Tiktoken> {
-  if (encoderPromise) {
-    return encoderPromise;
-  }
-  encoderPromise = (async (): Promise<Tiktoken> => {
-    const res = await fetch('https://tiktoken.pages.dev/js/o200k_base.json');
-    const o200k_base = await res.json();
-    return new Tiktoken(o200k_base);
-  })();
-  return encoderPromise;
-}
-
 /**
- * Creates a singleton token counter function that reuses the same encoder instance.
- * This avoids creating multiple function closures and prevents potential memory issues.
+ * Creates a token counter function using the specified encoding.
+ * Lazily loads the encoding data on first use via dynamic import.
  */
-export const createTokenCounter = async (): Promise<
-  (message: BaseMessage) => number
-> => {
-  if (tokenCounterPromise) {
-    return tokenCounterPromise;
-  }
-
-  tokenCounterPromise = (async (): Promise<
-    (message: BaseMessage) => number
-  > => {
-    const enc = await getSharedEncoder();
-    const countTokens = (text: string): number => enc.encode(text).length;
-    return (message: BaseMessage): number =>
-      getTokenCountForMessage(message, countTokens);
-  })();
-
-  return tokenCounterPromise;
+export const createTokenCounter = async (
+  encoding: EncodingName = 'o200k_base'
+): Promise<(message: BaseMessage) => number> => {
+  const tok = await getTokenizer(encoding);
+  const countTokens = (text: string): number => tok.count(text);
+  return (message: BaseMessage): number =>
+    getTokenCountForMessage(message, countTokens);
 };
 
-/**
- * Utility to manage the token encoder lifecycle explicitly.
- * Useful for applications that need fine-grained control over resource management.
- */
+/** Utility to manage the token encoder lifecycle explicitly. */
 export const TokenEncoderManager = {
-  /**
-   * Pre-initializes the encoder. This can be called during app startup
-   * to avoid lazy loading delays later.
-   */
   async initialize(): Promise<void> {
-    await getSharedEncoder();
+    // No-op: ai-tokenizer is synchronously initialized from bundled data.
   },
 
-  /**
-   * Clears the cached encoder and token counter.
-   * Useful for testing or when you need to force a fresh reload.
-   */
   reset(): void {
-    encoderPromise = undefined;
-    tokenCounterPromise = undefined;
+    for (const key of Object.keys(tokenizers)) {
+      delete tokenizers[key as EncodingName];
+    }
   },
 
-  /**
-   * Checks if the encoder has been initialized.
-   */
   isInitialized(): boolean {
-    return encoderPromise !== undefined;
+    return Object.keys(tokenizers).length > 0;
   },
 };