@librechat/agents 3.8.0 → 3.8.2

package/dist/types/hitl/approvalReview.d.ts

@@ -0,0 +1,32 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolApprovalInterruptPayload, ToolApprovalRequest, ToolApprovalReviewConfig } from '@/types/hitl';
+/**
+ * Private resume-only config entry populated from the checkpointed interrupt.
+ * Hosts must never need to construct or inspect this value.
+ */
+export declare const TOOL_APPROVAL_REVIEW_CONFIG_KEY = "__librechat_tool_approval_review";
+export interface ToolApprovalReviewEvidence {
+    interruptId: string;
+    payload: ToolApprovalInterruptPayload;
+    owner?: string;
+}
+export interface ReviewedToolApproval {
+    request: ToolApprovalRequest;
+    reviewConfig: ToolApprovalReviewConfig;
+}
+/** Detach approval payloads from host- or transport-owned object graphs. */
+export declare function cloneToolApprovalInterruptPayload<T>(payload: T): T;
+/** Build trusted review evidence from the interrupt restored by `Run`. */
+export declare function createToolApprovalReviewEvidence(interruptId: string | undefined, payload: unknown, owner?: string): ToolApprovalReviewEvidence | undefined;
+/** Read only well-shaped evidence from a ToolNode's runnable config. */
+export declare function getToolApprovalReviewEvidence(config: RunnableConfig, owner?: string): ToolApprovalReviewEvidence | undefined;
+export declare function getReviewedToolApproval(payload: ToolApprovalInterruptPayload | undefined, toolCallId: string | undefined): ReviewedToolApproval | undefined;
+/**
+ * Bind a resume decision to the exact proposal the reviewer saw. Description
+ * text is deliberately excluded: it explains policy but cannot change the
+ * side effect. Tool identity, normalized arguments and available decisions
+ * are execution-authoritative.
+ */
+export declare function toolApprovalProposalMatches(current: ReviewedToolApproval, reviewed: ReviewedToolApproval): boolean;
+/** Preserve batch order as part of the decision-to-request binding. */
+export declare function toolApprovalPayloadMatches(current: ToolApprovalInterruptPayload, reviewed: ToolApprovalInterruptPayload): boolean;

package/dist/types/hooks/types.d.ts

