@librechat/agents 2.4.22 → 2.4.31

package/dist/types/llm/anthropic/types.d.ts

@@ -1,5 +1,4 @@
 import Anthropic from '@anthropic-ai/sdk';
-import type { Tool as AnthropicTool } from '@anthropic-ai/sdk/resources';
 import { BindToolsInput } from '@langchain/core/language_models/chat_models';
 export type AnthropicToolResponse = {
     type: 'tool_use';
@@ -7,19 +6,21 @@ export type AnthropicToolResponse = {
     name: string;
     input: Record<string, any>;
 };
+export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageParam = Anthropic.MessageParam;
 export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
 export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
 export type AnthropicMessageResponse = Anthropic.ContentBlock | AnthropicToolResponse;
 export type AnthropicMessageCreateParams = Anthropic.MessageCreateParamsNonStreaming;
 export type AnthropicStreamingMessageCreateParams = Anthropic.MessageCreateParamsStreaming;
+export type AnthropicThinkingConfigParam = Anthropic.ThinkingConfigParam;
 export type AnthropicMessageStreamEvent = Anthropic.MessageStreamEvent;
 export type AnthropicRequestOptions = Anthropic.RequestOptions;
 export type AnthropicToolChoice = {
     type: 'tool';
     name: string;
 } | 'any' | 'auto' | 'none' | string;
-export type ChatAnthropicToolType = AnthropicTool | BindToolsInput;
+export type ChatAnthropicToolType = Anthropic.Messages.Tool | BindToolsInput;
 export type AnthropicTextBlockParam = Anthropic.Messages.TextBlockParam;
 export type AnthropicImageBlockParam = Anthropic.Messages.ImageBlockParam;
 export type AnthropicToolUseBlockParam = Anthropic.Messages.ToolUseBlockParam;
@@ -27,36 +28,4 @@ export type AnthropicToolResultBlockParam = Anthropic.Messages.ToolResultBlockPa
 export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
 export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
 export type AnthropicRedactedThinkingBlockParam = Anthropic.Messages.RedactedThinkingBlockParam;
-/**
- * Stream usage information for Anthropic API calls
- * @see https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching#pricing
- */
-export interface AnthropicStreamUsage {
-    /**
-     * The number of input tokens used in the request
-     */
-    input_tokens: number;
-    /**
-     * The number of cache creation input tokens used (write operations)
-     */
-    cache_creation_input_tokens?: number;
-    /**
-     * The number of cache input tokens used (read operations)
-     */
-    cache_read_input_tokens?: number;
-    /**
-     * The number of output tokens generated in the response
-     */
-    output_tokens: number;
-    /**
-     * The total number of tokens generated in the response
-     */
-    total_tokens: number;
-    /**
-     * Details about input token usage
-     */
-    input_token_details?: {
-        cache_creation: number;
-        cache_read: number;
-    };
-}
+export declare function isAnthropicImageBlockParam(block: unknown): block is AnthropicImageBlockParam;

package/dist/types/llm/anthropic/utils/message_inputs.d.ts

@@ -1,9 +1,9 @@
 /**
  * This util file contains functions for converting LangChain messages to Anthropic messages.
  */
-import { BaseMessage } from '@langchain/core/messages';
+import { type BaseMessage } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
-import type { AnthropicToolResponse, AnthropicMessageCreateParams } from '@/llm/anthropic/types';
+import type { AnthropicMessageCreateParams, AnthropicToolResponse } from '@/llm/anthropic/types';
 export declare function _convertLangChainToolCallToAnthropic(toolCall: ToolCall): AnthropicToolResponse;
 /**
  * Formats messages as a prompt for the model.

package/dist/types/llm/anthropic/utils/message_outputs.d.ts

@@ -3,10 +3,8 @@
  */
 import Anthropic from '@anthropic-ai/sdk';
 import { AIMessageChunk } from '@langchain/core/messages';
-import { ToolCall } from '@langchain/core/messages/tool';
 import { ChatGeneration } from '@langchain/core/outputs';
-import { AnthropicMessageResponse } from '../types.js';
-export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+import { AnthropicMessageResponse } from '../types';
 export declare function _makeMessageChunkFromAnthropicEvent(data: Anthropic.Messages.RawMessageStreamEvent, fields: {
     streamUsage: boolean;
     coerceContentToString: boolean;

package/dist/types/llm/anthropic/utils/output_parsers.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { BaseLLMOutputParser } from '@langchain/core/output_parsers';
+import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import { ChatGeneration } from '@langchain/core/outputs';
+import { ToolCall } from '@langchain/core/messages/tool';
+interface AnthropicToolsOutputParserParams<T extends Record<string, any>> extends JsonOutputKeyToolsParserParams<T> {
+}
+export declare class AnthropicToolsOutputParser<T extends Record<string, any> = Record<string, any>> extends BaseLLMOutputParser<T> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    returnId: boolean;
+    /** The type of tool calls to return. */
+    keyName: string;
+    /** Whether to return only the first tool call. */
+    returnSingle: boolean;
+    zodSchema?: z.ZodType<T>;
+    constructor(params: AnthropicToolsOutputParserParams<T>);
+    protected _validateResult(result: unknown): Promise<T>;
+    parseResult(generations: ChatGeneration[]): Promise<T>;
+}
+export declare function extractToolCalls(content: Record<string, any>[]): ToolCall[];
+export {};

package/dist/types/llm/openai/index.d.ts

@@ -2,6 +2,7 @@ import { AzureOpenAI as AzureOpenAIClient } from 'openai';
 import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
 import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
 import { OpenAIClient, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI } from '@langchain/openai';
+import type { OpenAICoreRequestOptions } from 'node_modules/@langchain/deepseek/node_modules/@langchain/openai';
 import type * as t from '@langchain/openai';
 export declare class CustomOpenAIClient extends OpenAIClient {
     abortHandler?: () => void;
@@ -21,9 +22,9 @@ export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
 }
 export declare class ChatDeepSeek extends OriginalChatDeepSeek {
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options?: t.OpenAICoreRequestOptions): t.OpenAICoreRequestOptions;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
 }
 export declare class ChatXAI extends OriginalChatXAI {
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options?: t.OpenAICoreRequestOptions): t.OpenAICoreRequestOptions;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
 }

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

