@librechat/agents 3.2.68 → 3.3.0

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

@@ -178,4 +178,26 @@ export declare function shiftIndexTokenCountMap(indexTokenCountMap: Record<numbe
  * @returns The messages array with tool sequences converted to buffer strings if necessary
  */
 export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: Providers, config?: RunnableConfig, runStartIndex?: number): BaseMessage[];
+/**
+ * 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 declare function foldToolBlocksForToollessAgent(messages: BaseMessage[], config?: RunnableConfig): BaseMessage[];
 export {};

package/dist/types/prompts/activityLabel.d.ts

@@ -0,0 +1,31 @@
+import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';
+import type { ActivityLabelToolEntry } from '@/types/activityLabel';
+/**
+ * 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 declare 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.\n\nRules:\n- 5 to 9 words, past-tense verb first\n- Name the most distinctive subject (file, API, topic); drop articles and filler\n- Describe outcomes, not mechanics; if something failed, say so plainly\n- Output only the label \u2014 no quotes, no punctuation at the end, no preamble\n\nExamples:\n- Searched Node.js release notes and changelogs\n- Compared runtime versions across official sources\n- Fixed failing auth middleware tests\n- Read project config and dependency manifests\n- Attempted database migration, hit permission errors";
+/** Truncates a serialized value for the label prompt. */
+export declare function truncateForLabel(value: string, maxLength: number): string;
+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 declare function buildActivityLabelPrompt({ entries, charLimit, thinkingExcerpts, lastAssistantText, redaction, }: BuildActivityLabelPromptParams): string;

package/dist/types/run.d.ts

@@ -39,6 +39,8 @@ export declare class Run<_T extends t.BaseGraphState> {
      * lets callers assert the type they expect.
      */
     private _interrupt;
+    /** Per-run sequence for batch-unique activity-label trace-seed fallbacks. */
+    private activityLabelSeq;
     private _haltedReason;
     private constructor();
     private createLegacyGraph;
@@ -207,4 +209,16 @@ export declare class Run<_T extends t.BaseGraphState> {
         language?: string;
         title?: string;
     }>;
+    /**
+     * Generates a short activity label for a completed tool/reasoning block
+     * using a fast model. Mirrors `generateTitle`'s Langfuse wiring so the
+     * call is traced under the conversation's session (sessionId from
+     * `chainOptions.configurable.thread_id`) with its own tags — never as an
+     * orphan trace. The payload contains no human messages by design: intent
+     * comes from `lastAssistantText`, content from reasoning excerpts and
+     * tool entries.
+     */
+    generateActivityLabel({ provider, clientOptions, entries, thinkingExcerpts, lastAssistantText, prompt, charLimit, chainOptions, traceSeed, agentId, }: t.RunActivityLabelOptions): Promise<{
+        label?: string;
+    }>;
 }

package/dist/types/types/activityLabel.d.ts

