@librechat/agents 3.1.55 → 3.1.57

package/src/messages/format.ts

@@ -6,7 +6,6 @@ import {
   BaseMessage,
   HumanMessage,
   SystemMessage,
-  getBufferString,
 } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
@@ -998,6 +997,113 @@ export function shiftIndexTokenCountMap(
   return shiftedMap;
 }
 
+/** Block types that contain binary image data and must be preserved structurally. */
+const IMAGE_BLOCK_TYPES = new Set(['image_url', 'image']);
+
+/** Checks whether a BaseMessage is a tool-role message. */
+const isToolMessage = (m: BaseMessage): boolean =>
+  m instanceof ToolMessage || ('role' in m && (m as any).role === 'tool');
+
+/** Flushes accumulated text chunks into `parts` as a single text block. */
+function flushTextChunks(
+  textChunks: string[],
+  parts: MessageContentComplex[]
+): void {
+  if (textChunks.length === 0) {
+    return;
+  }
+  parts.push({
+    type: ContentTypes.TEXT,
+    text: textChunks.join('\n'),
+  } as MessageContentComplex);
+  textChunks.length = 0;
+}
+
+/**
+ * Appends a single message's content to the running `textChunks` / `parts`
+ * accumulators.  Image blocks are shallow-copied into `parts` as-is so that
+ * binary data (base64 images) never becomes text tokens.  All other block
+ * types are serialized to text — unrecognized types are JSON-serialized
+ * rather than silently dropped.
+ *
+ * When `content` is an array containing tool_use blocks, `tool_calls` is NOT
+ * additionally serialized (avoiding double output).  `tool_calls` is used as
+ * a fallback when `content` is a plain string or an array with no tool_use.
+ */
+function appendMessageContent(
+  msg: BaseMessage,
+  role: string,
+  textChunks: string[],
+  parts: MessageContentComplex[]
+): void {
+  const { content } = msg;
+
+  if (typeof content === 'string') {
+    if (content) {
+      textChunks.push(`${role}: ${content}`);
+    }
+    appendToolCalls(msg, role, textChunks);
+    return;
+  }
+
+  if (!Array.isArray(content)) {
+    appendToolCalls(msg, role, textChunks);
+    return;
+  }
+
+  let hasToolUseBlock = false;
+
+  for (const block of content as ExtendedMessageContent[]) {
+    if (IMAGE_BLOCK_TYPES.has(block.type ?? '')) {
+      flushTextChunks(textChunks, parts);
+      parts.push({ ...block } as MessageContentComplex);
+      continue;
+    }
+
+    if (block.type === 'tool_use') {
+      hasToolUseBlock = true;
+      textChunks.push(
+        `${role}: [tool_use] ${String(block.name ?? '')} ${JSON.stringify(block.input ?? {})}`
+      );
+      continue;
+    }
+
+    const text = block.text ?? block.input;
+    if (typeof text === 'string' && text) {
+      textChunks.push(`${role}: ${text}`);
+      continue;
+    }
+
+    // Fallback: serialize unrecognized block types to preserve context
+    if (block.type != null && block.type !== '') {
+      textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
+    }
+  }
+
+  // If content array had no tool_use blocks, fall back to tool_calls metadata
+  // (handles edge case: empty content array with tool_calls populated)
+  if (!hasToolUseBlock) {
+    appendToolCalls(msg, role, textChunks);
+  }
+}
+
+function appendToolCalls(
+  msg: BaseMessage,
+  role: string,
+  textChunks: string[]
+): void {
+  if (role !== 'AI') {
+    return;
+  }
+  const aiMsg = msg as AIMessage;
+  if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) {
+    return;
+  }
+  for (const tc of aiMsg.tool_calls) {
+    textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+  }
+}
+
 /**
  * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
  * Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,
@@ -1021,19 +1127,27 @@ export function ensureThinkingBlockInMessages(
     return messages;
   }
 
-  // If the last message is already a HumanMessage, there is no trailing tool
-  // sequence to convert — return early to preserve prompt caching and avoid
-  // redundant token overhead from re-processing the entire history.
-  const lastMsg = messages[messages.length - 1];
-  const lastIsHuman =
-    lastMsg instanceof HumanMessage ||
-    ('role' in lastMsg && (lastMsg as any).role === 'user');
-  if (lastIsHuman) {
+  // Find the last HumanMessage. Only the trailing sequence after it needs
+  // validation — earlier messages are history already accepted by the provider.
+  let lastHumanIndex = -1;
+  for (let k = messages.length - 1; k >= 0; k--) {
+    const m = messages[k];
+    if (
+      m instanceof HumanMessage ||
+      ('role' in m && (m as any).role === 'user')
+    ) {
+      lastHumanIndex = k;
+      break;
+    }
+  }
+
+  if (lastHumanIndex === messages.length - 1) {
     return messages;
   }
 
-  const result: BaseMessage[] = [];
-  let i = 0;
+  const result: BaseMessage[] =
+    lastHumanIndex >= 0 ? messages.slice(0, lastHumanIndex + 1) : [];
+  let i = lastHumanIndex + 1;
 
   while (i < messages.length) {
     const msg = messages[i];
@@ -1059,21 +1173,24 @@ export function ensureThinkingBlockInMessages(
     let hasThinkingBlock = false;
 
     if (contentIsArray && aiMsg.content.length > 0) {
-      const content = aiMsg.content as ExtendedMessageContent[];
-      hasToolUse =
-        hasToolUse ||
-        content.some((c) => typeof c === 'object' && c.type === 'tool_use');
-      // Check ALL content blocks for thinking/reasoning, not just [0].
-      // Bedrock may emit a whitespace text chunk before the thinking block,
-      // pushing the reasoning_content to index 1+.
-      hasThinkingBlock = content.some(
-        (c) =>
-          typeof c === 'object' &&
-          (c.type === ContentTypes.THINKING ||
-            c.type === ContentTypes.REASONING_CONTENT ||
-            c.type === ContentTypes.REASONING ||
-            c.type === 'redacted_thinking')
-      );
+      for (const c of aiMsg.content as ExtendedMessageContent[]) {
+        if (typeof c !== 'object') {
+          continue;
+        }
+        if (c.type === 'tool_use') {
+          hasToolUse = true;
+        } else if (
+          c.type === ContentTypes.THINKING ||
+          c.type === ContentTypes.REASONING_CONTENT ||
+          c.type === ContentTypes.REASONING ||
+          c.type === 'redacted_thinking'
+        ) {
+          hasThinkingBlock = true;
+        }
+        if (hasToolUse && hasThinkingBlock) {
+          break;
+        }
+      }
     }
 
     // Bedrock also stores reasoning in additional_kwargs (may not be in content array)
@@ -1100,28 +1217,22 @@ export function ensureThinkingBlockInMessages(
         continue;
       }
 
-      // Collect the AI message and any following tool messages
-      const toolSequence: BaseMessage[] = [msg];
-      let j = i + 1;
+      // Build structured content in a single pass over the AI + following
+      // ToolMessages — preserves image blocks as-is to avoid serializing
+      // binary data as text (which caused 174× token amplification).
+      const parts: MessageContentComplex[] = [];
+      const textChunks: string[] = ['[Previous agent context]'];
+
+      appendMessageContent(msg, 'AI', textChunks, parts);
 
-      // Look ahead for tool messages that belong to this AI message
-      const isToolMsg = (m: BaseMessage): boolean =>
-        m instanceof ToolMessage || ('role' in m && (m as any).role === 'tool');
-      while (j < messages.length && isToolMsg(messages[j])) {
-        toolSequence.push(messages[j]);
+      let j = i + 1;
+      while (j < messages.length && isToolMessage(messages[j])) {
+        appendMessageContent(messages[j], 'Tool', textChunks, parts);
         j++;
       }
 
-      // Convert the sequence to a buffer string and wrap in a HumanMessage
-      // This avoids the thinking block requirement which only applies to AI messages
-      const bufferString = getBufferString(toolSequence);
-      result.push(
-        new HumanMessage({
-          content: `[Previous agent context]\n${bufferString}`,
-        })
-      );
-
-      // Skip the messages we've processed
+      flushTextChunks(textChunks, parts);
+      result.push(new HumanMessage({ content: parts }));
       i = j;
     } else {
       // Keep the message as is

package/src/run.ts

@@ -16,9 +16,9 @@ import {
   createCompletionTitleRunnable,
   createTitleRunnable,
 } from '@/utils/title';
+import { createTokenCounter, encodingForModel } from '@/utils/tokens';
 import { GraphEvents, Callback, TitleMethod } from '@/common';
 import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
-import { createTokenCounter } from '@/utils/tokens';
 import { StandardGraph } from '@/graphs/Graph';
 import { HandlerRegistry } from '@/events';
 import { isOpenAILike } from '@/utils/llm';
@@ -166,7 +166,11 @@ export class Run<_T extends t.BaseGraphState> {
   ): Promise<Run<T>> {
     /** Create tokenCounter if indexTokenCountMap is provided but tokenCounter is not */
     if (config.indexTokenCountMap && !config.tokenCounter) {
-      config.tokenCounter = await createTokenCounter();
+      const gc = config.graphConfig;
+      const clientOpts =
+        'agents' in gc ? gc.agents[0]?.clientOptions : gc.clientOptions;
+      const model = (clientOpts as { model?: string } | undefined)?.model ?? '';
+      config.tokenCounter = await createTokenCounter(encodingForModel(model));
     }
     return new Run<T>(config);
   }