@@ -0,0 +1 @@
+export {};

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

@@ -7,14 +7,22 @@ export declare const fetchRandomImageTool: DynamicStructuredTool<z.ZodObject<{
     input?: string | undefined;
 }, {
     input?: string | undefined;
-}>>;
+}>, {
+    input?: string | undefined;
+}, {
+    input?: string | undefined;
+}>;
 export declare const fetchRandomImageURL: DynamicStructuredTool<z.ZodObject<{
     input: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     input?: string | undefined;
 }, {
     input?: string | undefined;
-}>>;
+}>, {
+    input?: string | undefined;
+}, {
+    input?: string | undefined;
+}>;
 export declare const chartTool: DynamicStructuredTool<z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         label: z.ZodString;
@@ -36,5 +44,15 @@ export declare const chartTool: DynamicStructuredTool<z.ZodObject<{
         value: number;
         label: string;
     }[];
-}>>;
+}>, {
+    data: {
+        value: number;
+        label: string;
+    }[];
+}, {
+    data: {
+        value: number;
+        label: string;
+    }[];
+}>;
 export declare const tavilyTool: TavilySearchResults;

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

@@ -0,0 +1,117 @@
+export interface FirecrawlScrapeOptions {
+    formats?: string[];
+    includeTags?: string[];
+    excludeTags?: string[];
+    headers?: Record<string, string>;
+    waitFor?: number;
+    timeout?: number;
+}
+interface ScrapeMetadata {
+    sourceURL?: string;
+    url?: string;
+    scrapeId?: string;
+    statusCode?: number;
+    title?: string;
+    description?: string;
+    language?: string;
+    favicon?: string;
+    viewport?: string;
+    robots?: string;
+    'theme-color'?: string;
+    'og:url'?: string;
+    'og:title'?: string;
+    'og:description'?: string;
+    'og:type'?: string;
+    'og:image'?: string;
+    'og:image:width'?: string;
+    'og:image:height'?: string;
+    'og:site_name'?: string;
+    ogUrl?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    ogSiteName?: string;
+    'article:author'?: string;
+    'article:published_time'?: string;
+    'article:modified_time'?: string;
+    'article:section'?: string;
+    'article:tag'?: string;
+    'article:publisher'?: string;
+    publishedTime?: string;
+    modifiedTime?: string;
+    'twitter:site'?: string;
+    'twitter:creator'?: string;
+    'twitter:card'?: string;
+    'twitter:image'?: string;
+    'twitter:dnt'?: string;
+    'twitter:app:name:iphone'?: string;
+    'twitter:app:id:iphone'?: string;
+    'twitter:app:url:iphone'?: string;
+    'twitter:app:name:ipad'?: string;
+    'twitter:app:id:ipad'?: string;
+    'twitter:app:url:ipad'?: string;
+    'twitter:app:name:googleplay'?: string;
+    'twitter:app:id:googleplay'?: string;
+    'twitter:app:url:googleplay'?: string;
+    'fb:app_id'?: string;
+    'al:ios:url'?: string;
+    'al:ios:app_name'?: string;
+    'al:ios:app_store_id'?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}
+export interface FirecrawlScrapeResponse {
+    success: boolean;
+    data?: {
+        markdown?: string;
+        html?: string;
+        rawHtml?: string;
+        screenshot?: string;
+        links?: string[];
+        metadata?: ScrapeMetadata;
+    };
+    error?: string;
+}
+export interface FirecrawlScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    formats?: string[];
+    timeout?: number;
+}
+export declare function getAttribution(link: string, metadata?: ScrapeMetadata): string | undefined;
+/**
+ * Firecrawl scraper implementation
+ * Uses the Firecrawl API to scrape web pages
+ */
+export declare class FirecrawlScraper {
+    private apiKey;
+    private apiUrl;
+    private defaultFormats;
+    private timeout;
+    constructor(config?: FirecrawlScraperConfig);
+    /**
+     * Scrape a single URL
+     * @param url URL to scrape
+     * @param options Scrape options
+     * @returns Scrape response
+     */
+    scrapeUrl(url: string, options?: FirecrawlScrapeOptions): Promise<[string, FirecrawlScrapeResponse]>;
+    /**
+     * Extract content from scrape response
+     * @param response Scrape response
+     * @returns Extracted content or empty string if not available
+     */
+    extractContent(response: FirecrawlScrapeResponse): string;
+    /**
+     * Extract metadata from scrape response
+     * @param response Scrape response
+     * @returns Metadata object
+     */
+    extractMetadata(response: FirecrawlScrapeResponse): ScrapeMetadata;
+}
+/**
+ * Create a Firecrawl scraper instance
+ * @param config Scraper configuration
+ * @returns Firecrawl scraper instance
+ */
+export declare const createFirecrawlScraper: (config?: FirecrawlScraperConfig) => FirecrawlScraper;
+export {};

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

