@librechat/agents 3.6.2 → 3.6.4

package/src/llm/openai/index.ts

@@ -43,6 +43,7 @@ import type { SeenScalarMetadata } from './streamMetadata';
 import type { HeaderValue, HeadersLike } from './types';
 import type { PromptCacheTtl } from '@/messages/cache';
 import {
+  OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY,
   OPENAI_RESPONSES_REPLAY_POSITIONS_KEY,
   projectOpenAIResponsesToolMessageContent,
   projectToolStreamContentForProvider,
@@ -606,6 +607,85 @@ function isResponsesReplayOutputItem(item: unknown): boolean {
   );
 }
 
+type ResponsesReasoningSlot = {
+  encrypted_content?: string;
+  id?: string;
+  status?: string;
+};
+
+function getResponsesReasoningSlot(
+  reasoning: unknown
+): ResponsesReasoningSlot | undefined {
+  return typeof reasoning === 'object' && reasoning != null
+    ? (reasoning as ResponsesReasoningSlot)
+    : undefined;
+}
+
+function isSealedReasoningSlot(
+  slot: ResponsesReasoningSlot | undefined
+): slot is ResponsesReasoningSlot & { encrypted_content: string } {
+  return (
+    typeof slot?.encrypted_content === 'string' &&
+    slot.encrypted_content.length > 0
+  );
+}
+
+function resolveActiveReasoningItemId(
+  incoming: ResponsesReasoningSlot | undefined,
+  carried: unknown
+): string | undefined {
+  if (typeof incoming?.id === 'string' && incoming.id.length > 0) {
+    return incoming.id;
+  }
+  return typeof carried === 'string' ? carried : undefined;
+}
+
+/**
+ * A single `additional_kwargs.reasoning` slot has to stand in for a turn that
+ * can emit many reasoning items, and the chunk merge folds it field by field:
+ * `encrypted_content` and `status` are strings, so they concatenate, while
+ * `id` takes whichever item arrived last. An interrupted turn replays from
+ * that slot, handing the provider one item id welded to every item's
+ * ciphertext — rejected as "Encrypted content could not be decrypted or
+ * parsed". Keep the slot describing whichever item most recently sealed, so
+ * the id, its ciphertext, and its status always come from the same item.
+ *
+ * `activeItemId` tracks the item currently streaming, which is the one a
+ * terminal `encrypted_content` belongs to: the slot's own id has already been
+ * pinned back to the last sealed item by an earlier merge.
+ */
+function resealReasoningItemBoundary(
+  combined: AIMessageChunk,
+  accumulated: ResponsesReasoningSlot | undefined,
+  incoming: ResponsesReasoningSlot | undefined,
+  activeItemId: string | undefined
+): void {
+  const merged = getResponsesReasoningSlot(
+    combined.additional_kwargs.reasoning
+  );
+  if (merged == null || incoming == null) {
+    return;
+  }
+  if (isSealedReasoningSlot(incoming)) {
+    combined.additional_kwargs.reasoning = {
+      ...merged,
+      id: activeItemId ?? merged.id,
+      encrypted_content: incoming.encrypted_content,
+      status: incoming.status,
+    };
+    return;
+  }
+  if (!isSealedReasoningSlot(accumulated)) {
+    return;
+  }
+  combined.additional_kwargs.reasoning = {
+    ...merged,
+    id: accumulated.id,
+    encrypted_content: accumulated.encrypted_content,
+    status: accumulated.status,
+  };
+}
+
 /**
  * LangChain's Responses converter places the authoritative terminal output in
  * response_metadata.output. Its chunk merge has no way to delete provisional
@@ -619,10 +699,26 @@ class ResponsesReplayAIMessageChunk extends AIMessageChunk {
   }
 
   override concat(chunk: AIMessageChunk): this {
+    const accumulated = getResponsesReasoningSlot(
+      this.additional_kwargs.reasoning
+    );
+    const incoming = getResponsesReasoningSlot(
+      chunk.additional_kwargs.reasoning
+    );
+    const activeItemId = resolveActiveReasoningItemId(
+      incoming,
+      this.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY]
+    );
     const combined = super.concat(chunk);
+    resealReasoningItemBoundary(combined, accumulated, incoming, activeItemId);
+    if (activeItemId != null) {
+      combined.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY] =
+        activeItemId;
+    }
     if (!Array.isArray(chunk.response_metadata.output)) {
       return combined;
     }
+    delete combined.additional_kwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY];
     delete combined.additional_kwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY];
     const toolOutputs = combined.additional_kwargs.tool_outputs;
     if (!Array.isArray(toolOutputs)) {

package/src/messages/core.ts

@@ -671,6 +671,10 @@ type ResponsesReplayProjection = 'fallback' | 'native';
 export const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY =
   '__openai_responses_replay_positions__';
 
+/** Reasoning item currently streaming, so a terminal ciphertext seals against its own id. */
+export const OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY =
+  '__openai_responses_active_reasoning_id__';
+
 export type ResponsesReplayPosition = {
   contentIndex?: number;
   itemId: string;
@@ -1813,6 +1817,7 @@ function projectPreemptedOpenAIResponsesMessage(
   }
   delete additionalKwargs.tool_outputs;
   delete additionalKwargs[OPENAI_RESPONSES_REPLAY_POSITIONS_KEY];
+  delete additionalKwargs[OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY];
   delete additionalKwargs.__openai_function_call_ids__;
   delete additionalKwargs.__openai_custom_tool_call_ids__;
 

package/src/run.ts

@@ -296,6 +296,7 @@ export class Run<_T extends t.BaseGraphState> {
   private subagentUsageSink?: t.SubagentUsageSink;
   private preemption?: t.StreamPreemption;
   private streamLimits?: t.StreamLimits;
+  private subagentTasks?: t.SubagentTaskConfig;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
   graphRunnable?: t.CompiledStateWorkflow;
@@ -363,6 +364,7 @@ export class Run<_T extends t.BaseGraphState> {
     this.interruptingToolNames = config.interruptingToolNames;
     this.toolExecution = config.toolExecution;
     this.subagentUsageSink = config.subagentUsageSink;
+    this.subagentTasks = config.subagentTasks;
     this.preemption = config.preemption;
     this.streamLimits = config.streamLimits;
 
@@ -455,6 +457,7 @@ export class Run<_T extends t.BaseGraphState> {
         indexTokenCountMap: this.indexTokenCountMap,
         calibrationRatio: this.calibrationRatio,
         subagentUsageSink: this.subagentUsageSink,
+        subagentTasks: this.subagentTasks,
         preemption: this.preemption,
         streamLimits: this.streamLimits,
       },
@@ -493,6 +496,7 @@ export class Run<_T extends t.BaseGraphState> {
         indexTokenCountMap: this.indexTokenCountMap,
         calibrationRatio: this.calibrationRatio,
         subagentUsageSink: this.subagentUsageSink,
+        subagentTasks: this.subagentTasks,
         preemption: this.preemption,
         streamLimits: this.streamLimits,
       },
@@ -826,12 +830,23 @@ export class Run<_T extends t.BaseGraphState> {
              * The producer stamped `completed_at` before dispatch. Carrying it
              * through keeps the recorded duration the tool's, not the host
              * handler's — this runs after an arbitrarily slow handler resolves.
+             *
+             * Isolated because this is a `finally`: a throw here would
+             * REPLACE an in-flight error from the handler above, so the
+             * host's original failure would be reported as whatever went
+             * wrong during closure instead. Closing is best-effort at this
+             * point either way — the end-of-run sweep still stamps any step
+             * this misses.
              */
-            await this.Graph.recordStepCompletion(completion.stepId, {
-              toolCallId: completion.toolCallId,
-              metadata,
-              at: completion.completedAt,
-            });
+            try {
+              await this.Graph.recordStepCompletion(completion.stepId, {
+                toolCallId: completion.toolCallId,
+                metadata,
+                at: completion.completedAt,
+              });
+            } catch (_e) {
+              /** Never mask the handler's error with a closure failure */
+            }
           }
         }
       }

package/src/tools/SubagentTool.ts

@@ -27,6 +27,9 @@ const DESCRIPTION_PROP_DESCRIPTION =
 const SUBAGENT_TYPE_PROP_DESCRIPTION =
   'Which subagent type to delegate to. Must be one of the available types.';
 
+const RUN_IN_BACKGROUND_PROP_DESCRIPTION =
+  'Set true to start the subagent as a detached process-local task and return a background_task_id immediately. Poll the host background-task tool to collect its result. The task can outlive this turn but does not survive a process restart.';
+
 export const SubagentToolSchema = {
   type: 'object',
   properties: {
@@ -54,7 +57,10 @@ export const SubagentToolDefinition: LCTool = {
  * Used by `Graph.createAgentNode()` when constructing the runtime tool instance.
  * Extends `SubagentToolSchema` by populating `subagent_type.enum` dynamically.
  */
-export function buildSubagentToolParams(configs: SubagentConfig[]): {
+export function buildSubagentToolParams(
+  configs: SubagentConfig[],
+  options: { background?: boolean } = {}
+): {
   name: string;
   schema: JsonSchemaType;
   description: string;
@@ -79,10 +85,22 @@ export function buildSubagentToolParams(configs: SubagentConfig[]): {
           enum: types,
           description: `${SUBAGENT_TYPE_PROP_DESCRIPTION} Available: ${types.join(', ')}.`,
         },
+        ...(options.background === true
+          ? {
+            run_in_background: {
+              type: 'boolean',
+              description: RUN_IN_BACKGROUND_PROP_DESCRIPTION,
+            },
+          }
+          : {}),
       },
       required: ['description', 'subagent_type'],
     },
-    description: `${SubagentToolDescription}\n\nAvailable types:\n${typeDescriptions}`,
+    description: `${SubagentToolDescription}${
+      options.background === true
+        ? '\n\nBACKGROUND EXECUTION:\n- Set run_in_background to true when you do not need the result immediately. The call returns a background_task_id; use the host background-task tools to poll, steer, queue, interrupt, or cancel it.'
+        : ''
+    }\n\nAvailable types:\n${typeDescriptions}`,
   };
 }