@@ -0,0 +1,53 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ClientOptions } from '@/types/llm';
+import type { Providers } from '@/common';
+/** One tool call's contribution to the label payload (host-assembled). */
+export type ActivityLabelToolEntry = {
+    toolName: string;
+    toolInput: unknown;
+    toolOutput?: unknown;
+    error?: string;
+    status: 'success' | 'error';
+};
+/**
+ * Options for `Run.generateActivityLabel`. The payload deliberately contains
+ * NO human messages: intent context comes from the assistant's own last text
+ * (Claude Code's pattern) and the block's reasoning excerpts (claude.ai's
+ * pattern) — user text stays out of this low-scrutiny pathway entirely.
+ *
+ * This SDK defines NO activity-label graph event and never dispatches one.
+ * Label lifecycle streaming is entirely host-owned: a host claims its own
+ * content slots and emits on its own transport, with a payload shape only
+ * it defines. The SDK surface here is exactly this method plus the
+ * `activity_label` content type's formatter exclusions.
+ */
+export type RunActivityLabelOptions = {
+    provider: Providers;
+    clientOptions?: ClientOptions;
+    /**
+     * Agent that executed the labeled batch. Selects that agent's Langfuse
+     * overlay (trace metadata AND tool-output redaction policy) instead of
+     * the graph default — a stricter per-agent policy must not be bypassed
+     * by labeling work the default agent never performed.
+     */
+    agentId?: string;
+    entries: ActivityLabelToolEntry[];
+    /** Truncated reasoning excerpts from the block being labeled. */
+    thinkingExcerpts?: string[];
+    /** Assistant's last text before the block (~200 chars), as intent context. */
+    lastAssistantText?: string;
+    /** Override for the default label system prompt. */
+    prompt?: string;
+    /** Per-entry serialization cap for the prompt. Default 600. */
+    charLimit?: number;
+    /** LangChain runnable config carrier (signal, callbacks, thread/user ids). */
+    chainOptions?: Partial<RunnableConfig> & {
+        configurable?: Record<string, unknown>;
+    };
+    /**
+     * Seed for deterministic Langfuse trace ids (e.g. `${runId}-${slotIndex}`)
+     * so each batch's label gets a distinct, reproducible trace. When omitted,
+     * a per-run sequence keeps batches from collapsing into one trace.
+     */
+    traceSeed?: string;
+};

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

@@ -7,3 +7,4 @@ export * from './skill';
 export * from './stream';
 export * from './tools';
 export * from './summarize';
+export * from './activityLabel';

package/dist/types/types/stream.d.ts

