@librechat/agents 3.2.67 → 3.3.0

package/dist/types/llm/google/utils/common.d.ts

@@ -21,6 +21,15 @@ export declare function getMessageAuthor(message: BaseMessage): string;
 export declare function convertAuthorToRole(author: string): (typeof POSSIBLE_ROLES)[number];
 export declare function convertMessageContentToParts(message: BaseMessage, isMultimodalModel: boolean, previousMessages: BaseMessage[], model?: string): Part[];
 export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean, convertSystemMessageToHumanContent?: boolean, model?: string): Content[] | undefined;
+export declare function rejectsModelTurnPrefill(model?: string): boolean;
+/**
+ * Drops trailing `model`-role turns for models that reject prefill (see
+ * {@link rejectsModelTurnPrefill}). Such a turn is only produced by prefill
+ * flows (e.g. editing an assistant reply and resubmitting); these models return
+ * HTTP 400 for it, so we drop it and let the model generate fresh from the
+ * preceding user turn. No-op for every other model, preserving working prefill.
+ */
+export declare function dropUnsupportedModelTurnPrefill(contents: Content[] | undefined, model?: string): Content[] | undefined;
 export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse, extra: {
     usageMetadata?: UsageMetadata | undefined;
     index: number;

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.67",
+  "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/llm/google/index.ts

@@ -19,6 +19,7 @@ import type { GoogleClientOptions, GoogleThinkingConfig } from '@/types';
 import {
   convertResponseContentToChatGenerationChunk,
   convertBaseMessagesToContent,
+  dropUnsupportedModelTurnPrefill,
   mapGenerateContentResultToChatResult,
 } from './utils/common';
 
@@ -254,6 +255,7 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
       this.client.systemInstruction = systemInstruction;
       actualPrompt = prompt.slice(1);
     }
+    actualPrompt = dropUnsupportedModelTurnPrefill(actualPrompt, this.model);
     const parameters = this.invocationParams(options);
     const request = {
       ...parameters,
@@ -308,6 +310,7 @@ export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
       this.client.systemInstruction = systemInstruction;
       actualPrompt = prompt.slice(1);
     }
+    actualPrompt = dropUnsupportedModelTurnPrefill(actualPrompt, this.model);
     const parameters = this.invocationParams(options);
     const request = {
       ...parameters,

package/src/llm/google/utils/common.test.ts

@@ -1,12 +1,16 @@
 import { expect, test, describe } from '@jest/globals';
 import { AIMessageChunk } from '@langchain/core/messages';
-import type { EnhancedGenerateContentResponse } from '@google/generative-ai';
+import type { Content, EnhancedGenerateContentResponse } from '@google/generative-ai';
 import {
   STREAMED_TOOL_CALL_SEAL_METADATA_KEY,
   STREAMED_TOOL_CALL_ADAPTER_METADATA_KEY,
   GOOGLE_STREAMED_TOOL_CALL_ADAPTER,
 } from '@/tools/streamedToolCallSeals';
-import { convertResponseContentToChatGenerationChunk } from './common';
+import {
+  convertResponseContentToChatGenerationChunk,
+  dropUnsupportedModelTurnPrefill,
+  rejectsModelTurnPrefill,
+} from './common';
 
 function buildResponse(
   parts: Array<Record<string, unknown>>
@@ -62,3 +66,54 @@ describe('convertResponseContentToChatGenerationChunk seal metadata', () => {
     expect(metadata[STREAMED_TOOL_CALL_SEAL_METADATA_KEY]).toBeUndefined();
   });
 });