package/src/scripts/bedrock-cache-debug.ts

@@ -9,13 +9,13 @@
  */
 import { config } from 'dotenv';
 config();
-import { HumanMessage } from '@langchain/core/messages';
-import type { AIMessageChunk } from '@langchain/core/messages';
 import { concat } from '@langchain/core/utils/stream';
+import { HumanMessage } from '@langchain/core/messages';
 import {
-  ConverseStreamCommand,
   BedrockRuntimeClient,
+  ConverseStreamCommand,
 } from '@aws-sdk/client-bedrock-runtime';
+import type { AIMessageChunk } from '@langchain/core/messages';
 import { CustomChatBedrockConverse } from '@/llm/bedrock';
 
 const region = process.env.BEDROCK_AWS_REGION ?? 'us-east-1';
@@ -62,12 +62,12 @@ async function rawSdkCall(): Promise<void> {
         console.log('\nSpecific cache fields:');
         console.log(
           '  cacheReadInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheReadInputTokens
         );
         console.log(
           '  cacheWriteInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheWriteInputTokens
         );
       }
@@ -98,12 +98,12 @@ async function rawSdkCall(): Promise<void> {
         console.log('\nSpecific cache fields:');
         console.log(
           '  cacheReadInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheReadInputTokens
         );
         console.log(
           '  cacheWriteInputTokens:',
-          (event.metadata.usage as Record<string, unknown>)
+          (event.metadata.usage as unknown as Record<string, unknown>)
             ?.cacheWriteInputTokens
         );
       }
