@librechat/agents 3.4.3 → 3.4.4

package/src/types/activityLabel.ts

@@ -1,4 +1,5 @@
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { AssistantTextPhase } from '@/types/assistantPhase';
 import type { ClientOptions } from '@/types/llm';
 import type { Providers } from '@/common';
 
@@ -38,6 +39,11 @@ export type RunActivityLabelOptions = {
   thinkingExcerpts?: string[];
   /** Assistant's last text before the block (~200 chars), as intent context. */
   lastAssistantText?: string;
+  /**
+   * Provider-authored semantic phase for `lastAssistantText`. Hosts can use
+   * this to pass commentary as intent while excluding final-answer text.
+   */
+  lastAssistantPhase?: AssistantTextPhase;
   /**
    * Headers already committed for earlier batches in this run (run order,
    * most recent last). Continuity context: the prompt shows them so the new
@@ -61,3 +67,62 @@ export type RunActivityLabelOptions = {
    */
   traceSeed?: string;
 };
+
+/** One logical activity contributing to a run-wide phase summary. */
+export type ActivityPhaseEntry = {
+  /** Already committed child activity label, preferred over raw evidence. */
+  label?: string;
+  /** Raw fallback for a child label that was disabled, pending, or dropped. */
+  entries?: ActivityLabelToolEntry[];
+  /** Standalone or tool-attached reasoning excerpts for this activity. */
+  thinkingExcerpts?: string[];
+  /** Agent lane that produced the activity. */
+  agentId?: string;
+  /** Failed activities remain useful evidence and still count. */
+  status?: 'success' | 'partial' | 'error';
+};
+
+/** Options for `Run.generateActivityPhaseLabel`. */
+export type RunActivityPhaseLabelOptions = {
+  provider: Providers;
+  clientOptions?: ClientOptions;
+  /**
+   * Logical activities in run order. The SDK requires at least two so hosts
+   * cannot accidentally spend a model call summarizing a single activity.
+   */
+  activities: ActivityPhaseEntry[];
+  /** Full count when the host retained only bounded prompt evidence. */
+  totalActivityCount?: number;
+  /**
+   * Bounded assistant commentary emitted inside the phase. Human messages
+   * must not be supplied through this low-scrutiny summarization path.
+   */
+  assistantContext?: string[];
+  /** Semantic phase of the text boundary that closed the activity phase. */
+  closingTextPhase?: AssistantTextPhase;
+  /** Override for the dedicated phase-label system prompt. */
+  prompt?: string;
+  /** Per-evidence 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>;
+  };
+  /** Deterministic seed for this phase label trace. */
+  traceSeed?: string;
+  /** Stable source run identifier recorded on the phase observation. */
+  sourceRunId?: string;
+  /** Source Langfuse trace id for linking this detached summary trace. */
+  sourceTraceId?: string;
+  /** Host response/message identifier recorded on the phase observation. */
+  responseId?: string;
+  /** Zero-based index of the phase within the source run. */
+  phaseIndex?: number;
+  /** Completion state recorded on the phase observation. */
+  status?: 'completed' | 'partial' | 'failed';
+  /**
+   * Contributing agents. Their Langfuse redaction policies are combined into
+   * the strictest union before any phase evidence enters the model or trace.
+   */
+  agentIds?: string[];
+};

package/src/types/assistantPhase.ts

@@ -0,0 +1,6 @@
+/**
+ * Semantic phase attached to assistant text by Open Responses-compatible
+ * providers. Commentary is intermediate agent narration; final_answer marks
+ * the user-facing answer that closes the preceding activity phase.
+ */
+export type AssistantTextPhase = 'commentary' | 'final_answer';

package/src/types/graph.ts

@@ -19,6 +19,7 @@ import type {
 } from '@/types/summarize';
 import type {
   ToolMap,
+  ToolSessionMap,
   ToolEndEvent,
   GenericTool,
   LCTool,
@@ -848,6 +849,13 @@ export interface AgentInputs {
   subagentConfigs?: SubagentConfigEntry[];
   /** Maximum subagent nesting depth. Default 1 means top-level agents can spawn subagents but subagents cannot nest further. */
   maxSubagentDepth?: number;
+  /**
+   * Initial tool-session state owned by this agent when it runs as a
+   * subagent. The executor copies these sessions into the isolated child
+   * graph before its first invocation. Top-level runs continue to use
+   * `RunConfig.initialSessions`.
+   */
+  initialSessions?: ToolSessionMap;
   /**
    * Host-supplied tool instances that must execute IN-PROCESS inside the graph's
    * ToolNode even when the run is event-driven (`toolDefinitions` non-empty). Each

package/src/types/index.ts

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

package/src/types/stream.ts

@@ -9,6 +9,7 @@ import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { LLMResult, Generation } from '@langchain/core/outputs';
 import type { Command } from '@langchain/langgraph';
 import type { AnthropicContentBlock } from '@/llm/anthropic/types';
+import type { AssistantTextPhase } from '@/types/assistantPhase';
 import type { SummarizeCompleteEvent } from '@/types/summarize';
 import type { ToolEndEvent } from '@/types/tools';
 import { StepTypes, ContentTypes, GraphEvents } from '@/common/enum';
@@ -119,6 +120,10 @@ export type MessageCreationDetails = {
   type: StepTypes.MESSAGE_CREATION;
   message_creation: {
     message_id: string;
+    /** Content lane announced before its first delta. */
+    content_type?: ContentTypes.TEXT | ContentTypes.THINK;
+    /** Provider-authored assistant text phase, when available. */
+    phase?: AssistantTextPhase;
   };
 };
 
@@ -415,6 +420,10 @@ export type MessageContentComplex = (
       type?: never;
     })
 ) & {
+  /** Open Responses-compatible semantic phase for assistant text. */
+  phase?: AssistantTextPhase;
+  /** LangChain standard-content form of provider-specific block fields. */
+  extras?: { phase?: AssistantTextPhase } & Record<string, unknown>;
   tool_call_ids?: string[];
   // Optional agentId for parallel execution attribution
   agentId?: string;

package/src/utils/callbacks.ts

@@ -37,3 +37,24 @@ export function findCallback(
   const handlers = Array.isArray(callbacks) ? callbacks : callbacks.handlers;
   return handlers.find(predicate);
 }
+
+export function filterCallbacks(
+  callbacks: Callbacks | undefined,
+  predicate: (callback: CallbackEntry) => boolean
+): Callbacks {
+  if (callbacks == null) {
+    return [];
+  }
+
+  if (Array.isArray(callbacks)) {
+    return callbacks.filter(predicate);
+  }
+
+  const filtered = callbacks.copy();
+  for (const handler of [...filtered.handlers]) {
+    if (!predicate(handler)) {
+      filtered.removeHandler(handler);
+    }
+  }
+  return filtered;
+}