@librechat/agents 3.3.7 → 3.3.9

package/src/tools/__tests__/hitl.test.ts

@@ -35,6 +35,7 @@ import type * as t from '@/types';
 import { Providers as providers, GraphEvents } from '@/common';
 import * as events from '@/utils/events';
 import { HookRegistry, createToolPolicyHook } from '@/hooks';
+import { askUserQuestion } from '@/hitl';
 import { ToolNode } from '../ToolNode';
 
 async function flushAsyncWork(): Promise<void> {
@@ -4354,6 +4355,63 @@ describe('AskUserQuestion — interrupt + resume', () => {
     expect(String(toolMessage!.content)).toBe('staging');
   });
 
+  it('askUserQuestion surfaces the calling tool_call_id on the interrupt payload when the body supplies it', async () => {
+    /**
+     * LangChain stamps the full ToolCall onto the config a `tool(fn, …)`
+     * body receives, so the body can attribute its interrupt to the exact
+     * call. Hosts use `payload.tool_call_id` to stamp the question/answer
+     * onto the right content part when a model emits several ask calls in
+     * one turn — positional guessing mislabels the cards.
+     */
+    const askTool = tool(
+      async (input: { question: string }, config) => {
+        const resolution = askUserQuestion(input, {
+          toolCallId: config.toolCall?.id,
+        });
+        return resolution.answer;
+      },
+      {
+        name: 'ask_user_question',
+        description: 'Ask the user a clarifying question.',
+        schema: z.object({ question: z.string() }),
+      }
+    ) as unknown as StructuredToolInterface;
+
+    const node = new ToolNode({ tools: [askTool] });
+    const graph = buildHITLGraph(node, [
+      {
+        id: 'call_ask_id_1',
+        name: 'ask_user_question',
+        args: { question: 'Which region?' },
+      },
+    ]);
+    const config = { configurable: { thread_id: 'thread-ask-call-id' } };
+
+    const interrupted = await graph.invoke({ messages: [] }, config);
+    if (!isInterrupted<t.HumanInterruptPayload>(interrupted)) {
+      throw new Error('expected interrupt');
+    }
+    const payload = interrupted.__interrupt__[0].value!;
+    if (payload.type !== 'ask_user_question') {
+      throw new Error('expected ask_user_question payload');
+    }
+    expect(payload.tool_call_id).toBe('call_ask_id_1');
+    expect(payload.question.question).toBe('Which region?');
+
+    const resumed = (await resumeGraph(
+      graph,
+      interrupted,
+      { answer: 'us-east' } satisfies t.AskUserQuestionResolution,
+      config
+    )) as MessagesUpdate;
+    const toolMessage = resumed.messages.find(
+      (m): m is ToolMessage =>
+        m._getType() === 'tool' &&
+        (m as ToolMessage).tool_call_id === 'call_ask_id_1'
+    );
+    expect(String(toolMessage!.content)).toBe('us-east');
+  });
+
   it('isAskUserQuestionInterrupt narrows the payload union correctly', async () => {
     const { isAskUserQuestionInterrupt, isToolApprovalInterrupt } =
       await import('@/types/hitl');

package/src/types/activityLabel.ts

@@ -38,6 +38,14 @@ export type RunActivityLabelOptions = {
   thinkingExcerpts?: string[];
   /** Assistant's last text before the block (~200 chars), as intent context. */
   lastAssistantText?: string;
+  /**
+   * Headers already committed for earlier batches in this run (run order,
+   * most recent last). Continuity context: the prompt shows them so the new
+   * header extends the run's story instead of restating a line already on
+   * screen. Hosts should pass only COMMITTED labels — a pending slot's text
+   * is empty and a dropped fill never surfaced to the user.
+   */
+  previousLabels?: string[];
   /** Override for the default label system prompt. */
   prompt?: string;
   /** Per-entry serialization cap for the prompt. Default 600. */

package/src/types/hitl.ts

@@ -158,6 +158,14 @@ export interface AskUserQuestionRequest {
 export interface AskUserQuestionInterruptPayload {
   type: 'ask_user_question';
   question: AskUserQuestionRequest;
+  /**
+   * The `tool_call_id` of the ask-tool call that raised this interrupt,
+   * when the tool body supplied it (see `askUserQuestion`'s `options`).
+   * Lets hosts attribute the question — and later the answer — to the
+   * exact tool-call content part instead of guessing by position, which
+   * mislabels cards when a model emits several ask calls in one turn.
+   */
+  tool_call_id?: string;
 }
 
 /**

package/src/types/stream.ts

@@ -301,10 +301,30 @@ export type SummaryBoundary = {
   contentIndex: number;
 };
 
+/**
+ * Semantic extent of a summary: the first source message compaction retained
+ * verbatim, meaning everything before it is covered. Distinct from `boundary`,
+ * which records where the block was emitted — a retained recency tail sits
+ * *before* the block's own position, so position alone cannot say what the
+ * summary replaced.
+ *
+ * Anchored to the retained side rather than the covered side so that a source
+ * message expanding into several messages (a steer splits an assistant entry
+ * into pre-steer, steer, and post-steer entries sharing one ID) stays whole:
+ * such a message is the retained anchor and survives intact.
+ */
+export type SummaryCoverage = {
+  retainedFromMessageId: string;
+};
+
 export type SummaryContentBlock = {
   type: ContentTypes.SUMMARY;
   content?: MessageContentComplex[];
+  /** Injection budget: provider output-token space when usage was reported, plus
+   *  the wrapper added at injection time. Not comparable with per-message counts
+   *  such as `indexTokenCountMap`, which are in the consumer's own tokenizer. */
   tokenCount?: number;
+  coverage?: SummaryCoverage;
   boundary?: SummaryBoundary;
   summaryVersion?: number;
   model?: string;

package/src/types/tools.ts

@@ -75,6 +75,28 @@ export type EagerEventToolCallChunkState = {
   argsText: string;
   index?: number;
   lastArgsFragment?: string;
+  /**
+   * Cumulative length of every observed args fragment — the length of the
+   * plain in-order concatenation that LangChain's `AIMessageChunk.concat`
+   * performs to build the final tool call. Every reconciliation branch in
+   * `mergeToolCallArgsText` (and the repeat-fragment dedupe) produces text no
+   * longer than plain concatenation, with equality exactly when every merge
+   * was a pure append — so `argsText.length === rawArgsLength` proves
+   * `argsText` IS the canonical accumulation the final request will carry.
+   * Tracking only the length keeps cumulative/restating streams from
+   * retaining every prefix (quadratic growth) while still letting seal-time
+   * prestart verify the snapshot.
+   */
+  rawArgsLength?: number;
+  /**
+   * The non-empty args fragment carried by a chunk whose explicit adapter
+   * seal covered this call. Some adapters restate the finished call's full
+   * args on the seal chunk (OpenAI Responses `function_call_arguments.done`);
+   * only such a restatement may override the canonical-accumulation check at
+   * seal time. Pure-signal seals (Bedrock `contentBlockStop`, `args: ''`)
+   * never set this.
+   */
+  sealedArgsFragment?: string;
 };
 
 export type ToolNodeOptions = {
@@ -156,6 +178,14 @@ export type ToolNodeOptions = {
   eagerEventToolExecutions?: Map<string, EagerEventToolExecution>;
   /** Shared per-run per-tool turn counter used by eager and normal event dispatch. */
   eagerEventToolUsageCount?: Map<string, number>;
+  /**
+   * Shared per-run circuit breaker for eager prestart. When a prestarted
+   * execution's args turn out to differ from the final request ("changed
+   * after eager execution started"), the ToolNode adds the tool name here
+   * and the stream handler stops prestarting that tool for the remainder of
+   * the run, so the model's retry executes normally instead of looping.
+   */
+  eagerEventToolSuppressions?: Set<string>;
   /**
    * Hook registry for PreToolUse/PostToolUse/PostToolUseFailure/
    * PermissionDenied lifecycle hooks. Fires for **every** tool the
@@ -241,7 +271,11 @@ export type ToolEndEvent = {
    * present (see `ProcessedToolCall.outcome`) so `ON_RUN_STEP_COMPLETED`
    * consumers can read it without an unsafe cast.
    */
-  tool_call: ToolCall & { output?: string; progress?: number; outcome?: string };
+  tool_call: ToolCall & {
+    output?: string;
+    progress?: number;
+    outcome?: string;
+  };
   /** The content index of the tool call */
   index: number;
   type?: 'tool_call';