@librechat/agents 3.7.7 → 3.7.8

package/src/run.ts

@@ -35,7 +35,6 @@ import {
   ACTIVITY_PHASE_LABEL_RUN_NAME,
   DEFAULT_RECURSION_LIMIT,
 } from '@/common';
-import { isBuiltRuntime } from '@/lazyRequire';
 import {
   requireValidSubagentResumeManifest,
   stripSubagentResumeManifest,
@@ -94,14 +93,15 @@ import { applyGraphRuntimeConfig } from '@/graphs/applyGraphRuntimeConfig';
 import { LANGFUSE_OPERATION_METADATA_KEY } from '@/langfuseOperation';
 import { createTokenCounter, encodingForModel } from '@/utils/tokens';
 import { stampSyntheticProviderMessage } from '@/messages/provenance';
+import { isOpenAILike, isLibreChatOpenAIModel } from '@/utils/llm';
 import { initializeLangfuseTracing } from './instrumentation';
 import { seedRunInitialSessions } from '@/utils/toolSessions';
 import { getTraceIdSeed } from '@/langfuseRuntimeContext';
 import { createGraph } from '@/graphs/createGraph';
 import { resolveMaxSeals } from '@/llm/preempt';
+import { isBuiltRuntime } from '@/lazyRequire';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
-import { isOpenAILike, isLibreChatOpenAIModel } from '@/utils/llm';
 import { executeHooks } from '@/hooks';
 
 /** Source-mode runs have no dist siblings for the lazy-loading seam, so every
@@ -130,6 +130,7 @@ export const defaultOmitOptions = new Set([
 const ACTIVITY_LABEL_TRACE_NAME = 'LibreChat Activity Label';
 const ACTIVITY_PHASE_TRACE_NAME = 'LibreChat Activity Phase';
 const REASONING_LABEL_TRACE_NAME = 'LibreChat Reasoning Label';
+const OUTPUT_TRUNCATED_HALT_REASON = 'output_truncated';
 
 const CUSTOM_GRAPH_EVENTS = new Set<string>([
   GraphEvents.ON_AGENT_UPDATE,
@@ -794,6 +795,18 @@ export class Run<_T extends t.BaseGraphState> {
     return this.Graph?.getToolCount() ?? 0;
   }
 
+  /**
+   * True when the run's last turn ended at `END` because the provider hit
+   * its output token ceiling while producing plain text/reasoning — no tool
+   * call, so `assertNotTruncatedToolCall` never sees it and the graph reads
+   * the turn as an ordinary completion. Hosts check this alongside
+   * `getPreemptStats()` / `getHaltReason()` to decide whether to persist the
+   * response as unfinished instead of a silently truncated "complete" one.
+   */
+  getOutputTruncated(): boolean {
+    return this.Graph?.outputTruncatedIncomplete ?? false;
+  }
+
   /**
    * Creates a custom event callback handler that intercepts custom events
    * and processes them through our handler registry instead of EventStreamCallbackHandler
@@ -1362,6 +1375,13 @@ export class Run<_T extends t.BaseGraphState> {
         this._haltedReason == null &&
         this.hookRegistry?.hasHookFor('Stop', this.id) === true
       ) {
+        let stopReason = graph.preemptHaltReason;
+        if (stopReason == null && graph.preemptIncomplete) {
+          stopReason = 'preempt_incomplete';
+        }
+        if (stopReason == null && graph.outputTruncatedIncomplete) {
+          stopReason = OUTPUT_TRUNCATED_HALT_REASON;
+        }
         await executeHooks({
           registry: this.hookRegistry,
           input: {
@@ -1377,9 +1397,7 @@ export class Run<_T extends t.BaseGraphState> {
              * actual cause, not the generic label — and `preempt_incomplete`
              * is reserved for the boundary that simply had nothing to inject.
              */
-            stopReason:
-              graph.preemptHaltReason ??
-              (graph.preemptIncomplete ? 'preempt_incomplete' : undefined),
+            stopReason,
             stopHookActive: false, // will be true when stop is triggered by a hook (Phase 2)
           },
           sessionId: this.id,
@@ -1409,6 +1427,11 @@ export class Run<_T extends t.BaseGraphState> {
         this._haltedReason = graph.preemptHaltReason;
       } else if (this._haltedReason == null && graph.preemptIncomplete) {
         this._haltedReason = 'preempt_incomplete';
+      } else if (
+        this._haltedReason == null &&
+        graph.outputTruncatedIncomplete
+      ) {
+        this._haltedReason = OUTPUT_TRUNCATED_HALT_REASON;
       }
     };
 