@@ -138,6 +138,8 @@ export interface ExtendedMessageContent {
     type?: string;
     text?: string;
     input?: string;
+    /** Tool-call arguments on a v1 standard-content `tool_call` block. */
+    args?: ToolCallPart['args'];
     index?: string | number;
     id?: string;
     name?: string;

package/package.json

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

package/src/common/enum.ts

@@ -142,6 +142,8 @@ export enum ContentTypes {
   REASONING_CONTENT = 'reasoning_content',
   /** Mid-run user steer persisted inline in an assistant message; replayed as a user turn */
   STEER = 'steer',
+  /** Fast-model activity label for a tool/reasoning block; UI-only, never model input */
+  ACTIVITY_LABEL = 'activity_label',
 }
 
 export enum ToolCallTypes {

package/src/graphs/Graph.ts

@@ -16,6 +16,7 @@ import type * as t from '@/types';
 import {
   formatAnthropicArtifactContent,
   ensureThinkingBlockInMessages,
+  foldToolBlocksForToollessAgent,
   convertMessagesToContent,
   sanitizeOrphanToolBlocks,
   extractToolDiscoveries,
@@ -1864,6 +1865,25 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         );
       }
 
+      /**
+       * A destination that binds no tools is invoked without a tool schema, but
+       * in a multi-agent graph it can still inherit a prior agent's toolUse/
+       * toolResult history. Bedrock's Converse API (and other tool-schema-strict
+       * providers) reject such a request when no top-level toolConfig is sent.
+       * Fold that historical tool content into plain text so the tool-less agent
+       * receives valid, context-preserving messages. Handoff tools count as
+       * bound tools, so a tool-less router mid-handoff is not affected.
+       */
+      if (toolsForBinding == null || toolsForBinding.length === 0) {
+        finalMessages = foldToolBlocksForToollessAgent(finalMessages, config);
+        // The fold emits structured (array) content; re-flatten for agents that
+        // opted into string-only messages (`useLegacyContent`, run earlier at
+        // the top of this block) so the folded turn isn't the lone exception.
+        if (agentContext.useLegacyContent) {
+          finalMessages = formatContentStrings(finalMessages);
+        }
+      }
+
       // Determine the prompt-cache strategy up front. Two distinct facts:
       //
       //   `providerPromptCacheEnabled` — prompt caching is on for this provider

package/src/langfuseToolOutputTracing.ts

@@ -84,7 +84,10 @@ function toolNameMatches(
   return config.redactedToolNames.has(normalizedToolName);
 }
 
-function shouldRedactTool(
+/** Whether a tool's outputs are excluded from tracing (global disable or
+ *  `redactedToolNames` match). Exported for the activity-label prompt
+ *  builder, whose prompt becomes Langfuse generation input. */
+export function shouldRedactTool(
   toolName: string | undefined,
   config: ResolvedLangfuseToolOutputTracingConfig
 ): boolean {

package/src/messages/foldToollessToolBlocks.test.ts

@@ -0,0 +1,438 @@
+import {
+  AIMessage,
+  BaseMessage,
+  HumanMessage,
+  SystemMessage,
+  ToolMessage,
+} from '@langchain/core/messages';
+import type { ExtendedMessageContent } from '@/types';
+import { foldToolBlocksForToollessAgent } from './format';
+
+/** Concatenated text across a message's content (string or structured array). */
+function getTextContent(msg: {
+  content: string | ExtendedMessageContent[];
+}): string {
+  if (typeof msg.content === 'string') {
+    return msg.content;
+  }
+  if (Array.isArray(msg.content)) {
+    return (msg.content as ExtendedMessageContent[])
+      .filter((b) => b.type === 'text')
+      .map((b) => String(b.text ?? ''))
+      .join('\n');
+  }
+  return '';
+}
+
+/** Any residual tool content that a tool-less agent cannot legally send. */
+function hasResidualToolContent(messages: BaseMessage[]): boolean {
+  return messages.some((m) => {
+    if (m instanceof ToolMessage) {
+      return true;
+    }
+    const ai = m as AIMessage;
+    if (ai.tool_calls != null && ai.tool_calls.length > 0) {
+      return true;
+    }
+    const rawToolCalls = ai.additional_kwargs.tool_calls;
+    if (Array.isArray(rawToolCalls) && rawToolCalls.length > 0) {
+      return true;
+    }
+    if (Array.isArray(m.content)) {
+      return (m.content as ExtendedMessageContent[]).some(
+        (b) =>
+          typeof b === 'object' &&
+          (b.type === 'tool_use' ||
+            b.type === 'tool_call' ||
+            b.type === 'tool_result')
+      );
+    }
+    return false;
+  });
+}
+
+describe('foldToolBlocksForToollessAgent', () => {
+  test('returns the same array reference when there is no tool content', () => {
+    const messages = [
+      new SystemMessage('You are helpful.'),
+      new HumanMessage('Hi'),
+      new AIMessage('Hello!'),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(result).toBe(messages);
+  });
+
+  test('folds an AI tool call plus its ToolMessage into one HumanMessage', () => {
+    const messages = [
+      new HumanMessage('Search my files for "roadmap"'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'file_search',
+            args: { query: 'roadmap' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'Found roadmap.md',
+        tool_call_id: 'call_1',
+        name: 'file_search',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    // Human prompt kept, AI+Tool collapsed into a single HumanMessage.
+    expect(result).toHaveLength(2);
+    expect(result[0]).toBeInstanceOf(HumanMessage);
+    const folded = getTextContent(result[1]);
+    expect(folded).toContain('[Previous tool interaction]');
+    expect(folded).toContain('file_search');
+    expect(folded).toContain('roadmap');
+    expect(folded).toContain('Found roadmap.md');
+  });
+
+  test('folds historical tool content that precedes the last human turn (the reported bug)', () => {
+    const messages = [
+      new HumanMessage('Search my files for "roadmap"'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'file_search',
+            args: { query: 'roadmap' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'Found roadmap.md',
+        tool_call_id: 'call_1',
+        name: 'file_search',
+      }),
+      new AIMessage('Here is what I found in roadmap.md.'),
+      new HumanMessage('thanks'),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    // The trailing plain-text turns survive untouched.
+    const last = result[result.length - 1];
+    expect(last).toBeInstanceOf(HumanMessage);
+    expect(getTextContent(last)).toBe('thanks');
+    expect(
+      result.some((m) => getTextContent(m).includes('Here is what I found'))
+    ).toBe(true);
+  });
+
+  test('folds parallel tool calls and all their results together', () => {
+    const messages = [
+      new HumanMessage('Look up A and B'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'a', name: 'lookup', args: { key: 'A' }, type: 'tool_call' },
+          { id: 'b', name: 'lookup', args: { key: 'B' }, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({ content: 'A=1', tool_call_id: 'a', name: 'lookup' }),
+      new ToolMessage({ content: 'B=2', tool_call_id: 'b', name: 'lookup' }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    expect(result).toHaveLength(2);
+    const folded = getTextContent(result[1]);
+    expect(folded).toContain('A=1');
+    expect(folded).toContain('B=2');
+  });
+
+  test('detects Anthropic-style tool_use content blocks', () => {
+    const messages = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Let me search.' },
+          {
+            type: 'tool_use',
+            id: 'call_1',
+            name: 'file_search',
+            input: { query: 'roadmap' },
+          },
+        ],
+      }),
+      new ToolMessage({
+        content: 'Found roadmap.md',
+        tool_call_id: 'call_1',
+        name: 'file_search',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    const folded = getTextContent(result[result.length - 1]);
+    expect(folded).toContain('Let me search.');
+    expect(folded).toContain('file_search');
+  });
+
+  test('folds an AI message whose tool call is only in additional_kwargs', () => {
+    const messages = [
+      new HumanMessage('Search my files'),
+      // Parsed `tool_calls` is empty; the call survives only in the raw
+      // additional_kwargs. The OpenAI converter still serializes it, so the
+      // parent AI message must fold with its ToolMessage — otherwise the fold
+      // would leave an orphan assistant(tool_calls) -> user(...) sequence.
+      new AIMessage({
+        content: '',
+        additional_kwargs: {
+          tool_calls: [
+            {
+              id: 'call_1',
+              type: 'function',
+              function: {
+                name: 'file_search',
+                arguments: '{"query":"roadmap"}',
+              },
+            },
+          ],
+        },
+      }),
+      new ToolMessage({
+        content: 'Found roadmap.md',
+        tool_call_id: 'call_1',
+        name: 'file_search',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    expect(result).toHaveLength(2);
+    const folded = getTextContent(result[1]);
+    expect(folded).toContain('file_search');
+    expect(folded).toContain('roadmap');
+    expect(folded).toContain('Found roadmap.md');
+  });
+
+  test('folds a standard tool_result content block on a user message', () => {
+    const messages = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          {
+            id: 'call_1',
+            name: 'file_search',
+            args: { query: 'roadmap' },
+            type: 'tool_call',
+          },
+        ],
+      }),
+      // Tool result stored as a content block on a user message (the shape the
+      // Anthropic converter produces/accepts) rather than a ToolMessage.
+      new HumanMessage({
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'call_1',
+            content: 'Found roadmap.md',
+          },
+        ],
+      }),
+      new HumanMessage('thanks'),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    expect(result.map(getTextContent).join('\n')).toContain('Found roadmap.md');
+  });
+
+  test('detects v1 standard-content tool_call blocks (no AIMessage.tool_calls)', () => {
+    const messages = [
+      new HumanMessage('Search'),
+      // LangChain v1 standard content: the tool call lives only as a
+      // `tool_call` content block; @langchain/aws still serializes it to a
+      // Converse toolUse, so a tool-less destination must fold it too.
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Searching.' },
+          {
+            type: 'tool_call',
+            id: 'call_1',
+            name: 'file_search',
+            args: { query: 'roadmap' },
+          },
+        ],
+        response_metadata: { output_version: 'v1' },
+      }),
+      new ToolMessage({
+        content: 'Found roadmap.md',
+        tool_call_id: 'call_1',
+        name: 'file_search',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    const folded = getTextContent(result[result.length - 1]);
+    expect(folded).toContain('file_search');
+    expect(folded).toContain('roadmap');
+    expect(folded).toContain('Found roadmap.md');
+  });
+
+  test('preserves name/args/output of the nested ToolCallContent shape', () => {
+    const messages = [
+      new HumanMessage('Search'),
+      // Shape produced by convertMessagesToContent / persisted LibreChat history:
+      // the call (and its output) are nested under `tool_call`, not top level.
+      new AIMessage({
+        content: [
+          {
+            type: 'tool_call',
+            tool_call: {
+              type: 'tool_call',
+              name: 'file_search',
+              args: { query: 'roadmap' },
+              output: 'Found roadmap.md',
+            },
+          },
+        ],
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    const folded = result.map(getTextContent).join('\n');
+    expect(folded).toContain('file_search');
+    expect(folded).toContain('roadmap');
+    // The embedded tool output is preserved, not dropped.
+    expect(folded).toContain('Found roadmap.md');
+  });
+
+  test('folds a split AIMessage(tool_call) + tool_result user message as one turn', () => {
+    const messages = [
+      new HumanMessage('Search'),
+      new AIMessage({
+        content: [
+          { type: 'text', text: 'Let me search.' },
+          {
+            type: 'tool_call',
+            id: 'c1',
+            name: 'file_search',
+            args: { query: 'roadmap' },
+          },
+        ],
+      }),
+      new HumanMessage({
+        content: [
+          { type: 'tool_result', tool_use_id: 'c1', content: 'Found roadmap.md' },
+        ],
+      }),
+      new HumanMessage('thanks'),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    // Call + result collapse into ONE folded turn (not split/mislabelled).
+    expect(result).toHaveLength(3);
+    const folded = getTextContent(result[1]);
+    expect(folded).toContain('file_search');
+    expect(folded).toContain('Found roadmap.md');
+    expect(getTextContent(result[2])).toBe('thanks');
+  });
+
+  test('preserves image blocks nested inside a tool_result content block', () => {
+    const messages = [
+      new HumanMessage('Chart'),
+      new AIMessage({
+        content: [{ type: 'tool_call', id: 'c1', name: 'chart', args: {} }],
+      }),
+      new HumanMessage({
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'c1',
+            content: [
+              { type: 'text', text: 'chart:' },
+              {
+                type: 'image_url',
+                image_url: { url: 'data:image/png;base64,AAAA' },
+              },
+            ],
+          },
+        ],
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    const folded = result[result.length - 1].content;
+    expect(Array.isArray(folded)).toBe(true);
+    expect(
+      (folded as ExtendedMessageContent[]).some((b) => b.type === 'image_url')
+    ).toBe(true);
+  });
+
+  test('preserves image blocks in a tool result instead of stringifying them', () => {
+    const messages = [
+      new HumanMessage('Render a chart'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'c', name: 'chart', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: [
+          { type: 'text', text: 'chart:' },
+          {
+            type: 'image_url',
+            image_url: { url: 'data:image/png;base64,AAAA' },
+          },
+        ],
+        tool_call_id: 'c',
+        name: 'chart',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    const foldedContent = result[result.length - 1].content;
+    expect(Array.isArray(foldedContent)).toBe(true);
+    expect(
+      (foldedContent as ExtendedMessageContent[]).some(
+        (b) => b.type === 'image_url'
+      )
+    ).toBe(true);
+  });
+
+  test('leaves non-tool conversations untouched', () => {
+    const messages = [
+      new SystemMessage('sys'),
+      new HumanMessage('hi'),
+      new AIMessage('hello'),
+      new HumanMessage('bye'),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+
+    expect(result).toBe(messages);
+    expect(hasResidualToolContent(result)).toBe(false);
+  });
+});