@librechat/agents 3.2.68 → 3.3.1

package/src/messages/format.ts

@@ -22,6 +22,7 @@ import type {
   SummaryContentBlock,
   ThinkingContentText,
   ToolCallContent,
+  ToolResultContent,
   ToolCallPart,
   TPayload,
   TMessage,
@@ -400,7 +401,8 @@ function hasMeaningfulAssistantContent(part: MessageContentComplex): boolean {
     part.type === ContentTypes.TOOL_CALL ||
     part.type === ContentTypes.ERROR ||
     part.type === ContentTypes.AGENT_UPDATE ||
-    part.type === ContentTypes.SUMMARY
+    part.type === ContentTypes.SUMMARY ||
+    part.type === ContentTypes.ACTIVITY_LABEL
   ) {
     return false;
   }
@@ -798,7 +800,8 @@ function formatAssistantMessage(
       } else if (
         part.type === ContentTypes.ERROR ||
         part.type === ContentTypes.AGENT_UPDATE ||
-        part.type === ContentTypes.SUMMARY
+        part.type === ContentTypes.SUMMARY ||
+        part.type === ContentTypes.ACTIVITY_LABEL
       ) {
         continue;
       } else {
@@ -914,6 +917,14 @@ function labelAllAgentContent(
 
   for (let i = 0; i < contentParts.length; i++) {
     const part = contentParts[i];
+    /** UI-only progress headers are not agent content and must not disturb
+     *  agent state: a label with no `agentIdMap` entry would otherwise read
+     *  as an agent change and flush the buffer mid-agent, splitting one
+     *  agent's contiguous content into two labeled blocks. Skipped before
+     *  any state transition below (mirrors the transfer path). */
+    if (part.type === ContentTypes.ACTIVITY_LABEL) {
+      continue;
+    }
     const agentId = agentIdMap[i];
 
     // If agent changed, flush previous buffer
@@ -1037,6 +1048,14 @@ export const labelContentByAgent = (
 
   for (let i = 0; i < contentParts.length; i++) {
     const part = contentParts[i];
+    /** UI-only progress headers are not agent content and must not disturb
+     *  agent state: a label with no `agentIdMap` entry would otherwise look
+     *  like an agent change, flushing the buffer and resetting an open
+     *  transfer capture so the transferred agent's following chunks lose
+     *  their frame. Skipped before any state transition below. */
+    if (part.type === ContentTypes.ACTIVITY_LABEL) {
+      continue;
+    }
     const agentId = agentIdMap[i];
 
     // Check if this is a transfer tool call
@@ -1806,6 +1825,65 @@ function appendMessageContent(
       continue;
     }
 
+    // A `tool_call` content block appears either as the v1 standard shape
+    // (`{ name, args }` at top level, which `@langchain/aws` maps to a Converse
+    // toolUse) or this repo's `ToolCallContent` (`{ tool_call: { name, args,
+    // output } }`, from `convertMessagesToContent` / persisted history). Handle
+    // both, and emit any embedded output, so the name/args/result survive.
+    if (block.type === 'tool_call') {
+      hasToolUseBlock = true;
+      const nested = (block as { tool_call?: ToolCallPart }).tool_call;
+      const name = String(nested?.name ?? block.name ?? '');
+      const rawArgs = nested?.args ?? block.args ?? {};
+      const argsText =
+        typeof rawArgs === 'string' ? rawArgs : JSON.stringify(rawArgs);
+      textChunks.push(`${role}: [tool_use] ${name} ${argsText}`.trimEnd());
+      const output = nested?.output;
+      if (output != null && output !== '') {
+        textChunks.push(`Tool: ${String(output)}`);
+      }
+      continue;
+    }
+
+    // A `tool_result` content block (e.g. an AIMessage(tool_call) followed by a
+    // user message carrying the result). Preserve nested image blocks as-is
+    // instead of JSON-stringifying them through the generic fallback.
+    if (block.type === 'tool_result') {
+      hasToolUseBlock = true;
+      const inner = (block as { content?: ToolResultContent['content'] })
+        .content;
+      if (typeof inner === 'string') {
+        if (inner) {
+          textChunks.push(`${role}: [tool_result] ${inner}`);
+        }
+      } else if (Array.isArray(inner)) {
+        for (const innerBlock of inner as Array<
+          string | ExtendedMessageContent
+        >) {
+          if (typeof innerBlock === 'string') {
+            if (innerBlock) {
+              textChunks.push(`${role}: [tool_result] ${innerBlock}`);
+            }
+          } else if (IMAGE_BLOCK_TYPES.has(innerBlock.type ?? '')) {
+            flushTextChunks(textChunks, parts);
+            parts.push({ ...innerBlock } as MessageContentComplex);
+          } else {
+            const innerText = innerBlock.text ?? innerBlock.input;
+            textChunks.push(
+              `${role}: [tool_result] ${
+                typeof innerText === 'string' && innerText
+                  ? innerText
+                  : JSON.stringify(innerBlock)
+              }`
+            );
+          }
+        }
+      } else if (inner != null) {
+        textChunks.push(`${role}: [tool_result] ${JSON.stringify(inner)}`);
+      }
+      continue;
+    }
+
     const text = block.text ?? block.input;
     if (typeof text === 'string' && text) {
       textChunks.push(`${role}: ${text}`);
@@ -1834,11 +1912,26 @@ function appendToolCalls(
     return;
   }
   const aiMsg = msg as AIMessage;
-  if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) {
+  if (aiMsg.tool_calls && aiMsg.tool_calls.length > 0) {
+    for (const tc of aiMsg.tool_calls) {
+      textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+    }
     return;
   }
-  for (const tc of aiMsg.tool_calls) {
-    textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+  // Fall back to raw provider tool calls kept only in additional_kwargs.
+  const rawToolCalls = aiMsg.additional_kwargs.tool_calls;
+  if (!Array.isArray(rawToolCalls)) {
+    return;
+  }
+  for (const tc of rawToolCalls) {
+    const fn = (tc as { function?: { name?: string; arguments?: string } })
+      .function;
+    if (fn == null) {
+      continue;
+    }
+    textChunks.push(
+      `AI: [tool_call] ${String(fn.name ?? '')}(${String(fn.arguments ?? '')})`
+    );
   }
 }
 
@@ -2024,6 +2117,141 @@ export function ensureThinkingBlockInMessages(
   return result;
 }
 
+/** Whether a message carries tool content a tool-less agent cannot legally
+ *  send. Covers every representation a provider converter will serialize back
+ *  into a request: a ToolMessage, parsed `AIMessage.tool_calls`, raw
+ *  `additional_kwargs.tool_calls` (OpenAI keeps calls here when the parsed
+ *  array is empty), and `tool_use` / `tool_call` / `tool_result` content
+ *  blocks (`@langchain/aws` and the Anthropic converter map these to Converse
+ *  `toolUse` / `toolResult`). Missing the parent AI message is not just a
+ *  passthrough: folding its ToolMessage alone would leave an orphan
+ *  `assistant(tool_calls) -> user(...)` sequence. */
+function messageHasToolContent(msg: BaseMessage): boolean {
+  if (isToolMessage(msg)) {
+    return true;
+  }
+  const aiMsg = msg as AIMessage;
+  if (aiMsg.tool_calls != null && aiMsg.tool_calls.length > 0) {
+    return true;
+  }
+  const rawToolCalls = aiMsg.additional_kwargs.tool_calls;
+  if (Array.isArray(rawToolCalls) && rawToolCalls.length > 0) {
+    return true;
+  }
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content as ExtendedMessageContent[]) {
+      if (
+        typeof block === 'object' &&
+        (block.type === 'tool_use' ||
+          block.type === 'tool_call' ||
+          block.type === 'tool_result')
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/** Whether a message carries a tool RESULT: a ToolMessage, or a message whose
+ *  content includes a `tool_result` block (the shape when a call/result pair is
+ *  split as `AIMessage(tool_call)` + `HumanMessage(tool_result)`). Such a result
+ *  belongs with the preceding tool call, so it is absorbed into the same fold
+ *  and labelled as tool output. */
+function isToolResultMessage(msg: BaseMessage): boolean {
+  if (isToolMessage(msg)) {
+    return true;
+  }
+  if (Array.isArray(msg.content)) {
+    return (msg.content as ExtendedMessageContent[]).some(
+      (block) => typeof block === 'object' && block.type === 'tool_result'
+    );
+  }
+  return false;
+}
+
+/**
+ * Folds tool_use / tool_result content into plain text for an agent that binds
+ * no tools.
+ *
+ * In a multi-agent graph, a tool-less destination still inherits the prior
+ * agent's conversation history, which can contain toolUse/toolResult blocks.
+ * Because it binds no tools, the model is invoked with no tool schema — and
+ * Bedrock's Converse API rejects any request that carries toolUse/toolResult
+ * blocks without a top-level toolConfig ("The toolConfig field must be defined
+ * when using toolUse and toolResult content blocks"). Adding a dummy toolConfig
+ * is not an option: AWS requires at least one tool, and it would expose a
+ * capability the destination was intentionally denied.
+ *
+ * Each tool-call turn plus its trailing tool results (ToolMessages or
+ * `tool_result` content blocks) is collapsed into a single `[Previous tool
+ * interaction]` HumanMessage that preserves the tool name, arguments and result
+ * as text (image blocks are kept as-is). Runs in a single pass: non-tool
+ * messages pass through, `result` is allocated lazily on the first fold, and the
+ * original array is returned unchanged when it holds no tool content (the common
+ * fresh-tool-less-agent case).
+ */
+export function foldToolBlocksForToollessAgent(
+  messages: BaseMessage[],
+  config?: RunnableConfig
+): BaseMessage[] {
+  let result: BaseMessage[] | null = null;
+  let foldedCount = 0;
+  let i = 0;
+  while (i < messages.length) {
+    const msg = messages[i];
+    if (!messageHasToolContent(msg)) {
+      result?.push(msg);
+      i++;
+      continue;
+    }
+
+    /** First fold — copy the untouched prefix once, then append from here. */
+    if (result === null) {
+      result = messages.slice(0, i);
+    }
+
+    const parts: MessageContentComplex[] = [];
+    const textChunks: string[] = ['[Previous tool interaction]'];
+    appendMessageContent(
+      msg,
+      isToolResultMessage(msg) ? 'Tool' : 'AI',
+      textChunks,
+      parts
+    );
+    foldedCount++;
+
+    let j = i + 1;
+    while (j < messages.length && isToolResultMessage(messages[j])) {
+      appendMessageContent(messages[j], 'Tool', textChunks, parts);
+      foldedCount++;
+      j++;
+    }
+
+    flushTextChunks(textChunks, parts);
+    result.push(
+      withMessageRole(
+        new HumanMessage({ content: toLangChainContent(parts) }),
+        'user'
+      )
+    );
+    i = j;
+  }
+
+  if (result === null) {
+    return messages;
+  }
+
+  emitAgentLog(
+    config,
+    'warn',
+    'format',
+    `foldToolBlocksForToollessAgent: folded ${foldedCount} tool message(s) into text for a tool-less agent`
+  );
+
+  return result;
+}
+
 /**
  * Walks backwards from `currentIndex` through the message array to check
  * whether an earlier AI message in the same "chain" (no HumanMessage boundary)

package/src/messages/prune.ts

@@ -80,10 +80,18 @@ export function enforceOriginalContentCap(map: Map<number, string>): void {
 
 /** Minimum cumulative calibration ratio — provider can't count fewer tokens
  *  than our raw estimate (within reason). Prevents divide-by-zero edge cases. */
-const CALIBRATION_RATIO_MIN = 0.5;
+export const CALIBRATION_RATIO_MIN = 0.5;
 
 /** Maximum cumulative calibration ratio — sanity cap for the running ratio. */
-const CALIBRATION_RATIO_MAX = 5;
+export const CALIBRATION_RATIO_MAX = 5;
+
+/** Keeps provider/local token calibration within the shared safe range. */
+export function clampCalibrationRatio(ratio: number): number {
+  return Math.max(
+    CALIBRATION_RATIO_MIN,
+    Math.min(CALIBRATION_RATIO_MAX, ratio)
+  );
+}
 
 export type PruneMessagesFactoryParams = {
   provider?: Providers;
@@ -1002,8 +1010,8 @@ export function maskConsumedToolResults(params: {
   /** When provided, original (pre-masking) content is stored here keyed by
    *  message index — only for entries that actually get truncated. */
   originalContentStore?: Map<number, string>;
-  /** Called after storing content with the char length of the stored entry. */
-  onContentStored?: (charLength: number) => void;
+  /** Called after storing a newly captured entry. */
+  onContentStored?: (index: number, content: string) => void;
 }): number {
   const { messages, indexTokenCountMap, tokenCounter } = params;
   let maskedCount = 0;
@@ -1079,7 +1087,7 @@ export function maskConsumedToolResults(params: {
     if (params.originalContentStore && !params.originalContentStore.has(i)) {
       params.originalContentStore.set(i, content);
       if (params.onContentStored) {
-        params.onContentStored(content.length);
+        params.onContentStored(i, content);
       }
     }
 
@@ -1311,6 +1319,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
     remainingContextTokens?: number;
     contextPressure?: number;
     originalToolContent?: Map<number, string>;
+    newOriginalToolContent?: Map<number, string>;
     calibrationRatio?: number;
     resolvedInstructionOverhead?: number;
     /** Usable budget this call: maxTokens minus output reserve */
@@ -1318,6 +1327,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
     /** Calibrated instruction overhead actually applied this call */
     effectiveInstructionTokens?: number;
   } {
+    let newOriginalToolContent: Map<number, string> | undefined;
     if (params.messages.length === 0) {
       /** Post-compaction calls still invoke the model — report the same
        *  reserve-adjusted budget fields as the populated paths */
@@ -1479,10 +1489,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
         cumulativeRawSent += rawSentThisTurn;
         cumulativeProviderReported += providerMessageTokens;
         const newRatio = cumulativeProviderReported / cumulativeRawSent;
-        calibrationRatio = Math.max(
-          CALIBRATION_RATIO_MIN,
-          Math.min(CALIBRATION_RATIO_MAX, newRatio)
-        );
+        calibrationRatio = clampCalibrationRatio(newRatio);
 
         const calibratedOurTotal =
           instructionOverhead + rawSentThisTurn * calibrationRatio;
@@ -1661,8 +1668,12 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
             : undefined,
         onContentStored:
           factoryParams.summarizationEnabled === true
-            ? (charLen: number): void => {
-              originalToolContentSize += charLen;
+            ? (index: number, content: string): void => {
+              originalToolContentSize += content.length;
+              if (newOriginalToolContent == null) {
+                newOriginalToolContent = new Map();
+              }
+              newOriginalToolContent.set(index, content);
               while (
                 originalToolContentSize > ORIGINAL_CONTENT_MAX_CHARS &&
                   originalToolContent.size > 0
@@ -1798,6 +1809,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
         contextPressure,
         originalToolContent:
           originalToolContent.size > 0 ? originalToolContent : undefined,
+        newOriginalToolContent,
         calibrationRatio,
         resolvedInstructionOverhead: bestInstructionOverhead,
         contextBudget: pruningBudget,
@@ -2182,6 +2194,7 @@ export function createPruneMessages(factoryParams: PruneMessagesFactoryParams) {
       contextPressure,
       originalToolContent:
         originalToolContent.size > 0 ? originalToolContent : undefined,
+      newOriginalToolContent,
       calibrationRatio,
       resolvedInstructionOverhead: bestInstructionOverhead,
       contextBudget: pruningBudget,

package/src/messages/recency.ts

@@ -1,5 +1,7 @@
 import type { BaseMessage } from '@langchain/core/messages';
 
+export const DEFAULT_RETAIN_RECENT_TURNS = 2;
+
 /**
  * Configuration for splitting a message list into a head (to be summarized)
  * and a tail (to be preserved verbatim).
@@ -68,7 +70,7 @@ export function splitAtRecencyBoundary(
   messages: BaseMessage[],
   options: RecencyWindowOptions = {}
 ): RecencySplit {
-  const turnsCap = options.turns ?? 2;
+  const turnsCap = options.turns ?? DEFAULT_RETAIN_RECENT_TURNS;
 
   if (messages.length === 0 || turnsCap <= 0) {
     return {

package/src/prompts/activityLabel.ts

@@ -0,0 +1,177 @@
+import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';
+import type { ActivityLabelToolEntry } from '@/types/activityLabel';
+import { shouldRedactTool } from '@/langfuseToolOutputTracing';
+
+/**
+ * Default system prompt for fast-model activity labeling.
+ *
+ * Style synthesized from Claude Code's tool-use summary prompt (git-subject
+ * register, past tense, distinctive nouns) and claude.ai's observed group
+ * headers (5–9 words describing a mixed reasoning + tool block, e.g.
+ * "Synthesized version data and curated comparative framework").
+ */
+export const ACTIVITY_LABEL_PROMPT = `Write a short label describing what this block of agent activity accomplished. It appears as the header of a collapsed activity group in a chat UI.
+
+Rules:
+- 5 to 9 words, past-tense verb first
+- Name the most distinctive subject (file, API, topic); drop articles and filler
+- Describe outcomes, not mechanics; if something failed, say so plainly
+- Output only the label — no quotes, no punctuation at the end, no preamble
+
+Examples:
+- Searched Node.js release notes and changelogs
+- Compared runtime versions across official sources
+- Fixed failing auth middleware tests
+- Read project config and dependency manifests
+- Attempted database migration, hit permission errors`;
+
+/** Truncates a serialized value for the label prompt. */
+export function truncateForLabel(value: string, maxLength: number): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return value.slice(0, Math.max(0, maxLength - 1)) + '…';
+}
+
+const ABORT_SERIALIZATION = Symbol('abort-label-serialization');
+
+/**
+ * Serializes a tool value for the prompt WITHOUT materializing huge JSON:
+ * the output is clipped to a few hundred characters anyway, so a multi-
+ * megabyte tool result must not be stringified in full on the label path.
+ * Strings clip immediately; structured values serialize under a character
+ * budget and degrade to a shape summary once it is exhausted.
+ */
+function serializeForLabel(value: unknown, limit: number): string {
+  if (value == null) {
+    return '';
+  }
+  if (typeof value === 'string') {
+    return value.length > limit ? value.slice(0, limit + 1) : value;
+  }
+  let budget = limit * 4;
+  try {
+    return (
+      JSON.stringify(value, (_key, nested: unknown) => {
+        if (budget <= 0) {
+          throw ABORT_SERIALIZATION;
+        }
+        if (typeof nested === 'string') {
+          const clipped =
+            nested.length > limit ? nested.slice(0, limit) : nested;
+          budget -= clipped.length;
+          return clipped;
+        }
+        budget -= 8;
+        return nested;
+      }) ?? ''
+    );
+  } catch (error) {
+    if (error === ABORT_SERIALIZATION) {
+      return Array.isArray(value) ? `[Array(${value.length})]` : '[Object]';
+    }
+    return String(value);
+  }
+}
+
+const INPUT_CONTEXT_LIMIT = 200;
+const MAX_THINKING_EXCERPTS = 4;
+/** A label is 5-9 words; no batch needs more than this many entries to
+ *  produce one, and the cap keeps a 200-call programmatic batch from
+ *  building an enormous prompt out of per-field-bounded pieces. */
+const MAX_PROMPT_ENTRIES = 12;
+
+export type BuildActivityLabelPromptParams = {
+  entries: ActivityLabelToolEntry[];
+  charLimit: number;
+  thinkingExcerpts?: string[];
+  lastAssistantText?: string;
+  /**
+   * Resolved tool-output tracing policy. The label prompt becomes Langfuse
+   * generation input, so outputs/errors excluded from tracing (global
+   * disable or `redactedToolNames`) must never appear in it — the same
+   * redaction the span processor applies to structured tool observations.
+   */
+  redaction?: ResolvedLangfuseToolOutputTracingConfig;
+};
+
+/**
+ * Builds the user prompt for a fast-model activity label. Pure — exported
+ * for direct testing of redaction and truncation behavior.
+ */
+export function buildActivityLabelPrompt({
+  entries,
+  charLimit,
+  thinkingExcerpts,
+  lastAssistantText,
+  redaction,
+}: BuildActivityLabelPromptParams): string {
+  const clip = truncateForLabel;
+  /** Reasoning and intent text can quote tool output verbatim — including
+   *  output from EARLIER calls to a redacted tool that this batch does not
+   *  contain — so any active policy (global disable or a configured
+   *  redacted-name list) drops both wholesale. There is no reliable way to
+   *  scrub a quoted fragment out of free-form model prose. */
+  const excerptsRedacted =
+    redaction != null &&
+    (redaction.enabled === false || redaction.redactedToolNames.size > 0);
+  const sections: string[] = [];
+  /** Intent text is free-form assistant prose that can quote a redacted
+   *  tool result just as reasoning can, so it shares the excerpts' fate. */
+  if (
+    !excerptsRedacted &&
+    lastAssistantText != null &&
+    lastAssistantText.length > 0
+  ) {
+    sections.push(
+      `Intent (assistant's last message): ${clip(lastAssistantText, INPUT_CONTEXT_LIMIT)}`
+    );
+  }
+  if (
+    !excerptsRedacted &&
+    thinkingExcerpts != null &&
+    thinkingExcerpts.length > 0
+  ) {
+    sections.push(
+      'Reasoning excerpts:\n' +
+        thinkingExcerpts
+          .slice(0, MAX_THINKING_EXCERPTS)
+          .map((excerpt) => `- ${clip(excerpt, charLimit)}`)
+          .join('\n')
+    );
+  }
+  if (entries.length > 0) {
+    const shown = entries.slice(0, MAX_PROMPT_ENTRIES);
+    const omitted = entries.length - shown.length;
+    sections.push(
+      'Tool calls:\n' +
+        shown
+          .map((entry) => {
+            const input = clip(
+              serializeForLabel(entry.toolInput, charLimit),
+              charLimit
+            );
+            const redacted =
+              redaction != null && shouldRedactTool(entry.toolName, redaction);
+            let outcome: string;
+            if (redacted) {
+              outcome = redaction.redactionText;
+            } else if (entry.status === 'error') {
+              outcome = `ERROR: ${clip(entry.error ?? 'unknown error', charLimit)}`;
+            } else {
+              outcome = clip(
+                serializeForLabel(entry.toolOutput, charLimit),
+                charLimit
+              );
+            }
+            return `- ${entry.toolName}(${input}) → ${outcome}`;
+          })
+          .join('\n') +
+        (omitted > 0
+          ? `\n- …and ${omitted} more tool ${omitted === 1 ? 'call' : 'calls'}`
+          : '')
+    );
+  }
+  sections.push('Label:');
+  return sections.join('\n\n');
+}