@librechat/agents 3.1.67-dev.4 → 3.1.68

package/src/run.ts

@@ -22,10 +22,8 @@ import { MultiAgentGraph } from '@/graphs/MultiAgentGraph';
 import { StandardGraph } from '@/graphs/Graph';
 import { initializeModel } from '@/llm/init';
 import { HandlerRegistry } from '@/events';
-import { executeHooks } from '@/hooks';
 import { isOpenAILike } from '@/utils/llm';
 import { isPresent } from '@/utils/misc';
-import type { HookRegistry } from '@/hooks';
 
 export const defaultOmitOptions = new Set([
   'stream',
@@ -44,7 +42,6 @@ export class Run<_T extends t.BaseGraphState> {
   id: string;
   private tokenCounter?: t.TokenCounter;
   private handlerRegistry?: HandlerRegistry;
-  private hookRegistry?: HookRegistry;
   private indexTokenCountMap?: Record<string, number>;
   calibrationRatio: number = 1;
   graphRunnable?: t.CompiledStateWorkflow;
@@ -77,7 +74,6 @@ export class Run<_T extends t.BaseGraphState> {
     }
 
     this.handlerRegistry = handlerRegistry;
-    this.hookRegistry = config.hooks;
 
     if (!config.graphConfig) {
       throw new Error('Graph config not provided');
@@ -99,12 +95,6 @@ export class Run<_T extends t.BaseGraphState> {
       }
     }
 
-    if (config.initialSessions && this.Graph) {
-      for (const [key, value] of config.initialSessions) {
-        this.Graph.sessions.set(key, value);
-      }
-    }
-
     this.returnContent = config.returnContent ?? false;
     this.skipCleanup = config.skipCleanup ?? false;
   }
@@ -153,7 +143,6 @@ export class Run<_T extends t.BaseGraphState> {
     });
     /** Propagate compile options from graph config */
     standardGraph.compileOptions = config.compileOptions;
-    standardGraph.hookRegistry = this.hookRegistry;
     this.Graph = standardGraph;
     return standardGraph.createWorkflow();
   }
@@ -176,7 +165,6 @@ export class Run<_T extends t.BaseGraphState> {
       multiAgentGraph.compileOptions = compileOptions;
     }
 
-    multiAgentGraph.hookRegistry = this.hookRegistry;
     this.Graph = multiAgentGraph;
     return multiAgentGraph.createWorkflow();
   }
@@ -344,47 +332,6 @@ export class Run<_T extends t.BaseGraphState> {
       run_id: this.id,
     });
 
