@librechat/agents 3.2.64 → 3.2.65

package/dist/types/tools/search/types.d.ts

@@ -2,8 +2,8 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
-export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable';
-export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily';
+export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable' | 'crw';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'crw';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -91,6 +91,48 @@ export interface TavilySearchPayload {
     include_favicon?: boolean;
     chunks_per_source?: number;
 }
+export interface CrwSearchOptions {
+    /** Max results to request (maps to `limit`; clamped 1..20). */
+    maxResults?: number;
+    /** Add 'images' to the sources array. */
+    includeImages?: boolean;
+    timeout?: number;
+}
+export type CrwSearchSource = 'web' | 'images' | 'news';
+export interface CrwSearchPayload {
+    query: string;
+    limit: number;
+    sources?: CrwSearchSource[];
+    tbs?: string;
+}
+export interface CrwSearchResult {
+    title?: string;
+    url?: string;
+    description?: string;
+    snippet?: string;
+    position?: number;
+    category?: string;
+}
+export interface CrwImageSearchResult extends CrwSearchResult {
+    imageUrl?: string;
+    imageFormat?: string;
+}
+export interface CrwNewsSearchResult extends CrwSearchResult {
+    publishedDate?: string;
+}
+export interface CrwSearchGroups {
+    web?: CrwSearchResult[];
+    images?: CrwImageSearchResult[];
+    news?: CrwNewsSearchResult[];
+}
+export interface CrwSearchResponse {
+    success: boolean;
+    data?: (CrwSearchGroups & {
+        results?: CrwSearchGroups;
+    }) | CrwSearchResult[];
+    error?: string;
+    error_code?: string;
+}
 export interface SearchConfig {
     searchProvider?: SearchProvider;
     serperApiKey?: string;
@@ -103,6 +145,9 @@ export interface SearchConfig {
     keenableApiKey?: string;
     keenableApiUrl?: string;
     keenableSearchOptions?: KeenableSearchOptions;
+    crwApiKey?: string;
+    crwApiUrl?: string;
+    crwSearchOptions?: CrwSearchOptions;
 }
 export interface KeenableSearchOptions {
     maxResults?: number;
@@ -224,6 +269,7 @@ export type SafeSearchLevel = 0 | 1 | 2;
 export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
     tavilyScraperOptions?: TavilyScraperConfig;
+    crwScraperOptions?: CrwScraperConfig;
     /** Max chars of highlight content this tool feeds the MODEL per search (the
      * dominant, otherwise-unbounded part of the output). Distinct from
      * `maxContentLength`, which caps scraped/reranked content per source — full
@@ -255,7 +301,7 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
-export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse;
+export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse | CrwScrapeResponse;
 /** Base Scraper Interface */
 export interface BaseScraper {
     scrapeUrl(url: string, options?: unknown): Promise<[string, AnyScraperResponse]>;
@@ -265,6 +311,24 @@ export interface BaseScraper {
 }
 /** Firecrawl */
 export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'version' | 'logger'>;
+export interface CrwScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    formats?: string[];
+    timeout?: number;
+    logger?: Logger;
+    onlyMainContent?: boolean;
+    includeTags?: string[];
+    excludeTags?: string[];
+    waitFor?: number;
+    headers?: Record<string, string>;
+    renderJs?: boolean | null;
+    cssSelector?: string;
+    xpath?: string;
+    proxy?: string;
+    stealth?: boolean;
+}
+export type CrwScrapeOptions = Omit<CrwScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export type SerperScrapeOptions = Omit<SerperScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export type TavilyScrapeOptions = Omit<TavilyScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export interface TavilyExtractPayload {
@@ -341,6 +405,27 @@ export interface FirecrawlScrapeResponse {
     };
     error?: string;
 }
+export interface CrwScrapeData {
+    markdown?: string;
+    html?: string;
+    rawHtml?: string;
+    plainText?: string;
+    screenshot?: string;
+    links?: string[];
+    metadata?: ScrapeMetadata;
+}
+export interface CrwScrapeResponse {
+    success: boolean;
+    data?: CrwScrapeData;
+    error?: string;
+    error_code?: string;
+}
+export interface CrwRawScrapeResponse extends CrwScrapeData {
+    success?: boolean;
+    data?: CrwScrapeData;
+    error?: string;
+    error_code?: string;
+}
 export interface SerperScrapeResponse {
     success: boolean;
     data?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.2.64",
+  "version": "3.2.65",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",

package/src/graphs/Graph.ts

@@ -1130,6 +1130,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   /* Misc.*/
 
   getRunMessages(): BaseMessage[] | undefined {
+    if (this.messages == null) {
+      return this.cachedRunMessages;
+    }
     if (this.messages.length === 0 && this.cachedRunMessages != null) {
       return this.cachedRunMessages;
     }
@@ -1137,6 +1140,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
   }
 
   getContentParts(): t.MessageContentComplex[] | undefined {
+    // `messages` can be null/undefined on a graph that has been disposed
+    // (clearHeavyState) but is still reachable via a cache (e.g. RedisJobStore's
+    // WeakRef) during a HITL resume/reconnect. Guard instead of dereferencing null.
+    if (this.messages == null) {
+      return undefined;
+    }
     return convertMessagesToContent(this.messages.slice(this.startIndex));
   }
 
@@ -1169,6 +1178,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
    * Get all run steps, optionally filtered by agent ID
    */
   getRunSteps(agentId?: string): t.RunStep[] {
+    // `contentData` can be null/undefined on a disposed-but-cached graph during a
+    // HITL resume/reconnect; without this guard `[...this.contentData]` throws
+    // "this.contentData is not iterable".
+    if (this.contentData == null) {
+      return [];
+    }
     if (agentId == null || agentId === '') {
       return [...this.contentData];
     }

package/src/llm/anthropic/index.ts

@@ -6,6 +6,7 @@ import type {
   BaseMessage,
   MessageContentComplex,
 } from '@langchain/core/messages';
+import type { ChatModelStreamEvent } from '@langchain/core/language_models/event';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Anthropic } from '@anthropic-ai/sdk';
@@ -18,12 +19,15 @@ import type {
   AnthropicMCPServerURLDefinition,
   AnthropicContextManagementConfigParam,
   AnthropicRequestOptions,
+  AnthropicMessageStreamEvent,
 } from '@/llm/anthropic/types';
+import type { AnthropicUsageData } from './utils/message_outputs';
 import {
   _convertMessagesToAnthropicPayload,
   stripUnsupportedAssistantPrefill,
 } from './utils/message_inputs';
 import { _makeMessageChunkFromAnthropicEvent } from './utils/message_outputs';
+import { convertAnthropicStream } from './utils/stream_events';
 import { handleToolChoice } from './utils/tools';
 
 const DEFAULT_STREAM_DELAY = 25;
@@ -34,6 +38,23 @@ const STREAM_BOUNDARIES = new Set([' ', '.', ',', '!', '?', ';', ':']);
 
 type StreamTokenType = 'string' | 'input' | 'content';
 
+interface AnthropicStreamUsage {
+  inputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
+  outputTokens: number;
+}
+
+interface CumulativeUsageValue {
+  cumulative: number;
+  increment: number;
+}
+
+interface AnthropicEventStream
+  extends AsyncIterable<AnthropicMessageStreamEvent> {
+  controller?: { abort: () => void };
+}
+
 const ANTHROPIC_TOOL_BETAS: Partial<Record<string, AnthropicBeta>> = {
   tool_search_tool_regex_20251119: 'advanced-tool-use-2025-11-20',
   tool_search_tool_bm25_20251119: 'advanced-tool-use-2025-11-20',
@@ -324,6 +345,19 @@ function isSignalAborted(signal?: AbortSignal): boolean {
   return signal?.aborted === true;
 }
 
+async function* abortableAnthropicStream(
+  source: AnthropicEventStream,
+  signal?: AbortSignal
+): AsyncGenerator<AnthropicMessageStreamEvent> {
+  for await (const data of source) {
+    if (isSignalAborted(signal)) {
+      source.controller?.abort();
+      return;
+    }
+    yield data;
+  }
+}
+
 function extractToken(
   chunk: AIMessageChunk
 ): [string, StreamTokenType] | [undefined] {
@@ -392,27 +426,77 @@ function cloneChunk(
   return chunk;
 }
 
+function resolveCumulativeUsageValue(
+  current: number | null | undefined,
+  previous: number
+): CumulativeUsageValue {
+  if (current == null) {
+    return { cumulative: previous, increment: 0 };
+  }
+  const cumulative = Math.max(previous, current);
+  return { cumulative, increment: cumulative - previous };
+}
+
 function withIncrementalMessageDeltaUsage(
   chunk: AIMessageChunk,
-  previousOutputTokens: number
-): { chunk: AIMessageChunk; outputTokens: number } {
+  previousUsage: AnthropicStreamUsage,
+  cumulativeUsage: AnthropicUsageData
+): { chunk: AIMessageChunk; usage: AnthropicStreamUsage } {
   const usage = chunk.usage_metadata;
   if (usage == null) {
-    return { chunk, outputTokens: previousOutputTokens };
+    return { chunk, usage: previousUsage };
   }
 
-  const outputTokens = Math.max(0, usage.output_tokens - previousOutputTokens);
+  const inputTokens = resolveCumulativeUsageValue(
+    cumulativeUsage.input_tokens,
+    previousUsage.inputTokens
+  );
+  const cacheCreationInputTokens = resolveCumulativeUsageValue(
+    cumulativeUsage.cache_creation_input_tokens,
+    previousUsage.cacheCreationInputTokens
+  );
+  const cacheReadInputTokens = resolveCumulativeUsageValue(
+    cumulativeUsage.cache_read_input_tokens,
+    previousUsage.cacheReadInputTokens
+  );
+  const outputTokens = resolveCumulativeUsageValue(
+    cumulativeUsage.output_tokens,
+    previousUsage.outputTokens
+  );
+  const incrementalInputTokens =
+    inputTokens.increment +
+    cacheCreationInputTokens.increment +
+    cacheReadInputTokens.increment;
+  const hasCacheUsage =
+    cumulativeUsage.cache_creation_input_tokens != null ||
+    cumulativeUsage.cache_read_input_tokens != null;
+  const inputTokenDetails = {
+    ...(cumulativeUsage.cache_creation_input_tokens != null && {
+      cache_creation: cacheCreationInputTokens.increment,
+    }),
+    ...(cumulativeUsage.cache_read_input_tokens != null && {
+      cache_read: cacheReadInputTokens.increment,
+    }),
+  };
+
   return {
     chunk: new AIMessageChunk(
       Object.assign({}, chunk, {
         usage_metadata: {
           ...usage,
-          output_tokens: outputTokens,
-          total_tokens: usage.input_tokens + outputTokens,
+          input_tokens: incrementalInputTokens,
+          output_tokens: outputTokens.increment,
+          total_tokens: incrementalInputTokens + outputTokens.increment,
+          input_token_details: hasCacheUsage ? inputTokenDetails : undefined,
         },
       })
     ),
-    outputTokens: usage.output_tokens,
+    usage: {
+      inputTokens: inputTokens.cumulative,
+      cacheCreationInputTokens: cacheCreationInputTokens.cumulative,
+      cacheReadInputTokens: cacheReadInputTokens.cumulative,
+      outputTokens: outputTokens.cumulative,
+    },
   };
 }
 
@@ -626,6 +710,29 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     );
   }
 
+  async *_streamChatModelEvents(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    _runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatModelStreamEvent> {
+    const params = this.invocationParams(options);
+    const formattedMessages = _convertMessagesToAnthropicPayload(messages);
+    const payload = stripUnsupportedAssistantPrefill({
+      ...params,
+      ...formattedMessages,
+      stream: true,
+    } as const);
+    const stream = await this.createStreamWithRetry(payload, {
+      headers: options.headers,
+      signal: options.signal,
+    });
+    const shouldStreamUsage = options.streamUsage ?? this.streamUsage;
+    yield* convertAnthropicStream(
+      abortableAnthropicStream(stream, options.signal),
+      { streamUsage: shouldStreamUsage }
+    );
+  }
+
   async *_streamResponseChunks(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'],
@@ -651,7 +758,12 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     });
 
     const shouldStreamUsage = options.streamUsage ?? this.streamUsage;
-    let messageDeltaOutputTokens = 0;
+    let streamUsage: AnthropicStreamUsage = {
+      inputTokens: 0,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      outputTokens: 0,
+    };
     const queuedChunks: QueuedGenerationChunk[] = [];
     const producerState: {
       done: boolean;
@@ -833,13 +945,25 @@ export class CustomAnthropic extends ChatAnthropicMessages {
           }
 
           let { chunk } = result;
+          if (data.type === 'message_start') {
+            streamUsage = {
+              ...streamUsage,
+              inputTokens: data.message.usage.input_tokens,
+              outputTokens: data.message.usage.output_tokens,
+              cacheCreationInputTokens:
+                data.message.usage.cache_creation_input_tokens ?? 0,
+              cacheReadInputTokens:
+                data.message.usage.cache_read_input_tokens ?? 0,
+            };
+          }
           if (data.type === 'message_delta') {
             const incremental = withIncrementalMessageDeltaUsage(
               chunk,
-              messageDeltaOutputTokens
+              streamUsage,
+              data.usage
             );
             chunk = incremental.chunk;
-            messageDeltaOutputTokens = incremental.outputTokens;
+            streamUsage = incremental.usage;
           }
 
           const [token = '', tokenType] = extractToken(chunk);

package/src/llm/anthropic/inherited-content-utils.spec.ts

@@ -185,7 +185,7 @@ describe('_makeMessageChunkFromAnthropicEvent (ported from message_outputs.test.
     expect(usage.input_token_details?.cache_read).toBe(1000);
   });
 
-  it('message_delta chunk has input_tokens=0 and no cache token details', () => {
+  it('message_delta chunk preserves cumulative input and cache usage', () => {
     const event = {
       type: 'message_delta' as const,
       delta: { stop_reason: 'end_turn' as const, stop_sequence: null },
@@ -202,10 +202,15 @@ describe('_makeMessageChunkFromAnthropicEvent (ported from message_outputs.test.
     expect(result).not.toBeNull();
 
     const usage = result!.chunk.usage_metadata!;
-    expect(usage.output_tokens).toBe(42);
-    expect(usage.input_tokens).toBe(0);
-    expect(usage.input_token_details?.cache_creation).toBeUndefined();
-    expect(usage.input_token_details?.cache_read).toBeUndefined();
+    expect(usage).toEqual({
+      input_tokens: 1600,
+      output_tokens: 42,
+      total_tokens: 1642,
+      input_token_details: {
+        cache_creation: 500,
+        cache_read: 1000,
+      },
+    });
   });
 });