@@ -1614,13 +1637,16 @@ export class Run<_T extends t.BaseGraphState> {
   }
 
   /**
-   * Returns the reason a hook halted the run via
-   * `preventContinuation: true`, or `undefined` if no hook halted.
+   * Returns why the run ended without a natural completion, or `undefined`
+   * when it completed normally. Reasons include hook- and prompt-driven
+   * halts, `preempt_incomplete` when a cooperative seal ended the turn
+   * without continuation content, and `output_truncated` when the provider
+   * stopped a plain-text/reasoning response at its output-token ceiling.
    *
    * Hosts inspect this after `processStream` returns to distinguish a
-   * natural completion (`undefined`) from a hook-driven halt (a
-   * truthy string). Independent from `getInterrupt()` — a halted run
-   * has no interrupt; an interrupted run has no halt reason.
+   * natural completion from a terminal partial response. Independent from
+   * `getInterrupt()` — a halted run has no interrupt; an interrupted run has
+   * no halt reason.
    */
   getHaltReason(): string | undefined {
     return this._haltedReason;

package/src/summarization/node.ts

@@ -6,11 +6,19 @@ import {
 } from '@langchain/core/messages';
 import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { RenderedCompactionSemanticIndex } from '@/summarization/semanticIndex';
 import type { StreamLimitState } from '@/llm/streamLimits';
 import type { AgentContext } from '@/agents/AgentContext';
 import type { HookRegistry } from '@/hooks';
 import type { OnChunk } from '@/llm/invoke';
 import type * as t from '@/types';
+import {
+  addTailCacheControl,
+  addBedrockTailCacheControl,
+  resolvePromptCacheTtl,
+  resolveBedrockPromptCacheTtl,
+  type PromptCacheTtl,
+} from '@/messages/cache';
 import {
   cloneToolMessageWithContent,
   compactToolContent,
@@ -22,13 +30,6 @@ import {
   StreamLimitExceededError,
   STREAM_LIMIT_EPOCH_KEY,
 } from '@/llm/streamLimits';
-import {
-  addTailCacheControl,
-  addBedrockTailCacheControl,
-  resolvePromptCacheTtl,
-  resolveBedrockPromptCacheTtl,
-  type PromptCacheTtl,
-} from '@/messages/cache';
 import {
   DEFAULT_RETAIN_RECENT_TURNS,
   resolveIntraTurnRetainTokens,
@@ -41,9 +42,10 @@ import {
   StepTypes,
   Providers,
 } from '@/common';
+import { renderCompactionSemanticIndex } from '@/summarization/semanticIndex';
 import { safeDispatchCustomEvent, emitAgentLog } from '@/utils/events';
-import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
 import { prepareToolsForPromptCache } from '@/llm/promptCacheTools';
+import { attemptInvoke, tryFallbackProviders } from '@/llm/invoke';
 import { calculateMaxToolResultChars } from '@/utils/truncation';
 import { makeIsDeferred } from '@/messages/anthropicToolCache';
 import { createRemoveAllMessage } from '@/messages/reducer';
@@ -625,6 +627,7 @@ async function executeSummarizationWithFallback(params: {
   summarizeConfig?: RunnableConfig;
   stepId: string;
   usePromptCache: boolean;
+  semanticIndex: RenderedCompactionSemanticIndex;
   log: LogFn;
   /** Carries the run's stream limits so the event cap covers summary streams. */
   graph?: StreamLimitState & {
@@ -651,6 +654,7 @@ async function executeSummarizationWithFallback(params: {
     summarizeConfig,
     stepId,
     usePromptCache,
+    semanticIndex,
     log,
     graph,
   } = params;
@@ -693,6 +697,7 @@ async function executeSummarizationWithFallback(params: {
       promptText: clientConfig.promptText,
       updatePromptText: clientConfig.updatePromptText,
       priorSummaryText,
+      semanticIndexAppendix: semanticIndex.appendix,
       config: summarizeConfig,
       stepId,
       provider: clientConfig.provider,
@@ -704,20 +709,20 @@ async function executeSummarizationWithFallback(params: {
         clientConfig.provider === Providers.OPENROUTER ||
         clientConfig.provider === Providers.BEDROCK
           ? (
-                clientConfig.clientOptions as {
-                  promptCacheTtl?: PromptCacheTtl;
-                }
+              clientConfig.clientOptions as {
+                promptCacheTtl?: PromptCacheTtl;
+              }
           ).promptCacheTtl
           : undefined,
       bedrockModelId:
         clientConfig.provider === Providers.BEDROCK
           ? resolveBedrockCompactionCacheModel(
-            clientConfig.clientOptions as
-              | {
-                applicationInferenceProfile?: string;
-                model?: string;
-              }
-              | undefined
+              clientConfig.clientOptions as
+                | {
+                    applicationInferenceProfile?: string;
+                    model?: string;
+                  }
+                | undefined
           )
           : undefined,
       log,
@@ -785,7 +790,8 @@ async function executeSummarizationWithFallback(params: {
               buildSummarizationInstruction(
                 clientConfig.promptText,
                 clientConfig.updatePromptText,
-                priorSummaryText
+                priorSummaryText,
+                semanticIndex.appendix
               )
             ),
           ],
@@ -1092,6 +1098,29 @@ export function createSummarizeNode({
       return { summarizationRequest: undefined };
     }
 
+    /**
+     * A summarizer that has already returned nothing several times in a row
+     * keeps returning nothing, and every empty result leaves the message set
+     * exactly as it was — so the next prune cycle re-triggers on identical
+     * state. Stopping here bounds that loop instead of letting the run spend
+     * its recursion budget dispatching empty summary steps.
+     */
+    if (agentContext.summarizationExhausted) {
+      emitAgentLog(
+        config,
+        'warn',
+        'summarize',
+        'Summarization skipped — consecutive attempts produced no usable summary',
+        {
+          failures: agentContext.summarizationFailures,
+          reason: request.reason ?? 'trigger',
+        },
+        { runId: graph.runId, agentId: request.agentId }
+      );
+      agentContext.markSummarizationTriggered(state.messages.length);
+      return { summarizationRequest: undefined };
+    }
+
     const maxCtx = agentContext.maxContextTokens ?? 0;
     if (maxCtx > 0 && agentContext.instructionTokens >= maxCtx) {
       emitAgentLog(
@@ -1188,6 +1217,10 @@ export function createSummarizeNode({
       agentContext,
       agentContext.summarizationConfig
     );
+    const semanticIndex = renderCompactionSemanticIndex(
+      agentContext.compactionSemanticIndex,
+      messagesToRefine
+    );
 
     const stepKey = `summarize-${request.agentId}`;
     const [stepId, stepIndex] = generateStepId(stepKey);
@@ -1229,6 +1262,8 @@ export function createSummarizeNode({
           model: clientConfig.modelName,
           messagesToRefineCount: messagesToRefine.length,
           summaryVersion: agentContext.summaryVersion + 1,
+          semanticIndexEntryCount: semanticIndex.entryCount,
+          semanticIndexCharCount: semanticIndex.charCount,
         } satisfies t.SummarizeStartEvent,
         runnableConfig
       );
@@ -1276,6 +1311,9 @@ export function createSummarizeNode({
       isSelfSummarize: isSelfSummarizeModel,
       hasPromptCache,
       provider: clientConfig.provider,
+      semanticIndexEntryCount: semanticIndex.entryCount,
+      semanticIndexCharCount: semanticIndex.charCount,
+      semanticIndexOmittedEntryCount: semanticIndex.omittedEntryCount,
     });
 
     const summarizeConfig: RunnableConfig | undefined = config
@@ -1291,6 +1329,10 @@ export function createSummarizeNode({
           agentId: request.agentId,
           summarization_provider: clientConfig.provider,
           summarization_model: clientConfig.modelName,
+          compaction_semantic_index_entries: semanticIndex.entryCount,
+          compaction_semantic_index_chars: semanticIndex.charCount,
+          compaction_semantic_index_omitted_entries:
+            semanticIndex.omittedEntryCount,
           /**
              * Per-call model attribution for usage consumers (the subagent
              * usage-capture handler): the summarizer's model can differ from
@@ -1340,6 +1382,7 @@ export function createSummarizeNode({
       summarizeConfig,
       stepId,
       usePromptCache: isSelfSummarizeModel && hasPromptCache,
+      semanticIndex,
       log,
       graph,
     });
@@ -1365,6 +1408,7 @@ export function createSummarizeNode({
         `Summarization failed during ${preservationReason}; keeping history rather than replacing it with a metadata stub`
       );
       agentContext.markSummarizationTriggered(state.messages.length);
+      agentContext.recordSummarizationFailure();
       /**
        * The run step was already dispatched, so it has to be resolved here or
        * consumers tracking step lifecycle keep an unfinished placeholder for
@@ -1393,7 +1437,22 @@ export function createSummarizeNode({
     }
 
     if (!rawText) {
-      agentContext.markSummarizationTriggered(0);
+      /**
+       * An empty summary compacts nothing, so the state the pruner sees next
+       * is byte-identical to the one that just triggered. Resetting the guard
+       * to `0` here made `shouldSkipSummarization` answer `false` forever,
+       * and the agent node re-triggered on that unchanged state until the
+       * graph hit its recursion cap — a loop of empty summary steps, each one
+       * a billed model call. Recording the current count keeps the guard
+       * honest; the failure tally bounds the retries once new messages do
+       * arrive and legitimately lift it.
+       */
+      agentContext.markSummarizationTriggered(state.messages.length);
+      agentContext.recordSummarizationFailure();
+      log('warn', 'Summarization produced empty output', {
+        failures: agentContext.summarizationFailures,
+        messagesToRefineCount: messagesToRefine.length,
+      });
       if (runnableConfig) {
         await safeDispatchCustomEvent(
           GraphEvents.ON_SUMMARIZE_COMPLETE,
@@ -1544,12 +1603,15 @@ function extractResponseText(response: { content: string | object }): string {
 function buildSummarizationInstruction(
   promptText: string,
   updatePromptText: string | undefined,
-  priorSummaryText: string
+  priorSummaryText: string,
+  semanticIndexAppendix = ''
 ): string {
   const effectivePrompt = priorSummaryText
     ? (updatePromptText ?? promptText)
     : promptText;
-  const parts = [effectivePrompt];
+  const parts = semanticIndexAppendix
+    ? [semanticIndexAppendix, '\n\n', effectivePrompt]
+    : [effectivePrompt];
   if (priorSummaryText) {
     parts.push(
       `\n\n<previous-summary>\n${priorSummaryText}\n</previous-summary>`
@@ -1666,10 +1728,7 @@ export function applySummarizationHistoryCache(params: {
   if (params.provider === Providers.BEDROCK) {
     return addBedrockTailCacheControl(
       [...params.messages],
-      resolveBedrockPromptCacheTtl(
-        params.promptCacheTtl,
-        params.bedrockModelId
-      )
+      resolveBedrockPromptCacheTtl(params.promptCacheTtl, params.bedrockModelId)
     );
   }
   if (
@@ -1685,9 +1744,7 @@ export function applySummarizationHistoryCache(params: {
 }
 
 export function resolveBedrockCompactionCacheModel(
-  options:
-    | { applicationInferenceProfile?: string; model?: string }
-    | undefined
+  options: { applicationInferenceProfile?: string; model?: string } | undefined
 ): string | undefined {
   return options?.model;
 }
@@ -1705,6 +1762,7 @@ async function summarizeWithCacheHit({
   promptText,
   updatePromptText,
   priorSummaryText,
+  semanticIndexAppendix,
   config,
   stepId,
   provider,
@@ -1720,6 +1778,7 @@ async function summarizeWithCacheHit({
   promptText: string;
   updatePromptText?: string;
   priorSummaryText: string;
+  semanticIndexAppendix?: string;
   config?: RunnableConfig;
   stepId?: string;
   provider: t.ProviderName;
@@ -1733,7 +1792,8 @@ async function summarizeWithCacheHit({
   const instruction = buildSummarizationInstruction(
     promptText,
     updatePromptText,
-    priorSummaryText
+    priorSummaryText,
+    semanticIndexAppendix
   );
 
   const cachedHistory = applySummarizationHistoryCache({
@@ -1743,10 +1803,7 @@ async function summarizeWithCacheHit({
     promptCacheTtl,
     bedrockModelId,
   });
-  const invokeMessages = [
-    ...cachedHistory,
-    new HumanMessage(instruction),
-  ];
+  const invokeMessages = [...cachedHistory, new HumanMessage(instruction)];
 
   const result = await attemptInvoke(
     {