-    const threadId = config.configurable.thread_id as string | undefined;
-
-    if (this.hookRegistry != null) {
-      await executeHooks({
-        registry: this.hookRegistry,
-        input: {
-          hook_event_name: 'RunStart',
-          runId: this.id,
-          threadId,
-          agentId: this.Graph.defaultAgentId,
-          messages: inputs.messages,
-        },
-        sessionId: this.id,
-      });
-
-      const lastHuman = findLastMessageOfType(inputs.messages, 'human');
-      if (lastHuman != null) {
-        const promptResult = await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'UserPromptSubmit',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            prompt: extractPromptText(lastHuman),
-            // attachments: not yet wired — Phase 2 will extract
-            // non-text content blocks (images, files) from messages
-          },
-          sessionId: this.id,
-        });
-        if (
-          promptResult.decision === 'deny' ||
-          promptResult.decision === 'ask'
-        ) {
-          this.hookRegistry.clearSession(this.id);
-          config.callbacks = undefined;
-          return undefined;
-        }
-      }
-    }
-
     const stream = this.graphRunnable.streamEvents(inputs, config, {
       raiseError: true,
       /**
@@ -414,45 +361,7 @@ export class Run<_T extends t.BaseGraphState> {
           await handler.handle(eventName, data, metadata, this.Graph);
         }
       }
-
-      if (this.hookRegistry?.hasHookFor('Stop', this.id) === true) {
-        await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'Stop',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            messages: this.Graph.getRunMessages() ?? inputs.messages,
-            stopHookActive: false, // will be true when stop is triggered by a hook (Phase 2)
-          },
-          sessionId: this.id,
-        }).catch(() => {
-          /* Stop hook errors must not masquerade as stream failures */
-        });
-      }
-    } catch (err) {
-      if (this.hookRegistry?.hasHookFor('StopFailure', this.id) === true) {
-        const runMessages = this.Graph.getRunMessages() ?? [];
-        await executeHooks({
-          registry: this.hookRegistry,
-          input: {
-            hook_event_name: 'StopFailure',
-            runId: this.id,
-            threadId,
-            agentId: this.Graph.defaultAgentId,
-            error: err instanceof Error ? err.message : String(err),
-            lastAssistantMessage: findLastMessageOfType(runMessages, 'ai'),
-          },
-          sessionId: this.id,
-        }).catch(() => {
-          /* swallow hook errors — the original error must propagate */
-        });
-      }
-      throw err;
     } finally {
-      this.hookRegistry?.clearSession(this.id);
-
       /**
        * Break the reference chain that keeps heavy data alive via
        * LangGraph's internal `__pregel_scratchpad.currentTaskInput` →
@@ -648,38 +557,3 @@ export class Run<_T extends t.BaseGraphState> {
     }
   }
 }
-
-function findLastMessageOfType(
-  messages: BaseMessage[],
-  type: string
-): BaseMessage | undefined {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i].getType() === type) {
-      return messages[i];
-    }
-  }
-  return undefined;
-}
-
-function extractPromptText(message: BaseMessage): string {
-  const content = message.content;
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return String(content);
-  }
-  const parts: string[] = [];
-  for (const block of content) {
-    if (
-      typeof block === 'object' &&
-      'type' in block &&
-      block.type === 'text' &&
-      'text' in block &&
-      typeof block.text === 'string'
-    ) {
-      parts.push(block.text);
-    }
-  }
-  return parts.join('\n');
-}

package/src/summarization/__tests__/node.test.ts

@@ -343,6 +343,48 @@ describe('createSummarizeNode', () => {
     ).toBeUndefined();
   });
 
+  it('catches model initialization errors and falls back to metadata stub', async () => {
+    captureEvents();
+
+    /**
+     * Simulate the "Unsupported LLM provider" case — e.g. when a caller
+     * forwards an unrecognized provider name (custom-endpoint label) that
+     * getChatModelClass cannot resolve. Prior to the defense-in-depth fix,
+     * this error was thrown outside the try/catch in executeSummarizationWithFallback
+     * and bubbled up silently. Now it is caught and the metadata stub is used.
+     */
+    jest.spyOn(providers, 'getChatModelClass').mockImplementation(() => {
+      throw new Error('Unsupported LLM provider: Ollama');
+    });
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({ setSummary } as never);
+    const graph = mockGraph();
+    const node = createSummarizeNode({
+      agentContext,
+      graph,
+      generateStepId,
+    });
+
+    await expect(
+      node(
+        {
+          messages: [new HumanMessage('Test message')],
+          summarizationRequest: {
+            remainingContextTokens: 1000,
+            agentId: 'agent_0',
+          },
+        },
+        {} as RunnableConfig
+      )
+    ).resolves.not.toThrow();
+
+    expect(setSummary).toHaveBeenCalledWith(
+      expect.stringContaining('[Metadata summary:'),
+      expect.any(Number)
+    );
+  });
+
   it('falls back to metadata stub when primary LLM call fails', async () => {
     captureEvents();
 

package/src/summarization/__tests__/trigger.test.ts

@@ -1,4 +1,7 @@
-import { shouldTriggerSummarization } from '@/summarization';
+import {
+  shouldTriggerSummarization,
+  _resetUnrecognizedTriggerWarnings,
+} from '@/summarization';
 
 describe('shouldTriggerSummarization', () => {
   it('uses pre-prune pressure for token_ratio triggers when messages were pruned', () => {
@@ -47,4 +50,100 @@ describe('shouldTriggerSummarization', () => {
 
     expect(result).toBe(false);
   });
+
+  describe('unrecognized trigger type', () => {
+    let warnSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      _resetUnrecognizedTriggerWarnings();
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+    });
+
+    afterEach(() => {
+      warnSpy.mockRestore();
+    });
+
+    it('does not fire and warns once per unrecognized type', () => {
+      const baseParams = {
+        maxContextTokens: 2500,
+        prePruneContextTokens: 2400,
+        remainingContextTokens: 100,
+        messagesToRefineCount: 4,
+      };
+
+      // Cast via `unknown` because the type union guards against this at compile
+      // time; we are intentionally exercising the runtime fallback.
+      const result1 = shouldTriggerSummarization({
+        ...baseParams,
+        trigger: { type: 'token_count', value: 8000 } as unknown as {
+          type: 'token_ratio';
+          value: number;
+        },
+      });
+
+      expect(result1).toBe(false);
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy.mock.calls[0][0]).toContain('token_count');
+      expect(warnSpy.mock.calls[0][0]).toContain('token_ratio');
+      expect(warnSpy.mock.calls[0][0]).toContain('remaining_tokens');
+      expect(warnSpy.mock.calls[0][0]).toContain('messages_to_refine');
+
+      // Same unrecognized type a second time: no duplicate warning.
+      shouldTriggerSummarization({
+        ...baseParams,
+        trigger: { type: 'token_count', value: 8000 } as unknown as {
+          type: 'token_ratio';
+          value: number;
+        },
+      });
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+
+      // Different unrecognized type: warns again, once.
+      shouldTriggerSummarization({
+        ...baseParams,
+        trigger: { type: 'nonsense', value: 1 } as unknown as {
+          type: 'token_ratio';
+          value: number;
+        },
+      });
+      expect(warnSpy).toHaveBeenCalledTimes(2);
+      expect(warnSpy.mock.calls[1][0]).toContain('nonsense');
+    });
+
+    it('does not grow memory unboundedly under a flood of unique types', () => {
+      const baseParams = {
+        maxContextTokens: 2500,
+        prePruneContextTokens: 2400,
+        remainingContextTokens: 100,
+        messagesToRefineCount: 4,
+      };
+
+      for (let i = 0; i < 500; i++) {
+        shouldTriggerSummarization({
+          ...baseParams,
+          trigger: { type: `bogus-${i}`, value: 1 } as unknown as {
+            type: 'token_ratio';
+            value: number;
+          },
+        });
+      }
+
+      // Still logged each new type (up to the cap) — we never silently dropped
+      // warnings; we just evicted oldest entries from the dedup set.
+      expect(warnSpy).toHaveBeenCalledTimes(500);
+
+      // Re-warns for a recently-seen type that should still be in the cache
+      // (last one just inserted). No duplicate warning means the dedup set
+      // still functions; the size cap did not break the dedup contract.
+      const beforeRecent = warnSpy.mock.calls.length;
+      shouldTriggerSummarization({
+        ...baseParams,
+        trigger: { type: 'bogus-499', value: 1 } as unknown as {
+          type: 'token_ratio';
+          value: number;
+        },
+      });
+      expect(warnSpy).toHaveBeenCalledTimes(beforeRecent);
+    });
+  });
 });

package/src/summarization/index.ts

@@ -1,5 +1,51 @@
 import type { SummarizationTrigger } from '@/types';
 
+const VALID_TRIGGER_TYPES = [
+  'token_ratio',
+  'remaining_tokens',
+  'messages_to_refine',
+] as const;
+
+/**
+ * Upper bound on the dedup set for unrecognized trigger types. Bounds memory in
+ * case a caller threads dynamic/user-provided strings through `trigger.type`.
+ * Well above the handful of legit misconfigurations a process would ever see.
+ */
+const MAX_WARNED_TRIGGER_TYPES = 32;
+
+const warnedUnrecognizedTriggerTypes = new Set<string>();
+
+/**
+ * Warn (once per process, per unrecognized type) when the configured trigger
+ * type is something the runtime does not evaluate. Without this, a misconfigured
+ * `trigger.type` silently disables summarization with no visible signal.
+ *
+ * The dedup set is size-capped; on overflow we evict the oldest entry (Set
+ * preserves insertion order) so we keep bounded memory and still warn on
+ * recently-seen types.
+ */
+function warnUnrecognizedTriggerType(type: string): void {
+  if (warnedUnrecognizedTriggerTypes.has(type)) {
+    return;
+  }
+  if (warnedUnrecognizedTriggerTypes.size >= MAX_WARNED_TRIGGER_TYPES) {
+    const oldest = warnedUnrecognizedTriggerTypes.values().next().value;
+    if (oldest !== undefined) {
+      warnedUnrecognizedTriggerTypes.delete(oldest);
+    }
+  }
+  warnedUnrecognizedTriggerTypes.add(type);
+  console.warn(
+    `[shouldTriggerSummarization] Unrecognized trigger.type: "${type}". ` +
+      `Summarization will not fire. Valid values: ${VALID_TRIGGER_TYPES.join(', ')}.`
+  );
+}
+
+/** For tests only. Resets the dedup set so warnings can be observed again. */
+export function _resetUnrecognizedTriggerWarnings(): void {
+  warnedUnrecognizedTriggerTypes.clear();
+}
+
 /**
  * Determines whether summarization should be triggered based on the configured trigger
  * and current context state.
@@ -98,5 +144,6 @@ export function shouldTriggerSummarization(params: {
   }
 
   // Unrecognized trigger type: cannot evaluate, do not fire.
+  warnUnrecognizedTriggerType(trigger.type);
   return false;
 }

package/src/summarization/node.ts

@@ -7,7 +7,6 @@ import {
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { UsageMetadata, BaseMessage } from '@langchain/core/messages';
 import type { AgentContext } from '@/agents/AgentContext';
-import type { HookRegistry } from '@/hooks';
 import type { OnChunk } from '@/llm/invoke';
 import type * as t from '@/types';
 import { ContentTypes, GraphEvents, StepTypes, Providers } from '@/common';
@@ -18,7 +17,6 @@ import { getMaxOutputTokensKey } from '@/llm/request';
 import { addCacheControl } from '@/messages/cache';
 import { initializeModel } from '@/llm/init';
 import { getChunkContent } from '@/stream';
-import { executeHooks } from '@/hooks';
 
 const SUMMARIZATION_PARAM_KEYS = new Set(['maxSummaryTokens']);
 
@@ -366,6 +364,122 @@ type LogFn = (
   data?: Record<string, unknown>
 ) => void;
 
+/**
+ * Extracts an HTTP status code from a thrown LLM-provider error. Returns
+ * `undefined` for non-object values (including `null` or `undefined`, both
+ * valid `throw` targets in JS) so callers never dereference a nullish
+ * value.
+ */
+function extractHttpStatus(err: unknown): number | undefined {
+  if (err == null || typeof err !== 'object') {
+    return undefined;
+  }
+  const errRecord = err as Record<string, unknown>;
+  const direct = errRecord.status;
+  if (typeof direct === 'number') {
+    return direct;
+  }
+  const statusCode = errRecord.statusCode;
+  if (typeof statusCode === 'number') {
+    return statusCode;
+  }
+  const response = errRecord.response;
+  if (response != null && typeof response === 'object') {
+    const nested = (response as Record<string, unknown>).status;
+    if (typeof nested === 'number') {
+      return nested;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Formats a provider-level error for logging. Returns both a human-readable
+ * suffix (safe to include in the message string so it survives any host-side
+ * formatter) and a structured metadata bag for rich log backends.
+ */
+function describeProviderError(
+  err: unknown,
+  provider: string,
+  modelName?: string
+): { suffix: string; data: Record<string, unknown> } {
+  const providerLabel = `${provider}/${modelName ?? '(no-model)'}`;
+  const errMsg = err instanceof Error ? err.message : String(err);
+
+  const data: Record<string, unknown> = {
+    provider,
+    model: modelName,
+  };
+  if (err instanceof Error) {
+    data.errorName = err.name;
+    data.errorStack = err.stack;
+  }
+
+  const status = extractHttpStatus(err);
+  const statusSuffix = status != null ? ` (HTTP ${status})` : '';
+  if (status != null) {
+    data.status = status;
+  }
+
+  return {
+    suffix: `[${providerLabel}]${statusSuffix}: ${errMsg}`,
+    data,
+  };
+}
+
+/**
+ * Formats an exhausted-fallback error. `tryFallbackProviders` throws the
+ * last fallback provider's error, which may be from any of the configured
+ * fallbacks — not the primary — so we label the log with the list of
+ * fallback providers attempted rather than mis-attributing to the primary.
+ *
+ * Entries in `fallbacks` are normally strongly typed, but we defend against
+ * malformed runtime config (null/undefined entries, missing `provider`
+ * field) so a recoverable summarization failure is never promoted to an
+ * uncaught exception from inside the logging path.
+ */
+function describeFallbackError(
+  err: unknown,
+  fallbacks: unknown
+): { suffix: string; data: Record<string, unknown> } {
+  const errMsg = err instanceof Error ? err.message : String(err);
+  const list: ReadonlyArray<unknown> = Array.isArray(fallbacks)
+    ? fallbacks
+    : [];
+  const providerNames = list
+    .map((f) => {
+      if (f == null || typeof f !== 'object') {
+        return undefined;
+      }
+      const raw = (f as { provider?: unknown }).provider;
+      return raw != null ? String(raw) : undefined;
+    })
+    .filter((p): p is string => typeof p === 'string');
+  const label =
+    providerNames.length > 0
+      ? `fallbacks=[${providerNames.join(',')}]`
+      : 'no-fallbacks';
+
+  const data: Record<string, unknown> = {
+    fallbackProviders: providerNames,
+    fallbackCount: list.length,
+  };
+  if (err instanceof Error) {
+    data.errorName = err.name;
+    data.errorStack = err.stack;
+  }
+  const status = extractHttpStatus(err);
+  const statusSuffix = status != null ? ` (HTTP ${status})` : '';
+  if (status != null) {
+    data.status = status;
+  }
+
+  return {
+    suffix: `[${label}]${statusSuffix}: ${errMsg}`,
+    data,
+  };
+}
+
 /**
  * Runs the summarization LLM call with primary + fallback providers,
  * falling back to a metadata stub when all calls fail.
@@ -389,18 +503,23 @@ async function executeSummarizationWithFallback(params: {
     log,
   } = params;
 
-  const summarizationModel = initializeModel({
-    provider: clientConfig.provider as Providers,
-    clientOptions: clientConfig.clientOptions as t.ClientOptions,
-    tools: agentContext.getToolsForBinding(),
-  }) as t.ChatModel;
-
   const priorSummaryText = agentContext.getSummaryText()?.trim() ?? '';
 
   let summaryText = '';
   let summaryUsage: Partial<UsageMetadata> | undefined;
 
   try {
+    /**
+     * Initialize inside the try so that a misconfigured provider
+     * (e.g. an unrecognized summarization.provider) surfaces through the
+     * `log('error', ...)` path below rather than bubbling up silently.
+     */
+    const summarizationModel = initializeModel({
+      provider: clientConfig.provider as Providers,
+      clientOptions: clientConfig.clientOptions as t.ClientOptions,
+      tools: agentContext.getToolsForBinding(),
+    }) as t.ChatModel;
+
     const result = await summarizeWithCacheHit({
       model: summarizationModel,
       messages,
@@ -417,19 +536,20 @@ async function executeSummarizationWithFallback(params: {
     summaryText = result.text;
     summaryUsage = result.usage;
   } catch (primaryError) {
-    log('error', 'Summarization LLM call failed', {
-      error:
-        primaryError instanceof Error
-          ? primaryError.message
-          : String(primaryError),
-      provider: clientConfig.provider,
-      model: clientConfig.modelName,
+    const primaryDescribed = describeProviderError(
+      primaryError,
+      clientConfig.provider,
+      clientConfig.modelName
+    );
+    log('error', `Summarization LLM call failed ${primaryDescribed.suffix}`, {
+      ...primaryDescribed.data,
       messagesToRefineCount: messages.length,
     });
 
-    const fallbacks =
-      (clientConfig.clientOptions as unknown as t.LLMConfig | undefined)
-        ?.fallbacks ?? [];
+    const rawFallbacks = (
+      clientConfig.clientOptions as unknown as t.LLMConfig | undefined
+    )?.fallbacks;
+    const fallbacks = Array.isArray(rawFallbacks) ? rawFallbacks : [];
     if (fallbacks.length > 0) {
       try {
         const onChunk = createSummarizationChunkHandler({
@@ -462,18 +582,21 @@ async function executeSummarizationWithFallback(params: {
           );
         }
       } catch (fbErr) {
-        log('warn', 'Fallback providers also failed', {
-          error: fbErr instanceof Error ? fbErr.message : String(fbErr),
+        const fbDescribed = describeFallbackError(fbErr, fallbacks);
+        log('warn', `Fallback providers also failed ${fbDescribed.suffix}`, {
+          ...fbDescribed.data,
         });
       }
     }
     if (!summaryText) {
-      log('warn', 'Summarization failed, falling back to metadata stub', {
-        error:
-          primaryError instanceof Error
-            ? primaryError.message
-            : String(primaryError),
-      });
+      log(
+        'warn',
+        `Summarization failed, falling back to metadata stub ${primaryDescribed.suffix}`,
+        {
+          ...primaryDescribed.data,
+          messagesToRefineCount: messages.length,
+        }
+      );
       summaryText = generateMetadataStub(messages);
     }
   }
@@ -532,35 +655,6 @@ async function dispatchCompletionEvents(params: {
     );
   }
 
-  const sessionId = graph.runId ?? '';
-  if (graph.hookRegistry?.hasHookFor('PostCompact', sessionId) === true) {
-    const threadId = (
-      runnableConfig?.configurable as Record<string, unknown> | undefined
-    )?.thread_id as string | undefined;
-    const firstBlock = summaryBlock.content?.[0];
-    const summaryText =
-      firstBlock != null &&
-      typeof firstBlock === 'object' &&
-      'text' in firstBlock &&
-      typeof firstBlock.text === 'string'
-        ? firstBlock.text
-        : '';
-    await executeHooks({
-      registry: graph.hookRegistry,
-      input: {
-        hook_event_name: 'PostCompact',
-        runId: sessionId,
-        threadId,
-        agentId,
-        summary: summaryText,
-        messagesAfterCount: 0,
-      },
-      sessionId,
-    }).catch(() => {
-      /* PostCompact is observational — swallow errors */
-    });
-  }
-
   agentContext.rebuildTokenMapAfterSummarization({});
 }
 
@@ -576,7 +670,6 @@ interface CreateSummarizeNodeParams {
     config?: RunnableConfig;
     runId?: string;
     isMultiAgent: boolean;
-    hookRegistry?: HookRegistry;
     dispatchRunStep: (
       runStep: t.RunStep,
       config?: RunnableConfig
@@ -682,27 +775,6 @@ export function createSummarizeNode({
       );
     }
 
-    const sessionId = graph.runId ?? '';
-    if (graph.hookRegistry?.hasHookFor('PreCompact', sessionId) === true) {
-      const threadId = (
-        runnableConfig?.configurable as Record<string, unknown> | undefined
-      )?.thread_id as string | undefined;
-      await executeHooks({
-        registry: graph.hookRegistry,
-        input: {
-          hook_event_name: 'PreCompact',
-          runId: sessionId,
-          threadId,
-          agentId: request.agentId,
-          messagesBeforeCount: messagesToRefine.length,
-          trigger: agentContext.summarizationConfig?.trigger?.type ?? 'default',
-        },
-        sessionId,
-      }).catch(() => {
-        /* PreCompact is observational — swallow errors */
-      });
-    }
-
     const isSelfSummarizeModel =
       clientConfig.provider === (agentContext.provider as string);
     const hasPromptCache =