+
+describe('rejectsModelTurnPrefill', () => {
+  test('is true for models that reject a trailing model turn', () => {
+    expect(rejectsModelTurnPrefill('gemini-3.6-flash')).toBe(true);
+    expect(rejectsModelTurnPrefill('gemini-3.5-flash-lite')).toBe(true);
+    expect(rejectsModelTurnPrefill('models/gemini-3.6-flash')).toBe(true);
+    expect(rejectsModelTurnPrefill('google/gemini-3.5-flash-lite-latest')).toBe(true);
+  });
+
+  test('is false for models that still accept prefill and for empty input', () => {
+    expect(rejectsModelTurnPrefill('gemini-3.5-flash')).toBe(false);
+    expect(rejectsModelTurnPrefill('gemini-2.5-flash')).toBe(false);
+    expect(rejectsModelTurnPrefill('gemini-3-pro-preview')).toBe(false);
+    expect(rejectsModelTurnPrefill(undefined)).toBe(false);
+    expect(rejectsModelTurnPrefill('')).toBe(false);
+  });
+});
+
+describe('dropUnsupportedModelTurnPrefill', () => {
+  const userTurn: Content = { role: 'user', parts: [{ text: 'Hi' }] };
+  const modelTurn: Content = { role: 'model', parts: [{ text: 'Hello, I am' }] };
+
+  test('drops a trailing model turn for no-prefill models', () => {
+    const contents: Content[] = [userTurn, modelTurn];
+    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    expect(result).toEqual([userTurn]);
+  });
+
+  test('drops multiple consecutive trailing model turns but keeps one turn', () => {
+    const contents: Content[] = [userTurn, modelTurn, modelTurn];
+    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash-lite');
+    expect(result).toEqual([userTurn]);
+  });
+
+  test('leaves a trailing model turn for models that accept prefill', () => {
+    const contents: Content[] = [userTurn, modelTurn];
+    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.5-flash');
+    expect(result).toBe(contents);
+  });
+
+  test('is a no-op when the request already ends with a user turn', () => {
+    const contents: Content[] = [modelTurn, userTurn];
+    const result = dropUnsupportedModelTurnPrefill(contents, 'gemini-3.6-flash');
+    expect(result).toBe(contents);
+  });
+
+  test('is a no-op for empty or undefined contents', () => {
+    expect(dropUnsupportedModelTurnPrefill([], 'gemini-3.6-flash')).toEqual([]);
+    expect(dropUnsupportedModelTurnPrefill(undefined, 'gemini-3.6-flash')).toBeUndefined();
+  });
+});

package/src/llm/google/utils/common.ts

@@ -631,6 +631,50 @@ export function convertBaseMessagesToContent(
   ).content;
 }
 
+/**
+ * Gemini models that reject a request whose `contents` end with a `model`-role
+ * turn (a "prefill"). Google enforces this on newer generations (Gemini 3.6
+ * Flash, Gemini 3.5 Flash-Lite) while older/sibling models still accept a
+ * trailing model turn, so the rule is model-scoped rather than version-wide.
+ * Extend this list as Google applies the restriction to further models.
+ * @see https://ai.google.dev/gemini-api/docs/latest-model#api-changes-and-parameter-updates
+ */
+const NO_PREFILL_GEMINI_MODELS = [
+  'gemini-3.6-flash',
+  'gemini-3.5-flash-lite',
+] as const;
+
+export function rejectsModelTurnPrefill(model?: string): boolean {
+  if (model == null || model === '') {
+    return false;
+  }
+  const modelId = model.toLowerCase().split('/').pop() ?? '';
+  return NO_PREFILL_GEMINI_MODELS.some(
+    (id) => modelId === id || modelId.startsWith(`${id}-`)
+  );
+}
+
+/**
+ * Drops trailing `model`-role turns for models that reject prefill (see
+ * {@link rejectsModelTurnPrefill}). Such a turn is only produced by prefill
+ * flows (e.g. editing an assistant reply and resubmitting); these models return
+ * HTTP 400 for it, so we drop it and let the model generate fresh from the
+ * preceding user turn. No-op for every other model, preserving working prefill.
+ */
+export function dropUnsupportedModelTurnPrefill(
+  contents: Content[] | undefined,
+  model?: string
+): Content[] | undefined {
+  if (contents == null || contents.length === 0 || !rejectsModelTurnPrefill(model)) {
+    return contents;
+  }
+  let end = contents.length;
+  while (end > 1 && contents[end - 1]?.role === 'model') {
+    end -= 1;
+  }
+  return end === contents.length ? contents : contents.slice(0, end);
+}
+
 export function convertResponseContentToChatGenerationChunk(
   response: EnhancedGenerateContentResponse,
   extra: {