@@ -177,17 +177,17 @@ async function wrapperStreamCallWithCachePoint(): Promise<void> {
         const chunk = handleConverseStreamMetadata(event.metadata, {
           streamUsage: true,
         });
+        const msg = chunk.message as AIMessageChunk;
         console.log(
           'handleConverseStreamMetadata output usage_metadata:',
-          JSON.stringify(chunk.message.usage_metadata)
+          JSON.stringify(msg.usage_metadata)
         );
 
-        const hasDetails =
-          chunk.message.usage_metadata?.input_token_details != null;
+        const hasDetails = msg.usage_metadata?.input_token_details != null;
         console.log(
           `Has input_token_details: ${hasDetails}`,
           hasDetails
-            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            ? JSON.stringify(msg.usage_metadata!.input_token_details)
             : '(MISSING - BUG!)'
         );
       }
@@ -216,17 +216,17 @@ async function wrapperStreamCallWithCachePoint(): Promise<void> {
         const chunk = handleConverseStreamMetadata(event.metadata, {
           streamUsage: true,
         });
+        const msg = chunk.message as AIMessageChunk;
         console.log(
           'handleConverseStreamMetadata output usage_metadata:',
-          JSON.stringify(chunk.message.usage_metadata)
+          JSON.stringify(msg.usage_metadata)
         );
 
-        const hasDetails =
-          chunk.message.usage_metadata?.input_token_details != null;
+        const hasDetails = msg.usage_metadata?.input_token_details != null;
         console.log(
           `Has input_token_details: ${hasDetails}`,
           hasDetails
-            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            ? JSON.stringify(msg.usage_metadata!.input_token_details)
             : '(MISSING - BUG!)'
         );
       }

package/src/scripts/code_exec_multi_session.ts

@@ -44,8 +44,8 @@ function printSessionContext(run: Run<t.IState>, label: string): void {
   }
 
   console.log(`  Latest session_id: ${session.session_id}`);
-  console.log(`  Files tracked: ${session.files.length}`);
-  for (const file of session.files) {
+  console.log(`  Files tracked: ${session.files?.length ?? 0}`);
+  for (const file of session.files ?? []) {
     console.log(`    - ${file.name} (session: ${file.session_id})`);
   }
 }