@@ -213,9 +213,11 @@ export interface PreCompactHookInput extends BaseHookInput {
     /**
      * What triggered compaction. Matches `SummarizationTrigger.type` from the
      * agent's summarization config. `'default'` means no trigger was
-     * configured and compaction fired because messages were pruned.
+     * configured and compaction fired because messages were pruned;
+     * `'manual'` means the host asked for the summary outright and no trigger
+     * was evaluated.
      */
-    trigger: 'token_ratio' | 'remaining_tokens' | 'messages_to_refine' | 'default' | (string & {});
+    trigger: 'token_ratio' | 'remaining_tokens' | 'messages_to_refine' | 'default' | 'manual' | (string & {});
 }
 export interface PostCompactHookInput extends BaseHookInput {
     hook_event_name: 'PostCompact';

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ export * from './run';
 export * from './stream';
 export * from './events';
 export * from './messages';
+export { LANGFUSE_OBSERVATION_METADATA_ARTIFACT_KEY } from './langfuseToolOutputTracing';
 export * from './graphs';
 export * from './agents/projection';
 export * from './summarization';

package/dist/types/langfuse.d.ts

@@ -1,4 +1,5 @@
 import { CallbackHandler } from '@langfuse/langchain';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type { SpanContext } from '@opentelemetry/api';
 import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeContext';
 import type * as t from '@/types';
@@ -72,4 +73,8 @@ export declare function hasExplicitLangfuseConfig(contexts: Iterable<{
     langfuse?: t.LangfuseConfig;
 }>): boolean;
 export declare function isLangfuseCallbackHandler(value: unknown): boolean;
+/** Host results have passed host output filters. Record only reserved metadata,
+ * not arguments, rows, errors, or attachments. These completion observations
+ * do not measure tool latency; execution timing belongs in the metadata. */
+export declare function traceHostToolResults(request: t.ToolExecuteBatchRequest, results: t.ToolExecuteResult[], config?: RunnableConfig): Promise<void>;
 export declare function disposeLangfuseHandler(value: unknown): Promise<void>;

package/dist/types/langfuseToolOutputTracing.d.ts

@@ -4,11 +4,13 @@ import type { ResolvedLangfuseToolOutputTracingConfig } from '@/langfuseRuntimeC
 import type * as t from '@/types';
 import { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT, resolveLangfuseConfig } from '@/langfuseConfig';
 export { LANGFUSE_TOOL_OUTPUT_REDACTION_TEXT, resolveLangfuseConfig };
+export declare const LANGFUSE_OBSERVATION_METADATA_ARTIFACT_KEY = "librechatLangfuseObservationMetadata";
 /** Whether a tool's outputs are excluded from tracing (global disable or
  *  `redactedToolNames` match). Exported for the activity-label prompt
  *  builder, whose prompt becomes Langfuse generation input. */
 export declare function shouldRedactTool(toolName: string | undefined, config: ResolvedLangfuseToolOutputTracingConfig): boolean;
 export declare function classifyLangfuseToolNodeSpan(span: ReadableSpan): void;
+export declare function getToolObservationMetadata(artifact: unknown): Record<string, string | number | boolean>;
 export declare function redactLangfuseSpanToolOutputs(span: ReadableSpan, config: ResolvedLangfuseToolOutputTracingConfig): void;
 export declare function prepareLangfuseSpanForExport(span: ReadableSpan, config?: ResolvedLangfuseToolOutputTracingConfig): void;
 export declare function createLangfuseSpanProcessor(params?: LangfuseSpanProcessorParams, runLangfuse?: t.LangfuseConfig, agentLangfuse?: t.LangfuseConfig): SpanProcessor;

package/dist/types/llm/contextPressureMeter.d.ts

@@ -8,6 +8,7 @@ interface ContextPressureUsage {
     calibrationRatio?: number;
 }
 interface ContextPressureMeterParams {
+    provider?: t.ProviderName;
     tokenCounter?: t.TokenCounter;
     tokenCountCache?: ExactTokenCountCache;
     sourceMessages: BaseMessage[];
@@ -32,5 +33,5 @@ export interface ExactTokenCountCache {
 /** Reuses exact counts only while every token-relevant stable field matches. */
 export declare function createExactTokenCountCache(tokenCounter: t.TokenCounter): ExactTokenCountCache;
 /** Measures repeated provider projections while tokenizing each message object once. */
-export declare function createContextPressureMeter({ tokenCounter, tokenCountCache, sourceMessages, retainedMessages, indexTokenCountMap, contextUsage, instructionTokens, calibrationRatio, }: ContextPressureMeterParams): ContextPressureMeter;
+export declare function createContextPressureMeter({ provider, tokenCounter, tokenCountCache, sourceMessages, retainedMessages, indexTokenCountMap, contextUsage, instructionTokens, calibrationRatio, }: ContextPressureMeterParams): ContextPressureMeter;
 export {};

package/dist/types/llm/prepareProviderRequest.d.ts

@@ -2,6 +2,7 @@ import type { BaseMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
 import type * as t from '@/types';
+import type { ToolHistoryPreparation } from '@/messages/toolHistoryProjection';
 declare const preparedProviderRequestBrand: unique symbol;
 export type ProviderMessageProjectionMode = 'chat-messages' | 'openai-responses';
 export interface ProviderPayloadMeasurement {
@@ -10,6 +11,9 @@ export interface ProviderPayloadMeasurement {
     readonly availableMessageTokens?: number;
     readonly contextBudget?: number;
     readonly effectiveInstructionTokens?: number;
+    readonly toolMessageTokens?: number;
+    readonly toolMessageTokenCounts?: Record<string, number>;
+    readonly toolMessageUsageError?: Error;
 }
 export interface PreparedProviderRequest {
     readonly model: t.ChatModel;
@@ -32,6 +36,7 @@ export interface PrepareProviderRequestParams {
     config?: RunnableConfig;
     maxToolResultChars?: number;
     measure?: (messages: BaseMessage[]) => ProviderPayloadMeasurement;
+    toolHistory?: ToolHistoryPreparation;
 }
 export declare function usesNativeOpenAIResponses(model: t.ChatModel, provider: t.ProviderName, callOptions?: unknown): boolean;
 interface ProjectMessagesForProviderParams {
@@ -40,6 +45,7 @@ interface ProjectMessagesForProviderParams {
     provider: t.ProviderName;
     maxToolResultChars?: number;
     callOptions?: unknown;
+    toolHistory?: ToolHistoryPreparation;
 }
 /** Produces the provider-facing representation before adapter serialization. */
 export declare function projectMessagesForProvider(params: ProjectMessagesForProviderParams): BaseMessage[];
@@ -49,6 +55,6 @@ export declare function resolveServingModelId(model: unknown): string | undefine
  * Finalizes one provider request and measures the exact message array that
  * will be passed to LangChain. Source messages remain untouched.
  */
-export declare function prepareProviderRequest({ model, messages, provider, context, config, maxToolResultChars, measure, }: PrepareProviderRequestParams): PreparedProviderRequest;
+export declare function prepareProviderRequest({ model, messages, provider, context, config, maxToolResultChars, measure, toolHistory, }: PrepareProviderRequestParams): PreparedProviderRequest;
 export declare function assertPreparedProviderRequestFor(request: PreparedProviderRequest, model: t.ChatModel, provider: t.ProviderName, config?: RunnableConfig): void;
 export {};

package/dist/types/messages/budget.d.ts

@@ -1,11 +1,16 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
-/**
- * Reconciles a context-usage breakdown's instruction/available/message fields
- * from the pruner's budget metrics. `messageTokens` and `availableForMessages`
- * are DERIVED from `contextBudget` / `effectiveInstructionTokens` /
- * `remainingContextTokens` rather than summed from the index map — that map is
- * keyed by pre-prune indices, so summing it over the kept context would missum.
- * Shared by the live snapshot path (`Graph.createCallModel`) and the pre-send
- * projection (`AgentContext.projectContextUsage`) so both yield identical numbers.
- */
-export declare function syncBudgetDerivedFields(usage: t.ContextUsageEvent): void;
+/** Counts retained tool exchanges without serializing arguments or result content. */
+export interface ToolMessageUsageAccumulator {
+    add(message: BaseMessage, getRawTokens: () => number): void;
+    finish(calibrationRatio?: number): Pick<t.TokenBudgetBreakdown, 'toolMessageTokens' | 'toolMessageTokenCounts'>;
+}
+/** Accumulates tool-share attribution while its caller walks a provider payload. */
+export declare function createToolMessageUsageAccumulator(provider?: t.ProviderName): ToolMessageUsageAccumulator;
+/** Reconciles derived budget fields and, when supplied, the retained tool share.
+ * The index map is keyed before pruning, so it cannot index the retained context.
+ * Callers may pass the existing exact token cache's counter, never a stale index lookup.
+ * Runs on the live pre-invoke path, so an unusable count drops the tool share
+ * (warned once) instead of failing the model call it only measures. */
+export declare function syncBudgetDerivedFields(usage: t.ContextUsageEvent, context?: readonly BaseMessage[], tokenCounter?: t.TokenCounter, config?: RunnableConfig, provider?: t.ProviderName, toolMessageUsageError?: Error): void;

package/dist/types/messages/core.d.ts

@@ -1,5 +1,6 @@
 import { AIMessage, BaseMessage, ToolMessage, HumanMessage, AIMessageChunk } from '@langchain/core/messages';
 import type * as t from '@/types';
+import type { ToolHistoryPreparation } from './toolHistoryProjection';
 export declare function getConverseOverrideMessage({ userMessage, lastMessageX, lastMessageY, }: {
     userMessage: string[];
     lastMessageX: AIMessageChunk | null;
@@ -8,8 +9,7 @@ export declare function getConverseOverrideMessage({ userMessage, lastMessageX,
 /**
  * True when a content block is a provider reasoning block: Anthropic
  * `thinking` / `redacted_thinking`, Google `reasoning`, Bedrock
- * `reasoning_content`, and the streamed delta variants that prefix each of
- * those names.
+ * `reasoning_content`, LibreChat `think`, and their known streamed variants.
  *
  * Shared rather than re-derived because two very different readers must agree
  * on the same answer: the stream classifier, which decides what the host has
@@ -17,30 +17,22 @@ export declare function getConverseOverrideMessage({ userMessage, lastMessageX,
  * holds anything worth keeping. A turn the host renders as thinking-only must
  * never look like a visible answer to the gate.
  *
- * Prefix matching, not equality, because providers stream these as suffixed
- * delta types. `reasoning_content` needs no clause of its own — it already
- * carries the `reasoning` prefix.
+ * Exact matching prevents unrelated custom block types that happen to share a
+ * prefix from being silently classified as hidden reasoning.
  */
-export declare function isReasoningContentBlock(block: {
-    type?: string;
-}): boolean;
+export { isReasoningContentBlock } from './reasoningTypes';
 export declare function modifyDeltaProperties(provider: t.ProviderName, obj?: AIMessageChunk): AIMessageChunk | undefined;
 export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
 export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];
 type ResponsesReplayProjection = 'fallback' | 'native';
-export declare const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY = "__openai_responses_replay_positions__";
+export { OPENAI_RESPONSES_REPLAY_POSITIONS_KEY } from './toolHistoryProjection';
 /** Reasoning item currently streaming, so a terminal ciphertext seals against its own id. */
 export declare const OPENAI_RESPONSES_ACTIVE_REASONING_ID_KEY = "__openai_responses_active_reasoning_id__";
-export type ResponsesReplayPosition = {
-    contentIndex?: number;
-    itemId: string;
-    kind: 'message' | 'output' | 'reasoning' | 'text';
-    outputIndex: number;
-};
+export type { ResponsesReplayPosition } from './toolHistoryProjection';
 /** Drops incomplete streamed text blocks before provider-facing tool shaping. */
 export declare function dropIncompleteToolStreamContent(content: AIMessage['content']): AIMessage['content'];
 /** Applies sealed-Responses safety and drops incomplete streamed text input. */
-export declare function projectToolStreamContentForProvider(messages: BaseMessage[], responsesReplayProjection?: ResponsesReplayProjection, maxChars?: number): BaseMessage[];
+export declare function projectToolStreamContentForProvider(messages: BaseMessage[], responsesReplayProjection?: ResponsesReplayProjection, maxChars?: number, preparation?: ToolHistoryPreparation): BaseMessage[];
 /** Projects OpenAI-compatible tool content without changing parsed call parents. */
 export declare function projectOpenAIToolMessageContent(messages: BaseMessage[], maxChars?: number): BaseMessage[];
 /** Projects an actual OpenAI-compatible Chat attempt and removes cache metadata. */
@@ -76,4 +68,3 @@ export declare function formatArtifactPayload(messages: BaseMessage[]): void;
 export declare function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number;
 /** Whether message content carries non-whitespace text in any text block. */
 export declare function hasNonEmptyTextContent(content: BaseMessage['content']): boolean;
-export {};

package/dist/types/messages/format.d.ts

@@ -1,6 +1,7 @@
 import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ToolHistoryPreparation } from './toolHistoryProjection';
 import type { MessageContentComplex, TPayload, ProviderName, CompactionSemanticIndex, CompactionSemanticIndexSnapshot } from '@/types';
 import { Providers } from '@/common';
 interface MediaMessageParams {
@@ -211,7 +212,7 @@ export declare function compactSyntheticProviderContextMessage(message: HumanMes
  *   compatibility for callers that don't yet pass the boundary.
  * @returns The messages array with tool sequences converted to buffer strings if necessary
  */
-export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: ProviderName, config?: RunnableConfig, runStartIndex?: number): BaseMessage[];
+export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: ProviderName, config?: RunnableConfig, runStartIndex?: number, preparation?: ToolHistoryPreparation): BaseMessage[];
 /**
  * Folds tool_use / tool_result content into plain text for an agent that binds
  * no tools.
@@ -233,5 +234,5 @@ export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _
  * original array is returned unchanged when it holds no tool content (the common
  * fresh-tool-less-agent case).
  */
-export declare function foldToolBlocksForToollessAgent(messages: BaseMessage[], config?: RunnableConfig): BaseMessage[];
+export declare function foldToolBlocksForToollessAgent(messages: BaseMessage[], config?: RunnableConfig, preserveNativeOpenAIResponses?: boolean, preparation?: ToolHistoryPreparation): BaseMessage[];
 export {};

package/dist/types/messages/index.d.ts

@@ -1,7 +1,7 @@
 export * from './core';
 export * from './ids';
 export * from './prune';
-export * from './budget';
+export { syncBudgetDerivedFields } from './budget';
 export * from './format';
 export * from './cache';
 export * from './anthropicToolCache';

package/dist/types/messages/prune.d.ts

@@ -261,7 +261,7 @@ export declare function projectToolCallInputs(messages: BaseMessage[], maxInputC
  * Derives provider-safe tool history in one pass by dropping incomplete stream
  * content and bounding every provider-consumed tool-call input representation.
  */
-export declare function projectToolMessagesForProvider(messages: BaseMessage[], maxInputChars: number): BaseMessage[];
+export declare function projectToolMessagesForProvider(messages: BaseMessage[], maxInputChars: number, provider?: ProviderName): BaseMessage[];
 export declare function preFlightTruncateToolCallInputs(params: {
     messages: BaseMessage[];
     maxContextTokens: number;

package/dist/types/messages/reasoningTypes.d.ts

@@ -0,0 +1,7 @@
+/** Identifies every persisted or streamed reasoning content-block shape. */
+export declare function isReasoningContentBlock(block: {
+    type?: unknown;
+}): boolean;
+export declare function isAnthropicThinkingContentBlock(block: {
+    type?: unknown;
+}): boolean;

package/dist/types/messages/recency.d.ts

@@ -1,4 +1,5 @@
 import type { BaseMessage } from '@langchain/core/messages';
+import type { ProviderName } from '@/types/llm';
 export declare const DEFAULT_RETAIN_RECENT_TURNS = 2;
 export declare const DEFAULT_INTRA_TURN_RETAIN_RATIO = 0.16;
 /**
@@ -6,6 +7,8 @@ export declare const DEFAULT_INTRA_TURN_RETAIN_RATIO = 0.16;
  * and a tail (to be preserved verbatim).
  */
 export interface RecencyWindowOptions {
+    /** Serving provider used to interpret generic `ChatMessage` roles. */
+    provider?: ProviderName;
     /**
      * Maximum number of recent user-led turns to keep in the tail. A "turn"
      * begins at a user-authored HumanMessage and includes every following

package/dist/types/messages/toolHistoryProjection.d.ts

@@ -0,0 +1,65 @@
+import type { BaseMessage, ContentBlock } from '@langchain/core/messages';
+interface ToolHistoryCallMirror {
+    readonly name?: string;
+    readonly arguments: string;
+}
+export type ToolHistoryCallMirrors = Map<string, ToolHistoryCallMirror | null>;
+/** Only complete argument representations can establish that a call is a mirror. */
+export declare function recordToolHistoryCallMirror(mirrors: ToolHistoryCallMirrors, block: unknown): void;
+export declare function isToolHistoryCallMirror(mirrors: ToolHistoryCallMirrors | undefined, id: unknown, name: unknown, args: unknown): boolean;
+export declare const OPENAI_RESPONSES_REPLAY_POSITIONS_KEY = "__openai_responses_replay_positions__";
+export type ResponsesReplayPosition = {
+    contentIndex?: number;
+    itemId: string;
+    kind: 'message' | 'output' | 'reasoning' | 'text';
+    outputIndex: number;
+};
+export declare function isResponsesReplayPosition(value: unknown): value is ResponsesReplayPosition;
+/** Provider evidence is selected once; a sidecar never replaces message content. */
+export interface ResponsesHistorySource {
+    readonly coverage: 'complete-output' | 'tool-sidecar';
+    readonly items: unknown[];
+    readonly message?: BaseMessage;
+}
+export interface OrderedToolHistoryProjection {
+    readonly source: ResponsesHistorySource;
+    readonly contributions: readonly ResponsesHistoryContribution[];
+    readonly hasToolContent: boolean;
+    readonly truncated: boolean;
+}
+export interface ToolHistoryPreparation {
+    get(message: BaseMessage): OrderedToolHistoryProjection | undefined;
+}
+/** A preparation owns this cache; changed messages must be copy-on-write. */
+export declare function createToolHistoryPreparation(): ToolHistoryPreparation;
+export interface ToolHistoryPosition {
+    readonly outputIndex: number;
+    readonly contentIndex?: number;
+    readonly itemId?: string;
+}
+export type ResponsesHistoryContribution = ToolHistoryPosition & ({
+    readonly kind: 'text';
+    readonly actor: 'model';
+    readonly text: string;
+} | {
+    readonly kind: 'call';
+    readonly actor: 'model';
+    readonly name: string;
+    readonly callId?: string;
+    readonly arguments: unknown;
+} | {
+    readonly kind: 'image';
+    readonly actor: 'tool';
+    readonly image: ContentBlock.Multimodal.Image;
+} | {
+    readonly kind: 'provider-item';
+    readonly actor: 'model' | 'tool';
+    readonly providerType: string;
+    readonly value: unknown;
+});
+export declare function getResponsesHistorySource(message: BaseMessage): ResponsesHistorySource | undefined;
+/** Complete generated images retain their actual format across replay and folding. */
+export declare function getGeneratedImageMimeType(data: string): string;
+/** Streaming positions order sidecar evidence only when text positions map exactly. */
+export declare function projectResponsesHistory(source: ResponsesHistorySource, consumeWork: () => boolean): Generator<ResponsesHistoryContribution>;
+export {};

package/dist/types/messages/toolResultTypes.d.ts

@@ -1,3 +1,5 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { ProviderName } from '@/types/llm';
 export type ProviderToolCallKind = 'tool' | 'server' | 'anthropic-server' | 'mcp' | 'google' | 'bedrock';
 export interface ProviderToolCallPartDescriptor {
     readonly callId: string;
@@ -15,7 +17,7 @@ export interface ProviderToolResultPartDescriptor {
 }
 export interface ProviderToolCallIndexEntry {
     readonly descriptor: ProviderToolCallPartDescriptor;
-    secondarySourceType?: string;
+    secondarySourceTypes?: Set<string>;
 }
 export type ProviderToolCallIndex = Map<string, ProviderToolCallIndexEntry | null>;
 export declare const PROVIDER_TOOL_RESULT_MAX_ARRAY_ENTRIES = 256;
@@ -27,7 +29,35 @@ export declare function getBoundedProviderPairingArrayProperty(value: unknown, k
 export declare function isBoundedProviderPairingString(value: unknown, allowEmpty?: boolean): value is string;
 export declare function hasStructurallyValidAnthropicWebSearchResultContent(part: unknown): boolean;
 export declare function getProviderToolResultPartDescriptor(part: unknown): ProviderToolResultPartDescriptor | undefined;
+export declare function isProviderToolCallContentPart(part: unknown): boolean;
+export declare function isProviderToolContentPart(part: unknown): boolean;
 export declare function getProviderAIMessageToolCallDescriptor(toolCall: unknown): ProviderToolCallPartDescriptor | undefined;
 export declare function getProviderToolCallPartDescriptor(part: unknown): ProviderToolCallPartDescriptor | undefined;
 export declare function appendProviderToolCallDescriptor(index: ProviderToolCallIndex, descriptor: ProviderToolCallPartDescriptor): void;
+/** Google's built-in code execution emits an `executableCode` part with no call
+ *  id; its `codeExecutionResult` pairs by adjacency instead. */
+export declare function isExecutableCodePart(part: unknown): boolean;
 export declare function consumeProviderToolResultPair(descriptor: ProviderToolResultPartDescriptor, calls: ProviderToolCallIndex, previousPart?: unknown): boolean;
+export declare function getLegacyFunctionCallId(name: string): string | undefined;
+export type ProviderMessageRole = 'assistant' | 'user' | 'system' | 'tool' | 'function';
+/**
+ * Normalizes a message to the role a provider converter would send it as. A
+ * `ChatMessage` reports its type as `generic` and carries the wire role on
+ * `role`, so every classifier that keys on `getType()` alone silently skips
+ * generic assistant, tool and function messages the converters accept.
+ */
+export declare function getProviderMessageRole(message: BaseMessage, provider?: ProviderName): ProviderMessageRole | undefined;
+export declare function getRawToolCallDescriptor(toolCall: unknown): ProviderToolCallPartDescriptor | undefined;
+/**
+ * Appends every tool call an assistant message carries: parsed
+ * `AIMessage.tool_calls`, raw `additional_kwargs.tool_calls` (where OpenAI
+ * keeps calls when the parsed array is empty) and a legacy
+ * `additional_kwargs.function_call`. Content-block calls are the caller's to
+ * append, since only the caller knows whether the block is being replayed.
+ * Returns how many descriptors were recognized, so a caller can tell an
+ * invocation from a plain assistant turn without re-deriving the shapes.
+ */
+export declare function appendProviderMessageToolCalls(message: BaseMessage, calls: ProviderToolCallIndex, provider?: ProviderName): number;
+/** Describes a whole-message tool result: a `ToolMessage`, a `FunctionMessage`,
+ *  or a generic message carrying the equivalent wire role. */
+export declare function getProviderToolMessageResultDescriptor(message: BaseMessage, provider?: ProviderName): ProviderToolResultPartDescriptor | undefined;

package/dist/types/session/sessionProjection.d.ts

@@ -0,0 +1,10 @@
+import type { DerivedSessionMessages } from './deriveMessages';
+import type { SessionEntry } from './types';
+import type { JsonlSessionStore } from './JsonlSessionStore';
+/** Internal: only AgentSession's unexposed stores may reuse log topology. */
+export declare function initializeSessionProjection(store: JsonlSessionStore, entries: readonly SessionEntry[]): void;
+/** Forks share entry references, so exposing either disables the whole family. */
+export declare function shareSessionProjectionOwnership(source: JsonlSessionStore, target: JsonlSessionStore): void;
+export declare function releaseSessionProjection(store: JsonlSessionStore): void;
+/** Reuses log topology, but materializes fresh mutable messages for every run. */
+export declare function deriveSessionMessages(store: JsonlSessionStore | undefined): DerivedSessionMessages;

package/dist/types/summarization/index.d.ts

@@ -4,7 +4,8 @@ import type { SummarizationTrigger } from '@/types';
  * default prompts stay out of it: LibreChat's manual flow deliberately words
  * its own, so exporting these would publish an API with no consumer.
  */
-export { buildSummarizationInstruction, buildSummaryCarrierText, separateSummarizationParameters, } from './shared';
+export { buildSummarizationInstruction, buildSummaryCarrierText, separateSummarizationParameters, ManualSummarizationSkippedError, } from './shared';
+export type { ManualSummarizationSkipReason } from './shared';
 /** For tests only. Resets the dedup set so warnings can be observed again. */
 export declare function _resetUnrecognizedTriggerWarnings(): void;
 /**

package/dist/types/summarization/node.d.ts

@@ -45,6 +45,7 @@ export declare function createSummarizeNode({ agentContext, graph: adapterGraph,
 }, config?: RunnableConfig) => Promise<{
     summarizationRequest: undefined;
     messages?: BaseMessage[];
+    manualSummary?: string;
 }>;
 /** Creates an `onChunk` callback that dispatches `ON_SUMMARIZE_DELTA` events for streaming. */
 export declare function createSummarizationChunkHandler({ stepId, config, provider, reasoningKey, graph, }: {

package/dist/types/summarization/shared.d.ts

@@ -23,3 +23,15 @@ export declare function separateSummarizationParameters(parameters: Record<strin
     maxSummaryTokens?: number;
 };
 export declare function buildSummarizationInstruction(promptText: string, updatePromptText: string | undefined, priorSummaryText?: string, semanticIndexAppendix?: string): string;
+/** Why a summarize-only run could not attempt its summary. */
+export type ManualSummarizationSkipReason = 'disabled' | 'exhausted' | 'instructions_exceed_budget' | 'nothing_to_summarize';
+/**
+ * A summarize-only run asked for a summary the graph could not attempt.
+ * Thrown rather than ending the run quietly: the summary is the whole result
+ * of such a run, so a host left with neither a summary nor an error would
+ * have nothing to show the user.
+ */
+export declare class ManualSummarizationSkippedError extends Error {
+    readonly reason: ManualSummarizationSkipReason;
+    constructor(reason: ManualSummarizationSkipReason, message: string);
+}

package/dist/types/tools/ToolNode.d.ts

@@ -2,7 +2,7 @@ import { ToolCall } from '@langchain/core/messages/tool';
 import { END, Command, MessagesAnnotation } from '@langchain/langgraph';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { ToolOutputResolveView, ResolvedArgsByCallId } from '@/tools/toolOutputReferences';
+import type { ToolOutputResolveView, ToolOutputReferenceState, ResolvedArgsByCallId } from '@/tools/toolOutputReferences';
 import type { SubagentToolNodeResumeState } from '@/tools/subagent/SubagentReplay';
 import type * as t from '@/types';
 import { ToolOutputReferenceRegistry } from '@/tools/toolOutputReferences';
@@ -53,6 +53,10 @@ type RunToolBatchContext<T = unknown> = {
     additionalContextsSink?: string[];
     /** Stable identity of the assistant tool-call batch across HITL replay. */
     replayBatchKey?: string;
+    /** Positions in the original proposal, before completed calls are filtered. */
+    replayCallPositions?: ReadonlyMap<ToolCall, number>;
+    /** Tool-call identities owned by this ToolNode invocation. */
+    approvalScopeCallIds?: ReadonlySet<string>;
     /**
      * Graph state the ToolNode was invoked with, threaded from `run()`
      * so `tool.invoke` can forward it as langgraph 1.4's `runtime.state`
@@ -116,10 +120,10 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * the Run ends.
      */
     private directPathTurns;
-    /** Terminal results from interrupting siblings that must survive a
-     * LangGraph replay of the containing ToolNode. Includes the sidecar data
-     * the fresh batch needs for hook-context injection and completion events. */
-    private settledInterruptingResults;
+    /** Terminal direct results that must survive a LangGraph replay of the
+     * containing ToolNode. Includes the sidecar data the fresh batch needs for
+     * hook-context injection and completion-event deduplication. */
+    private settledDirectResultsByBatch;
     /** Tool registry for filtering (lazy computation of programmatic maps) */
     private toolRegistry?;
     /** Schema-only definitions used when event mode has no runtime registry. */
@@ -527,7 +531,9 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * invocations cannot race on shared mutable state.
      */
     private executeViaEvent;
-    protected run(input: any, config: RunnableConfig): Promise<T>;
+    protected run(input: any, config: RunnableConfig, referenceReplay?: {
+        state?: ToolOutputReferenceState;
+    }): Promise<T>;
     private isSendInput;
     private isMessagesState;
 }

package/dist/types/tools/subagent/SubagentReplay.d.ts

@@ -67,6 +67,8 @@ export interface SubagentResumeManifest {
     version: 1;
     executions: SubagentResumeExecution[];
 }
+export declare function isToolNodeResumeState(value: unknown): value is SubagentToolNodeResumeState;
+export declare function isToolOutputReferenceState(value: unknown): value is ToolOutputReferenceState;
 export declare function getSubagentResumeManifest(payload: unknown): SubagentResumeManifest | undefined;
 export declare function requireValidSubagentResumeManifest(payload: unknown): SubagentResumeManifest | undefined;
 export declare function attachSubagentResumeManifest(payload: unknown, manifest: SubagentResumeManifest): object;

package/dist/types/tools/toolBatchReplay.d.ts

@@ -0,0 +1,54 @@
+import { Command } from '@langchain/langgraph';
+import type { BaseMessage } from '@langchain/core/messages';
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { SubagentToolNodeResumeState } from '@/tools/subagent/SubagentReplay';
+import type { ToolOutputReferenceState } from '@/tools/toolOutputReferences';
+export declare const TOOL_BATCH_REPLAY_KEY = "__librechat_tool_batch_replay";
+export interface SettledToolBatchResult {
+    proposal: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    output: BaseMessage | Command;
+    additionalContexts: string[];
+    resolvedArgs?: Record<string, unknown>;
+    completionHandled?: boolean;
+    referenceContent?: string;
+    turn?: number;
+}
+export interface ToolBatchReplayRecord {
+    owner: string;
+    batch: string;
+    encoding: string;
+    data: string;
+    turnState?: SubagentToolNodeResumeState;
+    referenceState?: ToolOutputReferenceState;
+}
+interface ToolBatchReplayState {
+    version: 1;
+    approvalOwner?: string;
+    records: ToolBatchReplayRecord[];
+    wrappedPayload?: boolean;
+}
+/** The only host-to-runtime entry point for checkpoint-owned tool replay state. */
+export declare function restoreToolReplayConfig(configurable: Record<string, unknown>, interruptId: string | undefined, payload: unknown): void;
+export declare function getToolBatchReplayOwner(config: RunnableConfig, agentId: string): string;
+export declare function getToolBatchReplayScope(config: RunnableConfig): string | undefined;
+/** Foreign approval evidence may only transit a checkpoint-proven child path. */
+export declare function isChildToolApprovalOwner(config: RunnableConfig, owner: string, trustedParentCallIds: ReadonlySet<string>): boolean;
+/** Rebind only the checkpoint-proven source execution when a child fork is created. */
+export declare function rebindToolBatchReplayScope(configurable: Record<string, unknown>, sourceScope: string, destinationScope: string): void;
+/** A fork may be paused again before it consumes its pending interrupt. */
+export declare function rebindToolBatchReplayPayload(payload: unknown, sourceScope: string, destinationScope: string): unknown;
+export declare function getToolBatchReplayState(payload: unknown): ToolBatchReplayState | undefined;
+export declare function stripToolBatchReplayState(payload: unknown): unknown;
+/** Decode outer execution metadata before shape-sensitive child wrappers. */
+export declare function getPublicToolInterruptPayload(payload: unknown): unknown;
+export declare function attachToolBatchReplayState(payload: unknown, owner: string, batches: ReadonlyMap<string, ReadonlyMap<string, object>>, turnState?: SubagentToolNodeResumeState, referenceState?: ToolOutputReferenceState): Promise<unknown>;
+export declare function restoreToolBatchReplayState(config: RunnableConfig, owner: string): Promise<Array<{
+    batch: string;
+    results: Array<[string, SettledToolBatchResult]>;
+    turnState?: SubagentToolNodeResumeState;
+    referenceState?: ToolOutputReferenceState;
+}>>;
+export {};

package/dist/types/tools/toolOutputReferences.d.ts

@@ -199,6 +199,8 @@ export declare class ToolOutputReferenceRegistry {
     snapshot(runId: string | undefined): ToolOutputResolveView;
     /** Captures the checkpoint-safe state needed to resume one run bucket. */
     snapshotState(runId: string | undefined): ToolOutputReferenceState;
+    /** Restore batch inputs without rolling back graph-owned concurrent outputs. */
+    resumeBatch(runId: string, state: ToolOutputReferenceState): ToolOutputResolveView;
     /** Restores a checkpointed run bucket under the current resume scope. */
     restoreState(runId: string | undefined, state: ToolOutputReferenceState): void;
     private resolveAgainst;

package/dist/types/types/graph.d.ts

@@ -30,6 +30,13 @@ export type SystemCallbacks = {
 export type BaseGraphState = {
     messages: BaseMessage[];
     runStepState?: RunStepResumeState;
+    /**
+     * The summary a summarize-only run produced. Kept in state because such a
+     * run has no assistant reply: trace roots report it as the run's output
+     * instead of the retained tail or the raw state. Empty once any later run
+     * on the same checkpointed thread starts, so it never outlives its run.
+     */
+    manualSummary?: string;
 };
 export type AgentSubgraphState = BaseGraphState & {
     summarizationRequest?: SummarizationNodeInput;
@@ -725,6 +732,19 @@ interface AgentInputFields {
      */
     discoveredTools?: string[];
     summarizationEnabled?: boolean;
+    /**
+     * Runs this agent as a summarize-only pass: the first model step requests
+     * summarization outright instead of consulting the trigger, and the step
+     * after the summary emits its context snapshot and ends the run without a
+     * model call. Hosts use it for user-initiated compaction, where the summary
+     * is the whole response. Requires `summarizationEnabled`: a run that cannot
+     * attempt the summary rejects with `ManualSummarizationSkippedError`
+     * rather than ending with nothing, and one whose provider calls all fail
+     * keeps the history and reports the failure on the summary step. A
+     * multi-agent workflow compiles to the agent that opted in alone; no other
+     * agent runs.
+     */
+    summarizeOnly?: boolean;
     summarizationConfig?: SummarizationConfig;
     /**
      * Optional host-supplied, user-visible guidance for compaction. The SDK