@@ -0,0 +1,2 @@
+import type * as t from './types';
+export declare function formatResultsForLLM(results: t.SearchResultData): string;

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

@@ -0,0 +1,13 @@
+import type * as t from './types';
+/**
+ * Expand highlights in search results using smart boundary detection.
+ *
+ * This implementation finds natural text boundaries like paragraphs, sentences,
+ * and phrases to provide context while maintaining readability.
+ *
+ * @param searchResults - Search results object
+ * @param mainExpandBy - Primary expansion size on each side (default: 300)
+ * @param separatorExpandBy - Additional range to look for separators (default: 150)
+ * @returns Copy of search results with expanded highlights
+ */
+export declare function expandHighlights(searchResults: t.SearchResultData, mainExpandBy?: number, separatorExpandBy?: number): t.SearchResultData;

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

@@ -0,0 +1,2 @@
+export * from './tool';
+export type * from './types';

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

@@ -0,0 +1,32 @@
+import type * as t from './types';
+export declare abstract class BaseReranker {
+    protected apiKey: string | undefined;
+    constructor();
+    abstract rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+    protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
+    protected logDocumentSamples(documents: string[]): void;
+}
+export declare class JinaReranker extends BaseReranker {
+    constructor({ apiKey }: {
+        apiKey?: string;
+    });
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+export declare class CohereReranker extends BaseReranker {
+    constructor({ apiKey }: {
+        apiKey?: string;
+    });
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+export declare class InfinityReranker extends BaseReranker {
+    constructor();
+    rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
+}
+/**
+ * Creates the appropriate reranker based on type and configuration
+ */
+export declare const createReranker: (config: {
+    rerankerType: t.RerankerType;
+    jinaApiKey?: string;
+    cohereApiKey?: string;
+}) => BaseReranker | undefined;

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

@@ -0,0 +1,9 @@
+import type * as t from './types';
+import { FirecrawlScraper } from './firecrawl';
+export declare const createSearchAPI: (config: t.SearchConfig) => {
+    getSources: (query: string, numResults?: number, storedLocation?: string) => Promise<t.SearchResult>;
+};
+export declare const createSourceProcessor: (config?: t.ProcessSourcesConfig, scraperInstance?: FirecrawlScraper) => {
+    processSources: (result: t.SearchResult, numElements: number, query: string, proMode?: boolean) => Promise<t.SearchResultData>;
+    topResults: number;
+};

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import type * as t from './types';
+declare const SearchToolSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicStructuredTool<typeof SearchToolSchema>;
+export {};

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

@@ -0,0 +1,150 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { BaseReranker } from './rerankers';
+export type SearchProvider = 'serper' | 'searxng';
+export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
+export interface OrganicResult {
+    position?: number;
+    title?: string;
+    link: string;
+    snippet?: string;
+    date?: string;
+}
+export interface TopStoryResult {
+    title?: string;
+    link: string;
+    source?: string;
+    date?: string;
+    imageUrl?: string;
+}
+export interface ImageResult {
+    title?: string;
+    imageUrl?: string;
+}
+export interface KnowledgeGraphResult {
+    title?: string;
+    type?: string;
+    description?: string;
+    attributes?: Record<string, string>;
+    imageUrl?: string;
+}
+export interface AnswerBoxResult {
+    title?: string;
+    answer?: string;
+    snippet?: string;
+    date?: string;
+}
+export interface PeopleAlsoAskResult {
+    question?: string;
+    answer?: string;
+}
+export interface Highlight {
+    score: number;
+    text: string;
+}
+export interface ValidSource {
+    link: string;
+    position?: number;
+    title?: string;
+    snippet?: string;
+    date?: string;
+    content?: string;
+    attribution?: string;
+    highlights?: Highlight[];
+}
+export interface SearchResultData {
+    organic?: ValidSource[];
+    topStories?: ValidSource[];
+    images?: ImageResult[];
+    knowledgeGraph?: KnowledgeGraphResult;
+    answerBox?: AnswerBoxResult;
+    peopleAlsoAsk?: PeopleAlsoAskResult[];
+    relatedSearches?: string[];
+    suggestions?: string[];
+    error?: string;
+}
+export interface SearchResult {
+    data?: SearchResultData;
+    error?: string;
+    success: boolean;
+}
+export interface Source {
+    link: string;
+    html?: string;
+    title?: string;
+    snippet?: string;
+    date?: string;
+}
+export interface SearchConfig {
+    searchProvider?: SearchProvider;
+    serperApiKey?: string;
+    searxngInstanceUrl?: string;
+    searxngApiKey?: string;
+}
+export interface ScrapeResult {
+    url: string;
+    error?: boolean;
+    content: string;
+    attribution?: string;
+    highlights?: Highlight[];
+}
+export interface ProcessSourcesConfig {
+    topResults?: number;
+    strategies?: string[];
+    filterContent?: boolean;
+    reranker?: BaseReranker;
+}
+export interface FirecrawlConfig {
+    firecrawlApiKey?: string;
+    firecrawlApiUrl?: string;
+    firecrawlFormats?: string[];
+}
+export interface ScraperContentResult {
+    content: string;
+}
+export interface ScraperExtractionResult {
+    no_extraction: ScraperContentResult;
+}
+export interface SearXNGResult {
+    title?: string;
+    url?: string;
+    content?: string;
+    publishedDate?: string;
+    img_src?: string;
+}
+export interface JinaRerankerResult {
+    index: number;
+    relevance_score: number;
+    document?: string | {
+        text: string;
+    };
+}
+export interface JinaRerankerResponse {
+    model: string;
+    usage: {
+        total_tokens: number;
+    };
+    results: JinaRerankerResult[];
+}
+export interface CohereRerankerResult {
+    index: number;
+    relevance_score: number;
+}
+export interface CohereRerankerResponse {
+    results: CohereRerankerResult[];
+    id: string;
+    meta: {
+        api_version: {
+            version: string;
+            is_experimental: boolean;
+        };
+        billed_units: {
+            search_units: number;
+        };
+    };
+}
+export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
+    jinaApiKey?: string;
+    cohereApiKey?: string;
+    rerankerType?: RerankerType;
+    onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.4.22",
+  "version": "2.4.31",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -52,6 +52,7 @@
     "thinking": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/thinking.ts --name 'Jo' --location 'New York, NY'",
     "memory": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/memory.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "tool-test": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/tools.ts --provider 'alibaba' --name 'Jo' --location 'New York, NY'",
+    "search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/search.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "abort": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/abort.ts --provider 'openAI' --name 'Jo' --location 'New York, NY'",
     "start:cli2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/cli2.ts --provider 'anthropic' --name 'Jo' --location 'New York, NY'",
     "script2": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/proto/example_test.ts",
@@ -71,17 +72,17 @@
     "format": "prettier --write ."
   },
   "dependencies": {
-    "@langchain/anthropic": "^0.3.16",
-    "@langchain/aws": "^0.1.7",
-    "@langchain/community": "^0.3.39",
-    "@langchain/core": "^0.3.43",
+    "@langchain/anthropic": "^0.3.20",
+    "@langchain/aws": "^0.1.9",
+    "@langchain/community": "^0.3.42",
+    "@langchain/core": "^0.3.51",
     "@langchain/deepseek": "^0.0.1",
-    "@langchain/google-genai": "^0.2.2",
-    "@langchain/google-vertexai": "^0.2.3",
-    "@langchain/langgraph": "^0.2.62",
+    "@langchain/google-genai": "^0.2.5",
+    "@langchain/google-vertexai": "^0.2.5",
+    "@langchain/langgraph": "^0.2.67",
     "@langchain/mistralai": "^0.2.0",
     "@langchain/ollama": "^0.2.0",
-    "@langchain/openai": "^0.5.4",
+    "@langchain/openai": "^0.5.10",
     "@langchain/xai": "^0.0.2",
     "dotenv": "^16.4.7",
     "https-proxy-agent": "^7.0.6",

package/src/common/enum.ts

@@ -158,6 +158,7 @@ export enum Callback {
 export enum Constants {
   OFFICIAL_CODE_BASEURL = 'https://api.librechat.ai/v1',
   EXECUTE_CODE = 'execute_code',
+  WEB_SEARCH = 'web_search',
   CONTENT_AND_ARTIFACT = 'content_and_artifact',
 }
 

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './graphs';
 
 /* Tools */
 export * from './tools/CodeExecutor';
+export * from './tools/search';
 
 /* Misc. */
 export * from './common';

package/src/llm/anthropic/index.ts

@@ -4,6 +4,7 @@ import { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { BaseChatModelParams } from '@langchain/core/language_models/chat_models';
 import type {
   BaseMessage,
+  UsageMetadata,
   MessageContentComplex,
 } from '@langchain/core/messages';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
@@ -132,9 +133,9 @@ export class CustomAnthropic extends ChatAnthropicMessages {
 
   /**
    * Get stream usage as returned by this client's API response.
-   * @returns {AnthropicStreamUsage} The stream usage object.
+   * @returns The stream usage object.
    */
-  getStreamUsage(): AnthropicStreamUsage | undefined {
+  getStreamUsage(): UsageMetadata | undefined {
     if (this.emitted_usage === true) {
       return;
     }
@@ -147,7 +148,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     if (!outputUsage) {
       return;
     }
-    const totalUsage: AnthropicStreamUsage = {
+    const totalUsage: UsageMetadata = {
       input_tokens: inputUsage?.input_tokens ?? 0,
       output_tokens: outputUsage.output_tokens ?? 0,
       total_tokens:
@@ -184,7 +185,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
     token?: string;
     chunk: AIMessageChunk;
     shouldStreamUsage: boolean;
-    usageMetadata?: AnthropicStreamUsage;
+    usageMetadata?: UsageMetadata;
   }): ChatGenerationChunk {
     const usage_metadata = shouldStreamUsage
       ? (usageMetadata ?? chunk.usage_metadata)
@@ -245,7 +246,7 @@ export class CustomAnthropic extends ChatAnthropicMessages {
         this.message_delta = data as AnthropicMessageDeltaEvent;
       }
 
-      let usageMetadata: AnthropicStreamUsage | undefined;
+      let usageMetadata: UsageMetadata | undefined;
       if (this.tools_in_params !== true && this.emitted_usage !== true) {
         usageMetadata = this.getStreamUsage();
       }