@@ -199,25 +199,20 @@ Tell me what version it shows.
     | undefined;
 
   if (finalSession) {
-    const uniqueSessionIds = new Set(
-      finalSession.files.map((f) => f.session_id)
-    );
-    console.log(`\nTotal files tracked: ${finalSession.files.length}`);
+    const files = finalSession.files ?? [];
+    const uniqueSessionIds = new Set(files.map((f) => f.session_id));
+    console.log(`\nTotal files tracked: ${files.length}`);
     console.log(`Unique session_ids: ${uniqueSessionIds.size}`);
     console.log('\nFiles:');
-    for (const file of finalSession.files) {
+    for (const file of files) {
       console.log(
         `  - ${file.name} (session: ${file.session_id?.slice(0, 20)}...)`
       );
     }
 
     // Verify expectations
-    const fileACount = finalSession.files.filter(
-      (f) => f.name === 'file_a.txt'
-    ).length;
-    const fileBCount = finalSession.files.filter(
-      (f) => f.name === 'file_b.txt'
-    ).length;
+    const fileACount = files.filter((f) => f.name === 'file_a.txt').length;
+    const fileBCount = files.filter((f) => f.name === 'file_b.txt').length;
 
     console.log('\n✓ Checks:');
     console.log(`  file_a.txt count: ${fileACount} (expected: 1, latest wins)`);

package/src/scripts/image.ts

@@ -1,4 +1,4 @@
-// src/scripts/cli.ts
+// src/scripts/image.ts
 import { config } from 'dotenv';
 config();
 import { HumanMessage, AIMessage, BaseMessage } from '@langchain/core/messages';
@@ -10,6 +10,7 @@ import {
   ModelEndHandler,
   createMetadataAggregator,
 } from '@/events';
+// @ts-expect-error — example module not in current codebase
 import { fetchRandomImageTool, fetchRandomImageURL } from '@/tools/example';
 import { getLLMConfig } from '@/utils/llmConfig';
 import { getArgs } from '@/scripts/args';

package/src/scripts/multi-agent-parallel-start.ts

@@ -25,8 +25,7 @@ async function testParallelFromStart() {
   console.log('Testing Parallel From Start Multi-Agent System...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   // Define two agents - both have NO incoming edges, so they run in parallel from the start
   const agents: t.AgentInputs[] = [
@@ -253,8 +252,8 @@ async function testParallelFromStart() {
     console.log('Final content parts:', contentParts.length, 'parts');
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log('\n=== Content Metadata Map (separate from content) ===');
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (separate from content) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
 
     await sleep(3000);
   } catch (error) {

package/src/scripts/multi-agent-sequence.ts

@@ -22,8 +22,7 @@ async function testSequentialMultiAgent() {
   console.log('Testing Sequential Multi-Agent System (A → B → C)...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   // Define three simple agents
   const agents: t.AgentInputs[] = [
@@ -198,8 +197,8 @@ async function testSequentialMultiAgent() {
     console.log(`Total content parts: ${contentParts.length}`);
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log('\n=== Content Metadata Map (separate from content) ===');
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (separate from content) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
 
     // Display the sequential responses
     const aiMessages = conversationHistory.filter(

package/src/scripts/single-agent-metadata-test.ts

@@ -20,8 +20,7 @@ async function testSingleAgent() {
   console.log('Testing Single Agent with Metadata Logging...\n');
 
   // Set up content aggregator
-  const { contentParts, aggregateContent, contentMetadataMap } =
-    createContentAggregator();
+  const { contentParts, aggregateContent, stepMap } = createContentAggregator();
 
   const startTime = Date.now();
 
@@ -183,10 +182,8 @@ async function testSingleAgent() {
     console.log('Final content parts:', contentParts.length, 'parts');
     console.log('\n=== Content Parts (clean, no metadata) ===');
     console.dir(contentParts, { depth: null });
-    console.log(
-      '\n=== Content Metadata Map (should be empty for single-agent) ==='
-    );
-    console.dir(Object.fromEntries(contentMetadataMap), { depth: null });
+    console.log('\n=== Step Map (should be empty for single-agent) ===');
+    console.dir(Object.fromEntries(stepMap), { depth: null });
     console.log('====================================\n');
 
     await sleep(3000);

package/src/scripts/test-tool-before-handoff-role-order.ts

@@ -42,10 +42,9 @@ async function testToolBeforeHandoffRoleOrder(): Promise<void> {
   let handoffOccurred = false;
 
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(async () => {
       toolCallCount++;
-      console.log(`\n  Tool completed: ${name} (total: ${toolCallCount})`);
-      return true;
+      console.log(`\n  Tool completed (total: ${toolCallCount})`);
     }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),

package/src/scripts/test-tools-before-handoff.ts

@@ -28,9 +28,8 @@ async function testToolsBeforeHandoff() {
 
   // Create custom handlers
   const customHandlers = {
-    [GraphEvents.TOOL_END]: new ToolEndHandler(undefined, (name?: string) => {
-      console.log(`\n✅ Tool completed: ${name}`);
-      return true;
+    [GraphEvents.TOOL_END]: new ToolEndHandler(async () => {
+      console.log('\n✅ Tool completed');
     }),
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(),
     [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),

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);
+  });
+});