@librechat/agents 3.0.0-rc9 → 3.0.0

package/dist/types/messages/format.d.ts

@@ -1,24 +1,24 @@
-import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { AIMessage, ToolMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { Providers } from '@/common';
-interface VisionMessageParams {
+interface MediaMessageParams {
     message: {
         role: string;
         content: string;
         name?: string;
         [key: string]: any;
     };
-    image_urls: MessageContentImageUrl[];
+    mediaParts: MessageContentComplex[];
     endpoint?: Providers;
 }
 /**
- * Formats a message to OpenAI Vision API payload format.
+ * Formats a message with media content (images, documents, videos, audios) to API payload format.
  *
- * @param {VisionMessageParams} params - The parameters for formatting.
- * @returns {Object} - The formatted message.
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
  */
-export declare const formatVisionMessage: ({ message, image_urls, endpoint, }: VisionMessageParams) => {
+export declare const formatMediaMessage: ({ message, endpoint, mediaParts, }: MediaMessageParams) => {
     role: string;
     content: MessageContentComplex[];
     name?: string;
@@ -31,6 +31,9 @@ interface MessageInput {
     text?: string;
     content?: string | MessageContentComplex[];
     image_urls?: MessageContentImageUrl[];
+    documents?: MessageContentComplex[];
+    videos?: MessageContentComplex[];
+    audios?: MessageContentComplex[];
     lc_id?: string[];
     [key: string]: any;
 }
@@ -50,16 +53,16 @@ interface FormattedMessage {
 /**
  * Formats a message to OpenAI payload format based on the provided options.
  *
- * @param {FormatMessageParams} params - The parameters for formatting.
- * @returns {FormattedMessage | HumanMessage | AIMessage | SystemMessage} - The formatted message.
+ * @param params - The parameters for formatting.
+ * @returns - The formatted message.
  */
-export declare const formatMessage: ({ message, userName, assistantName, endpoint, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
+export declare const formatMessage: ({ message, userName, endpoint, assistantName, langChain, }: FormatMessageParams) => FormattedMessage | HumanMessage | AIMessage | SystemMessage;
 /**
  * Formats an array of messages for LangChain.
  *
- * @param {Array<MessageInput>} messages - The array of messages to format.
- * @param {Omit<FormatMessageParams, 'message' | 'langChain'>} formatOptions - The options for formatting each message.
- * @returns {Array<HumanMessage | AIMessage | SystemMessage>} - The array of formatted LangChain messages.
+ * @param messages - The array of messages to format.
+ * @param formatOptions - The options for formatting each message.
+ * @returns - The array of formatted LangChain messages.
  */
 export declare const formatLangChainMessages: (messages: Array<MessageInput>, formatOptions: Omit<FormatMessageParams, "message" | "langChain">) => Array<HumanMessage | AIMessage | SystemMessage>;
 interface LangChainMessage {
@@ -76,28 +79,22 @@ interface LangChainMessage {
 /**
  * Formats a LangChain message object by merging properties from `lc_kwargs` or `kwargs` and `additional_kwargs`.
  *
- * @param {LangChainMessage} message - The message object to format.
- * @returns {Record<string, any>} The formatted LangChain message.
+ * @param message - The message object to format.
+ * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
- * @param {TPayload} payload - The array of messages to format.
- * @param {Record<number, number>} [indexTokenCountMap] - Optional map of message indices to token counts.
- * @param {Set<string>} [tools] - Optional set of tool names that are allowed in the request.
- * @returns {Object} - Object containing formatted messages and updated indexTokenCountMap if provided.
+ * @param payload - The array of messages to format.
+ * @param indexTokenCountMap - Optional map of message indices to token counts.
+ * @param tools - Optional set of tool names that are allowed in the request.
+ * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
 export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap?: Record<number, number>, tools?: Set<string>) => {
     messages: Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>;
     indexTokenCountMap?: Record<number, number>;
 };
-/**
- * Formats an array of messages for LangChain, making sure all content fields are strings
- * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
- * @returns {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} - The array of formatted LangChain messages, including ToolMessages for tool calls.
- */
-export declare const formatContentStrings: (payload: Array<BaseMessage>) => Array<BaseMessage>;
 /**
  * Adds a value at key 0 for system messages and shifts all key indices by one in an indexTokenCountMap.
  * This is useful when adding a system message at the beginning of a conversation.

package/dist/types/messages/index.d.ts

@@ -2,3 +2,5 @@ export * from './core';
 export * from './ids';
 export * from './prune';
 export * from './format';
+export * from './cache';
+export * from './content';

package/dist/types/run.d.ts

@@ -1,4 +1,5 @@
-import type { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import './instrumentation';
+import type { MessageContentComplex, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';

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

@@ -3,9 +3,10 @@ import type * as t from './types';
  * Firecrawl scraper implementation
  * Uses the Firecrawl API to scrape web pages
  */
-export declare class FirecrawlScraper {
+export declare class FirecrawlScraper implements t.BaseScraper {
     private apiKey;
     private apiUrl;
+    private version;
     private defaultFormats;
     private timeout;
     private logger;

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

@@ -7,8 +7,10 @@ export declare abstract class BaseReranker {
     protected getDefaultRanking(documents: string[], topK: number): t.Highlight[];
 }
 export declare class JinaReranker extends BaseReranker {
-    constructor({ apiKey, logger, }: {
+    private apiUrl;
+    constructor({ apiKey, apiUrl, logger, }: {
         apiKey?: string;
+        apiUrl?: string;
         logger?: t.Logger;
     });
     rerank(query: string, documents: string[], topK?: number): Promise<t.Highlight[]>;
@@ -30,6 +32,7 @@ export declare class InfinityReranker extends BaseReranker {
 export declare const createReranker: (config: {
     rerankerType: t.RerankerType;
     jinaApiKey?: string;
+    jinaApiUrl?: string;
     cohereApiKey?: string;
     logger?: t.Logger;
 }) => BaseReranker | undefined;

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

@@ -1,9 +1,8 @@
 import type * as t from './types';
-import { FirecrawlScraper } from './firecrawl';
 export declare const createSearchAPI: (config: t.SearchConfig) => {
     getSources: (params: t.GetSourcesParams) => Promise<t.SearchResult>;
 };
-export declare const createSourceProcessor: (config?: t.ProcessSourcesConfig, scraperInstance?: FirecrawlScraper) => {
+export declare const createSourceProcessor: (config?: t.ProcessSourcesConfig, scraperInstance?: t.BaseScraper) => {
     processSources: (fields: t.ProcessSourcesFields) => Promise<t.SearchResultData>;
     topResults: number;
 };

package/dist/types/tools/search/serper-scraper.d.ts

@@ -0,0 +1,59 @@
+import type * as t from './types';
+/**
+ * Serper scraper implementation
+ * Uses the Serper Scrape API (https://scrape.serper.dev) to scrape web pages
+ *
+ * Features:
+ * - Simple API with single endpoint
+ * - Returns both text and markdown content
+ * - Includes metadata from scraped pages
+ * - Credits-based pricing model
+ *
+ * @example
+ * ```typescript
+ * const scraper = createSerperScraper({
+ *   apiKey: 'your-serper-api-key',
+ *   includeMarkdown: true,
+ *   timeout: 10000
+ * });
+ *
+ * const [url, response] = await scraper.scrapeUrl('https://example.com');
+ * if (response.success) {
+ *   const [content] = scraper.extractContent(response);
+ *   console.log(content);
+ * }
+ * ```
+ */
+export declare class SerperScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private logger;
+    private includeMarkdown;
+    constructor(config?: t.SerperScraperConfig);
+    /**
+     * Scrape a single URL
+     * @param url URL to scrape
+     * @param options Scrape options
+     * @returns Scrape response
+     */
+    scrapeUrl(url: string, options?: t.SerperScrapeOptions): Promise<[string, t.SerperScrapeResponse]>;
+    /**
+     * Extract content from scrape response
+     * @param response Scrape response
+     * @returns Extracted content or empty string if not available
+     */
+    extractContent(response: t.SerperScrapeResponse): [string, undefined | t.References];
+    /**
+     * Extract metadata from scrape response
+     * @param response Scrape response
+     * @returns Metadata object
+     */
+    extractMetadata(response: t.SerperScrapeResponse): Record<string, string | number | boolean | null | undefined>;
+}
+/**
+ * Create a Serper scraper instance
+ * @param config Scraper configuration
+ * @returns Serper scraper instance
+ */
+export declare const createSerperScraper: (config?: t.SerperScraperConfig) => SerperScraper;

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

@@ -6,6 +6,27 @@ import { DATE_RANGE } from './schema';
  * Creates a search tool with a schema that dynamically includes the country field
  * only when the searchProvider is 'serper'.
  *
+ * Supports multiple scraper providers:
+ * - Firecrawl (default): Full-featured web scraping with multiple formats
+ * - Serper: Lightweight scraping using Serper's scrape API
+ *
+ * @example
+ * ```typescript
+ * // Using Firecrawl scraper (default)
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'firecrawl',
+ *   firecrawlApiKey: 'your-firecrawl-key'
+ * });
+ *
+ * // Using Serper scraper
+ * const searchTool = createSearchTool({
+ *   searchProvider: 'serper',
+ *   scraperProvider: 'serper',
+ *   serperApiKey: 'your-serper-key'
+ * });
+ * ```
+ *
  * @param config - The search tool configuration
  * @returns A DynamicStructuredTool with a schema that depends on the searchProvider
  */
@@ -18,16 +39,16 @@ export declare const createSearchTool: (config?: t.SearchToolConfig) => DynamicS
     news: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     query: string;
-    date?: DATE_RANGE | undefined;
-    images?: boolean | undefined;
     videos?: boolean | undefined;
+    images?: boolean | undefined;
     news?: boolean | undefined;
+    date?: DATE_RANGE | undefined;
     country?: unknown;
 }, {
     query: string;
-    date?: DATE_RANGE | undefined;
-    images?: boolean | undefined;
     videos?: boolean | undefined;
+    images?: boolean | undefined;
     news?: boolean | undefined;
+    date?: DATE_RANGE | undefined;
     country?: unknown;
 }>>;

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

@@ -4,6 +4,7 @@ import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 export type SearchProvider = 'serper' | 'searxng';
+export type ScraperProvider = 'firecrawl' | 'serper';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -85,8 +86,16 @@ export interface ProcessSourcesConfig {
 export interface FirecrawlConfig {
     firecrawlApiKey?: string;
     firecrawlApiUrl?: string;
+    firecrawlVersion?: string;
     firecrawlOptions?: FirecrawlScraperConfig;
 }
+export interface SerperScraperConfig {
+    apiKey?: string;
+    apiUrl?: string;
+    timeout?: number;
+    logger?: Logger;
+    includeMarkdown?: boolean;
+}
 export interface ScraperContentResult {
     content: string;
 }
@@ -130,9 +139,12 @@ export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, Fi
     logger?: Logger;
     safeSearch?: SafeSearchLevel;
     jinaApiKey?: string;
+    jinaApiUrl?: string;
     cohereApiKey?: string;
     rerankerType?: RerankerType;
+    scraperProvider?: ScraperProvider;
     scraperTimeout?: number;
+    serperScraperOptions?: SerperScraperConfig;
     onSearchResults?: (results: SearchResult, runnableConfig?: RunnableConfig) => void;
     onGetHighlights?: (link: string) => void;
 }
@@ -146,8 +158,15 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
+/** Base Scraper Interface */
+export interface BaseScraper {
+    scrapeUrl(url: string, options?: unknown): Promise<[string, FirecrawlScrapeResponse | SerperScrapeResponse]>;
+    extractContent(response: FirecrawlScrapeResponse | SerperScrapeResponse): [string, undefined | References];
+    extractMetadata(response: FirecrawlScrapeResponse | SerperScrapeResponse): ScrapeMetadata | Record<string, string | number | boolean | null | undefined>;
+}
 /** Firecrawl */
-export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+export type FirecrawlScrapeOptions = Omit<FirecrawlScraperConfig, 'apiKey' | 'apiUrl' | 'version' | 'logger'>;
+export type SerperScrapeOptions = Omit<SerperScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
 export interface ScrapeMetadata {
     sourceURL?: string;
     url?: string;
@@ -213,9 +232,20 @@ export interface FirecrawlScrapeResponse {
     };
     error?: string;
 }
+export interface SerperScrapeResponse {
+    success: boolean;
+    data?: {
+        text?: string;
+        markdown?: string;
+        metadata?: Record<string, string | number | boolean | null | undefined>;
+        credits?: number;
+    };
+    error?: string;
+}
 export interface FirecrawlScraperConfig {
     apiKey?: string;
     apiUrl?: string;
+    version?: string;
     formats?: string[];
     timeout?: number;
     logger?: Logger;

package/dist/types/types/graph.d.ts

@@ -218,7 +218,7 @@ export type GraphEdge = {
      * For handoff edges: Description for the input parameter that the handoff tool accepts,
      * allowing the supervisor to pass specific instructions/context to the transferred agent.
      */
-    prompt?: string | ((messages: BaseMessage[], runStartIndex: number) => string | undefined);
+    prompt?: string | ((messages: BaseMessage[], runStartIndex: number) => string | Promise<string> | undefined);
     /**
      * When true, excludes messages from startIndex when adding prompt.
      * Automatically set to true when {results} variable is used in prompt.
@@ -246,4 +246,6 @@ export interface AgentInputs {
     clientOptions?: ClientOptions;
     additional_instructions?: string;
     reasoningKey?: 'reasoning_content' | 'reasoning';
+    /** Format content blocks as strings (for legacy compatibility i.e. Ollama/Azure Serverless) */
+    useLegacyContent?: boolean;
 }

package/dist/types/types/messages.d.ts

@@ -0,0 +1,4 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { BaseMessage } from '@langchain/core/messages';
+export type AnthropicMessages = Array<AnthropicMessage | BaseMessage>;
+export type AnthropicMessage = Anthropic.MessageParam;

package/dist/types/utils/handlers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Multi-Agent Handler Utilities
+ *
+ * Provides a simple helper to create handlers with content aggregation for multi-agent scripts.
+ *
+ * Usage:
+ * ```typescript
+ * const { contentParts, aggregateContent, handlers } = createHandlers();
+ *
+ * // With callbacks
+ * const { contentParts, aggregateContent, handlers } = createHandlers({
+ *   onRunStep: (event, data) => console.log('Step:', data),
+ *   onRunStepCompleted: (event, data) => console.log('Completed:', data)
+ * });
+ * ```
+ */
+import { GraphEvents } from '@/common';
+import { createContentAggregator } from '@/stream';
+import type * as t from '@/types';
+interface HandlerCallbacks {
+    onRunStep?: (event: GraphEvents.ON_RUN_STEP, data: t.StreamEventData) => void;
+    onRunStepCompleted?: (event: GraphEvents.ON_RUN_STEP_COMPLETED, data: t.StreamEventData) => void;
+    onRunStepDelta?: (event: GraphEvents.ON_RUN_STEP_DELTA, data: t.StreamEventData) => void;
+    onMessageDelta?: (event: GraphEvents.ON_MESSAGE_DELTA, data: t.StreamEventData) => void;
+}
+/**
+ * Creates handlers with content aggregation for multi-agent scripts
+ */
+export declare function createHandlers(callbacks?: HandlerCallbacks): {
+    contentParts: Array<t.MessageContentComplex | undefined>;
+    aggregateContent: ReturnType<typeof createContentAggregator>['aggregateContent'];
+    handlers: Record<string, t.EventHandler>;
+};
+export {};

package/dist/types/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './graph';
 export * from './llm';
 export * from './misc';
+export * from './handlers';
 export * from './run';
 export * from './tokens';

package/dist/types/utils/misc.d.ts

@@ -1,3 +1,4 @@
+export declare function isPresent(value: string | null | undefined): value is string;
 /**
  * Recursively unescapes all string values in an object
  * @param obj The object to unescape

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "3.0.00-rc9",
+  "version": "3.0.00",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -51,7 +51,7 @@
     "caching": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/caching.ts --name 'Jo' --location 'New York, NY'",
     "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 'bedrock' --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 'openrouter' --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'",
     "ant_web_search": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/ant_web_search.ts --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'",
@@ -105,6 +105,10 @@
     "@langchain/ollama": "^0.2.3",
     "@langchain/openai": "0.5.18",
     "@langchain/xai": "^0.0.3",
+    "@langfuse/langchain": "^4.3.0",
+    "@langfuse/otel": "^4.3.0",
+    "@langfuse/tracing": "^4.3.0",
+    "@opentelemetry/sdk-node": "^0.207.0",
     "cheerio": "^1.0.0",
     "dotenv": "^16.4.7",
     "https-proxy-agent": "^7.0.6",

package/src/agents/AgentContext.ts

@@ -37,6 +37,7 @@ export class AgentContext {
       streamBuffer,
       maxContextTokens,
       reasoningKey,
+      useLegacyContent,
     } = agentConfig;
 
     const agentContext = new AgentContext({
@@ -53,6 +54,7 @@ export class AgentContext {
       toolEnd,
       instructionTokens: 0,
       tokenCounter,
+      useLegacyContent,
     });
 
     if (tokenCounter) {
@@ -123,6 +125,8 @@ export class AgentContext {
   >;
   /** Promise for token calculation initialization */
   tokenCalculationPromise?: Promise<void>;
+  /** Format content blocks as strings (for legacy compatibility) */
+  useLegacyContent: boolean = false;
 
   constructor({
     agentId,
@@ -138,6 +142,7 @@ export class AgentContext {
     reasoningKey,
     toolEnd,
     instructionTokens,
+    useLegacyContent,
   }: {
     agentId: string;
     provider: Providers;
@@ -152,6 +157,7 @@ export class AgentContext {
     reasoningKey?: 'reasoning_content' | 'reasoning';
     toolEnd?: boolean;
     instructionTokens?: number;
+    useLegacyContent?: boolean;
   }) {
     this.agentId = agentId;
     this.provider = provider;
@@ -173,6 +179,8 @@ export class AgentContext {
       this.instructionTokens = instructionTokens;
     }
 
+    this.useLegacyContent = useLegacyContent ?? false;
+
     this.systemRunnable = this.createSystemRunnable();
   }
 

package/src/graphs/Graph.ts

@@ -41,7 +41,9 @@ import {
   convertMessagesToContent,
   modifyDeltaProperties,
   formatArtifactPayload,
+  formatContentStrings,
   createPruneMessages,
+  addCacheControl,
 } from '@/messages';
 import {
   resetIfNotEmpty,
@@ -299,6 +301,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       agentContext.currentTokenType === 'think_and_text'
     ) {
       keyList.push('reasoning');
+    } else if (agentContext.tokenTypeSwitch === 'content') {
+      keyList.push('post-reasoning');
     }
 
     if (this.invokedToolIds != null && this.invokedToolIds.size > 0) {
@@ -580,7 +584,12 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
               null) ||
           (agentContext.provider === Providers.BEDROCK &&
             (agentContext.clientOptions as t.BedrockAnthropicInput)
-              .additionalModelRequestFields?.['thinking'] != null);
+              .additionalModelRequestFields?.['thinking'] != null) ||
+          (agentContext.provider === Providers.OPENAI &&
+            (
+              (agentContext.clientOptions as t.OpenAIClientOptions).modelKwargs
+                ?.thinking as t.AnthropicClientOptions['thinking']
+            )?.type === 'enabled');
 
         agentContext.pruneMessages = createPruneMessages({
           startIndex: this.startIndex,
@@ -601,7 +610,11 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         messagesToUse = context;
       }
 
-      const finalMessages = messagesToUse;
+      let finalMessages = messagesToUse;
+      if (agentContext.useLegacyContent) {
+        finalMessages = formatContentStrings(finalMessages);
+      }
+
       const lastMessageX =
         finalMessages.length >= 2
           ? finalMessages[finalMessages.length - 2]
@@ -635,6 +648,22 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         formatArtifactPayload(finalMessages);
       }
 
+      if (agentContext.provider === Providers.ANTHROPIC) {
+        const anthropicOptions = agentContext.clientOptions as
+          | t.AnthropicClientOptions
+          | undefined;
+        const defaultHeaders = anthropicOptions?.clientOptions
+          ?.defaultHeaders as Record<string, string> | undefined;
+        const anthropicBeta = defaultHeaders?.['anthropic-beta'];
+
+        if (
+          typeof anthropicBeta === 'string' &&
+          anthropicBeta.includes('prompt-caching')
+        ) {
+          finalMessages = addCacheControl<BaseMessage>(finalMessages);
+        }
+      }
+
       if (
         agentContext.lastStreamCall != null &&
         agentContext.streamBuffer != null

package/src/graphs/MultiAgentGraph.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod';
 import { tool } from '@langchain/core/tools';
+import { PromptTemplate } from '@langchain/core/prompts';
 import {
   ToolMessage,
   HumanMessage,
   getBufferString,
 } from '@langchain/core/messages';
-import { ChatPromptTemplate } from '@langchain/core/prompts';
 import {
   END,
   START,
@@ -508,16 +508,16 @@ export class MultiAgentGraph extends StandardGraph {
           let effectiveExcludeResults = excludeResults;
 
           if (typeof prompt === 'function') {
-            promptText = prompt(state.messages, this.startIndex);
+            promptText = await prompt(state.messages, this.startIndex);
           } else if (prompt != null) {
             if (prompt.includes('{results}')) {
               const resultsMessages = state.messages.slice(this.startIndex);
               const resultsString = getBufferString(resultsMessages);
-              const promptTemplate = ChatPromptTemplate.fromTemplate(prompt);
-              const formattedPromptValue = await promptTemplate.invoke({
+              const promptTemplate = PromptTemplate.fromTemplate(prompt);
+              const result = await promptTemplate.invoke({
                 results: resultsString,
               });
-              promptText = formattedPromptValue.messages[0].content.toString();
+              promptText = result.value;
               effectiveExcludeResults =
                 excludeResults !== false && promptText !== '';
             } else {

package/src/instrumentation.ts

@@ -0,0 +1,22 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { LangfuseSpanProcessor } from '@langfuse/otel';
+import { isPresent } from '@/utils/misc';
+
+if (
+  isPresent(process.env.LANGFUSE_SECRET_KEY) &&
+  isPresent(process.env.LANGFUSE_PUBLIC_KEY) &&
+  isPresent(process.env.LANGFUSE_BASE_URL)
+) {
+  const langfuseSpanProcessor = new LangfuseSpanProcessor({
+    publicKey: process.env.LANGFUSE_PUBLIC_KEY,
+    secretKey: process.env.LANGFUSE_SECRET_KEY,
+    baseUrl: process.env.LANGFUSE_BASE_URL,
+    environment: process.env.NODE_ENV ?? 'development',
+  });
+
+  const sdk = new NodeSDK({
+    spanProcessors: [langfuseSpanProcessor],
+  });
+
+  sdk.start();
+}