@librechat/agents 3.3.3 → 3.3.5

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

@@ -8,7 +8,7 @@ import type { InjectedMessage } from '@/types/tools';
  * `docs/hooks-design-report.md` §3.2 for the mapping to existing
  * `@librechat/agents` emission points.
  */
-export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
+export declare const HOOK_EVENTS: readonly ["RunStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreemptBoundary", "PermissionDenied", "SubagentStart", "SubagentStop", "Stop", "StopFailure", "PreCompact", "PostCompact"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 /** Tool-gating decision; executeHooks folds with `deny > ask > allow` precedence. */
 export type ToolDecision = 'allow' | 'deny' | 'ask';
@@ -117,6 +117,38 @@ export interface PostToolBatchHookInput extends BaseHookInput {
     /** All tool calls (and their outcomes) from this batch, in batch order. */
     entries: PostToolBatchEntry[];
 }
+/**
+ * Fires when a cooperative preemption seals the model stream mid-generation
+ * — the second injection boundary, and the only one that exists during a
+ * long text answer with no tool calls in it.
+ *
+ * Order: fires after the model stream is sealed and BEFORE the next model
+ * call. The `injectedMessages` a hook returns here are appended verbatim and
+ * the agent node self-loops. Returning nothing is a valid outcome (the host's
+ * queue was cancelled or already drained): the run stops honestly rather than
+ * self-looping into an empty turn.
+ *
+ * The sealed turn is NOT yet observable from graph state when this fires.
+ * Dispatch happens inside the agent node, and only the outer graph's reducer
+ * writes `StandardGraph.messages` — which cannot run until the node returns.
+ * A hook calling `Run.getRunMessages()` here sees the state as of the last
+ * completed superstep, so the sealed text is absent. `PostToolBatch` behaves
+ * the same way: a tool-boundary hook cannot see the assistant turn that
+ * requested the tool. This is a property of the single-node outer graph, not
+ * of preemption, and committing first would mean returning from the node and
+ * re-entering — precisely what the self-loop exists to avoid.
+ *
+ * A hook that needs the sealed text should therefore not go looking for it in
+ * graph state. Decide from the host's own queue, or read it after the run.
+ *
+ * Requires `RunConfig.preemption`. This event is deliberately NOT
+ * result-altering, so registering it never disables eager tool execution.
+ */
+export interface PreemptBoundaryHookInput extends BaseHookInput {
+    hook_event_name: 'PreemptBoundary';
+    /** 1-based index of this seal within the run. */
+    sealCount: number;
+}
 export interface PermissionDeniedHookInput extends BaseHookInput {
     hook_event_name: 'PermissionDenied';
     toolName: string;
@@ -170,7 +202,7 @@ export interface PostCompactHookInput extends BaseHookInput {
     messagesAfterCount: number;
 }
 /** Discriminated union of every hook input shape. */
-export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PostToolBatchHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
+export type HookInput = RunStartHookInput | UserPromptSubmitHookInput | PreToolUseHookInput | PostToolUseHookInput | PostToolUseFailureHookInput | PostToolBatchHookInput | PreemptBoundaryHookInput | PermissionDeniedHookInput | SubagentStartHookInput | SubagentStopHookInput | StopHookInput | StopFailureHookInput | PreCompactHookInput | PostCompactHookInput;
 /** Compile-time map from event name to its input shape. */
 export type HookInputByEvent = {
     RunStart: RunStartHookInput;
@@ -179,6 +211,7 @@ export type HookInputByEvent = {
     PostToolUse: PostToolUseHookInput;
     PostToolUseFailure: PostToolUseFailureHookInput;
     PostToolBatch: PostToolBatchHookInput;
+    PreemptBoundary: PreemptBoundaryHookInput;
     PermissionDenied: PermissionDeniedHookInput;
     SubagentStart: SubagentStartHookInput;
     SubagentStop: SubagentStopHookInput;
@@ -196,14 +229,18 @@ export interface BaseHookOutput {
     additionalContext?: string;
     /**
      * Messages to inject into graph state, one `HumanMessage` per entry
-     * (converted via `ToolNode.convertInjectedMessages`, which preserves
+     * (converted via `convertInjectedMessages`, which preserves
      * `role`/`source`/`isMeta` in `additional_kwargs`). Unlike
      * `additionalContext` — which is consolidated across hooks into a single
      * system-flavored message — each entry keeps its own identity and role,
      * making this the channel for injecting verbatim user speech (e.g. a
      * mid-run steering message). Accumulated across hooks in registration
-     * order. Currently consumed only at the `PostToolBatch` dispatch site;
-     * other events ignore the field.
+     * order.
+     *
+     * Consumed at exactly two dispatch sites, both of which run the same
+     * converter so the emitted shapes cannot drift: `PostToolBatch` (the tool
+     * boundary) and `PreemptBoundary` (a cooperative mid-generation seal).
+     * Every other event ignores the field.
      */
     injectedMessages?: InjectedMessage[];
     /** True to prevent the next model turn. Any hook can set this. */
@@ -305,6 +342,7 @@ export interface PostToolUseHookOutput extends BaseHookOutput {
 }
 export type PostToolUseFailureHookOutput = BaseHookOutput;
 export type PostToolBatchHookOutput = BaseHookOutput;
+export type PreemptBoundaryHookOutput = BaseHookOutput;
 export type PermissionDeniedHookOutput = BaseHookOutput;
 export interface SubagentStartHookOutput extends BaseHookOutput {
     decision?: ToolDecision;
@@ -326,6 +364,7 @@ export type HookOutputByEvent = {
     PostToolUse: PostToolUseHookOutput;
     PostToolUseFailure: PostToolUseFailureHookOutput;
     PostToolBatch: PostToolBatchHookOutput;
+    PreemptBoundary: PreemptBoundaryHookOutput;
     PermissionDenied: PermissionDeniedHookOutput;
     SubagentStart: SubagentStartHookOutput;
     SubagentStop: SubagentStopHookOutput;
@@ -335,7 +374,7 @@ export type HookOutputByEvent = {
     PostCompact: PostCompactHookOutput;
 };
 /** Superset output shape used by the executor's fold loop. */
-export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PostToolBatchHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
+export type HookOutput = RunStartHookOutput | UserPromptSubmitHookOutput | PreToolUseHookOutput | PostToolUseHookOutput | PostToolUseFailureHookOutput | PostToolBatchHookOutput | PreemptBoundaryHookOutput | PermissionDeniedHookOutput | SubagentStartHookOutput | SubagentStopHookOutput | StopHookOutput | StopFailureHookOutput | PreCompactHookOutput | PostCompactHookOutput;
 /**
  * A hook callback is a plain async function registered against a specific
  * event. The `signal` is always supplied by `executeHooks` and combines the

package/dist/types/index.d.ts

@@ -1,6 +1,5 @@
 export * from './run';
 export * from './stream';
-export * from './splitStream';
 export * from './events';
 export * from './messages';
 export * from './graphs';
@@ -45,4 +44,5 @@ export { getChatModelClass } from './llm/providers';
 export { FakeChatModel, createFakeStreamingLLM } from './llm/fake';
 export { initializeModel } from './llm/init';
 export { attemptInvoke, tryFallbackProviders } from './llm/invoke';
+export { canSealPreempt } from './llm/preempt';
 export { isThinkingEnabled, getMaxOutputTokensKey } from './llm/request';

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

@@ -41,6 +41,26 @@ export type InvokeContext = NonNullable<Parameters<ChatModelStreamHandler['handl
  * When provided, replaces the default `ChatModelStreamHandler`.
  */
 export type OnChunk = (chunk: AIMessageChunk) => void | Promise<void>;
+export declare function usesNativeOpenAIResponses(model: t.ChatModel, provider: Providers, callOptions?: unknown): boolean;
+/**
+ * Produces the exact provider-facing message representation before a model
+ * adapter serializes it. This is shared by invocation and Graph's final budget
+ * guard so structured tool output cannot grow after the payload was measured.
+ */
+export declare function projectMessagesForProvider({ model, messages, provider, maxToolResultChars, callOptions, }: {
+    model: t.ChatModel;
+    messages: BaseMessage[];
+    provider: Providers;
+    maxToolResultChars?: number;
+    callOptions?: unknown;
+}): BaseMessage[];
+/**
+ * The serving model's id, read through the same wrapper stack
+ * `collectModelCallbackSources` walks — `bindTools` returns a
+ * `RunnableBinding` and a system runnable pipes a `RunnableSequence`, and
+ * neither exposes the chat model's `model` at the top level.
+ */
+export declare function resolveServingModelId(model: unknown): string | undefined;
 /**
  * Invokes a chat model with the given messages, handling both streaming and
  * non-streaming paths.
@@ -85,7 +105,7 @@ export declare function getFallbackOverflowCandidates(error: unknown): FallbackO
  * behind a later unrelated error would surface a dead end instead. Ordinary
  * failures still throw last-error-wins.
  */
-export declare function tryFallbackProviders({ fallbacks, tools, messages, config, primaryError, context, onChunk, overflowContext, }: {
+export declare function tryFallbackProviders({ fallbacks, tools, messages, config, primaryError, context, onChunk, overflowContext, prepareProviderMessages, }: {
     fallbacks: t.FallbackConfig[];
     tools?: t.GraphTools;
     messages: BaseMessage[];
@@ -100,4 +120,17 @@ export declare function tryFallbackProviders({ fallbacks, tools, messages, confi
      * be dropped in favour of whichever failure came last.
      */
     overflowContext?: ContextOverflowContext;
+    /**
+     * Optional final payload guard used by Graph. It receives the initialized,
+     * tool-bound fallback model so Responses-vs-Chat projection is exact before
+     * the fallback request is measured and sent.
+     */
+    prepareProviderMessages?: (input: {
+        model: t.ChatModel;
+        messages: BaseMessage[];
+        provider: Providers;
+        clientOptions?: t.ClientOptions;
+        maxContextTokens?: number;
+        config?: RunnableConfig;
+    }) => BaseMessage[] | Promise<BaseMessage[]>;
 }): Promise<Partial<t.BaseGraphState> | undefined>;

package/dist/types/llm/openai/index.d.ts

@@ -11,6 +11,7 @@ import type { ChatResult } from '@langchain/core/outputs';
 import type { ChatXAIInput } from '@langchain/xai';
 import type * as t from '@langchain/openai';
 import type { HeaderValue, HeadersLike } from './types';
+import type { PromptCacheTtl } from '@/messages/cache';
 export declare function isHeaders(headers: unknown): headers is Headers;
 export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
 type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
@@ -20,6 +21,9 @@ type LibreChatOpenAIFields = t.ChatOpenAIFields & {
     includeReasoningContent?: boolean;
     includeReasoningDetails?: boolean;
     convertReasoningDetailsToContent?: boolean;
+    preserveToolCacheControl?: boolean;
+    responsesPromptCache?: boolean;
+    responsesPromptCacheTtl?: PromptCacheTtl;
     promptCacheExplicit?: boolean;
     safety_identifier?: string;
 };

package/dist/types/llm/openai/utils/index.d.ts

@@ -22,6 +22,8 @@ export interface ConvertMessagesOptions {
     includeReasoningDetails?: boolean;
     /** Convert reasoning_details to content blocks for Claude (requires content array format) */
     convertReasoningDetailsToContent?: boolean;
+    /** Preserve OpenRouter's canonical cache-decorated tool text block. */
+    preserveToolCacheControl?: boolean;
 }
 export declare function _convertMessagesToOpenAIParams(messages: BaseMessage[], model?: string, options?: ConvertMessagesOptions): OpenAICompletionParam[];
 export declare function _convertMessagesToOpenAIResponsesParams(messages: BaseMessage[], model?: string, zdrEnabled?: boolean): ResponsesInputItem[];

package/dist/types/llm/openrouter/index.d.ts

@@ -16,6 +16,7 @@ export interface ChatOpenRouterCallOptions extends Omit<ChatOpenAICallOptions, '
     include_reasoning?: boolean;
     reasoning?: OpenRouterReasoning;
     modelKwargs?: OpenAIChatInput['modelKwargs'];
+    useResponsesApi?: boolean;
     promptCache?: boolean;
     /**
      * Prompt-cache breakpoint TTL. Defaults to `'1h'` (extended cache) when
@@ -29,6 +30,10 @@ export type ChatOpenRouterInput = Partial<ChatOpenRouterCallOptions & OpenAIChat
 /** invocationParams return type extended with OpenRouter reasoning */
 export type OpenRouterInvocationParams = Omit<OpenAIClient.Chat.ChatCompletionCreateParams, 'messages'> & {
     reasoning?: OpenRouterReasoning;
+    cache_control?: {
+        type: 'ephemeral';
+        ttl?: '1h';
+    };
 };
 type InvocationParamsExtra = {
     streaming?: boolean;

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

@@ -0,0 +1,40 @@
+import type { AIMessageChunk } from '@langchain/core/messages';
+/**
+ * Normalizes a host-supplied seal budget.
+ *
+ * Read in two places that interpret it differently — a numeric comparison in
+ * the seal gate and an addition into the recursion limit — so a value like
+ * `1.5` would permit two seals while reserving fractional headroom, `NaN`
+ * would poison the recursion limit outright, and `Infinity` would remove both
+ * bounds at once. Normalizing once keeps the two readings in agreement.
+ *
+ * `0` is honored as a deliberate "never seal"; anything not finite falls back
+ * to the default rather than silently disabling the feature.
+ */
+export declare function resolveMaxSeals(maxSeals: number | undefined): number;
+/**
+ * Cooperative mid-generation seal gate. Returns true ONLY when sealing here
+ * yields a message sequence valid on EVERY supported provider:
+ *  - non-whitespace TEXT content, so the FIRST injected user turn is preceded
+ *    by a non-empty assistant turn — no empty-content 400s. Note this says
+ *    nothing about adjacency AMONG several injected turns: a boundary that
+ *    drains two steers emits two consecutive user messages, which strict
+ *    providers reject. That is normalized at the provider-facing hop by
+ *    `coalesceAdjacentUserTurns`, not here;
+ *  - no tool call in flight, so no `tool_use` can be orphaned AND no eagerly
+ *    prestarted execution can be stripped out from under the model.
+ *
+ * Anthropic's server-side tools need no check of their own. Every
+ * `server_tool_use` content block also emits a `tool_call_chunk`
+ * (`_makeMessageChunkFromAnthropicEvent`), and `concat` keeps that chunk on
+ * the accumulated message for the remainder of the turn, so the tool-call
+ * gates below already cover it. The practical consequence is worth stating
+ * plainly: once a turn starts a web search it is no longer preemptible, and
+ * a queued message waits for the ordinary tool boundary instead.
+ *
+ * Nothing is stripped and nothing is repaired: when the accumulated shape is
+ * not already safe the stream simply runs on, and whatever the host queued
+ * lands at the next tool boundary instead. Chunks accumulate monotonically
+ * through `concat`, so an unsafe shape can never be observed at a seal point.
+ */
+export declare function canSealPreempt(chunk: AIMessageChunk | undefined): boolean;

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

@@ -0,0 +1,23 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import { Providers } from '@/common';
+/**
+ * Providers whose APIs specify strict user/assistant alternation. Mistral
+ * rejects consecutive user turns outright. Bedrock's Converse API documents
+ * the alternation requirement across many model families; enforcement varies
+ * by family — Claude on Converse currently tolerates adjacent user turns
+ * (verified live, 2026-07-28) — so the payload is normalized for all of them
+ * rather than betting on per-family leniency. Anthropic's own Messages API,
+ * OpenAI and Gemini all accept consecutive user turns, so they are
+ * deliberately absent.
+ */
+export declare const strictAlternationProviders: ReadonlySet<Providers>;
+/**
+ * Merges runs of consecutive human turns into one, for providers that reject
+ * them. Purely a wire-shaping pass: it returns a new array of new messages,
+ * so graph state and the host's persisted messages keep the per-message
+ * identity that steer rendering and the trailing-steer anchor rely on.
+ *
+ * Tool-result turns are excluded — the converters merge those themselves, and
+ * combining one with a text turn would orphan the pairing.
+ */
+export declare function coalesceAdjacentUserTurns(messages: BaseMessage[]): BaseMessage[];

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

@@ -9,7 +9,8 @@
  * - Hard-clear: Replace entire content with a placeholder.
  *
  * Messages in the "protected zone" (recent assistant turns, system/pre-first-human
- * messages, and messages with image content) are never pruned.
+ * messages) are never pruned. Atomic media/resource blocks are preserved when
+ * they fit; oversized inline payloads are replaced with bounded placeholders.
  */
 import { type BaseMessage } from '@langchain/core/messages';
 import type { ContextPruningSettings } from './contextPruningSettings';

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

@@ -9,6 +9,42 @@ export declare function getConverseOverrideMessage({ userMessage, lastMessageX,
 export declare function modifyDeltaProperties(provider: Providers, obj?: AIMessageChunk): AIMessageChunk | undefined;
 export declare function formatAnthropicMessage(message: AIMessageChunk): AIMessage;
 export declare function convertMessagesToContent(messages: BaseMessage[]): t.MessageContentComplex[];
+/**
+ * Drops incomplete streamed text-input fragments that some providers retain
+ * beside the assembled parsed tool call. They are neither user-visible text
+ * nor valid content blocks for a subsequent provider.
+ */
+export declare function projectToolStreamContentForProvider(messages: BaseMessage[]): 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. */
+export declare function projectOpenAIChatToolMessageContent(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/** Preserves OpenRouter's cache-decorated text blocks for a Chat attempt. */
+export declare function projectOpenRouterToolMessageContent(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/** Projects Responses tool content and collapses parsed/raw computer-call mirrors. */
+export declare function projectOpenAIResponsesToolMessageContent(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/** Removes Anthropic/OpenRouter cache metadata before unsupported providers run. */
+export declare function projectCacheControlledToolOutputsToText(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/** Unwraps a canonical single text block after provider cache markers are removed. */
+export declare function projectSingleTextToolOutputsToText(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/** Serializes provider-neutral structured tool outputs without media pairing. */
+export declare function projectStructuredToolOutputsToText(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/**
+ * Non-Responses providers cannot consume native computer screenshots. Keep
+ * the tool-call structure intact, but replace screenshot bytes with a bounded
+ * text marker at the actual invocation boundary.
+ */
+export declare function projectComputerCallOutputsToText(messages: BaseMessage[]): BaseMessage[];
+export declare function projectAnthropicArtifactContent(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/**
+ * Mutating compatibility wrapper retained for existing package consumers.
+ * New provider-call paths should use `projectAnthropicArtifactContent`.
+ */
 export declare function formatAnthropicArtifactContent(messages: BaseMessage[]): void;
+export declare function projectArtifactPayload(messages: BaseMessage[], maxChars?: number): BaseMessage[];
+/**
+ * Mutating compatibility wrapper retained for existing package consumers.
+ * New provider-call paths should use `projectArtifactPayload`.
+ */
 export declare function formatArtifactPayload(messages: BaseMessage[]): void;
 export declare function findLastIndex<T>(array: T[], predicate: (value: T) => boolean): number;

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

@@ -151,6 +151,12 @@ export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap
  * @returns A new map with the system message at index 0 and all other indices shifted by 1
  */
 export declare function shiftIndexTokenCountMap(indexTokenCountMap: Record<number, number>, instructionsTokenCount: number): Record<number, number>;
+/**
+ * Identifies provider-context placeholders created by this module without
+ * trusting user-controlled content prefixes or leaking marker metadata onto
+ * the provider wire.
+ */
+export declare function isSyntheticProviderContextMessage(message: BaseMessage): boolean;
 /**
  * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
  * Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,

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

@@ -0,0 +1,40 @@
+import type { BaseMessage } from '@langchain/core/messages';
+/**
+ * Bracketed-meta convention, like the handoff path's
+ * `[Processed tool result and transferring to …]` bridge. The wording makes
+ * two things unambiguous to the model: the assistant turn above is FINISHED,
+ * and it belongs to a previous stage — so the successor answers as itself
+ * instead of continuing someone else's sentence.
+ */
+export declare const PREDECESSOR_HANDOFF_CUE: string;
+/**
+ * Appends a user-turn handoff cue when a payload ends with an assistant turn
+ * that THIS RUN produced — which only happens when a different agent in a
+ * multi-agent workflow produced it (an agent's own self-loops always re-enter
+ * on a tool result or an injected user turn).
+ *
+ * Why: providers with prefill semantics (Anthropic, Bedrock-Claude) treat a
+ * trailing assistant message as a prefill and CONTINUE it. A bare direct-edge
+ * successor therefore speaks in its predecessor's voice — or, when the
+ * trailing turn reads complete (a preemption steer's short resume, say),
+ * returns empty content (danny-avila/agents#345, reproduced live 3/3).
+ * Handoff edges with instructions and prompt-instruction edges already break
+ * the prefill with a user turn; this closes the same gap for bare edges.
+ *
+ * Fail-safe OFF by provenance: the trailing payload message must be one the
+ * run itself produced (`isRunProduced`, backed by the graph's run-produced id
+ * set — immune to summarization compaction, which rewrites the live array
+ * and stales index-based boundaries). Host-supplied trailing assistant
+ * turns (deliberate prefill flows) never match — the run has not produced
+ * them — so single-agent prefill behavior is untouched. Wire-only: the cue is
+ * appended to the provider projection, never to graph state or host history.
+ */
+export declare function appendPredecessorHandoffCue(messages: BaseMessage[], isRunProduced: ((message: BaseMessage) => boolean) | undefined): BaseMessage[];
+/**
+ * Strips a trailing handoff cue. The counterpart for the serving-provider
+ * funnel: an Anthropic-like PRIMARY bakes the cue into its measured payload,
+ * and a tolerant fallback (OpenAI, Mistral, Bedrock-Nova) re-sending that
+ * payload must not ship the Claude-only synthetic turn. Identity on the
+ * no-op path.
+ */
+export declare function removePredecessorHandoffCue(messages: BaseMessage[]): BaseMessage[];

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

@@ -7,6 +7,9 @@ export * from './cache';
 export * from './anthropicToolCache';
 export * from './content';
 export * from './tools';
+export * from './injected';
+export * from './alternation';
+export * from './handoffCue';
 export * from './contextPruning';
 export * from './contextPruningSettings';
 export * from './reducer';

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

@@ -0,0 +1,3 @@
+import type { BaseMessage } from '@langchain/core/messages';
+import type { InjectedMessage } from '@/types/tools';
+export declare function convertInjectedMessages(messages: InjectedMessage[]): BaseMessage[];

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

@@ -4,6 +4,8 @@ import type { TokenCounter } from '@/types/run';
 import { ContentTypes, Providers } from '@/common';
 /** Default fraction of the token budget reserved as headroom (5 %). */
 export declare const DEFAULT_RESERVE_RATIO = 0.05;
+/** Provider framing reserved for the assistant reply label. */
+export declare const REPLY_PRIMER_TOKENS = 3;
 /** Hard cap for the originalToolContent store (~2 MB estimated from char length). */
 export declare const ORIGINAL_CONTENT_MAX_CHARS = 2000000;
 /**
@@ -25,6 +27,8 @@ export declare function clampCalibrationRatio(ratio: number): number;
 export type PruneMessagesFactoryParams = {
     provider?: Providers;
     maxTokens: number;
+    /** Per-tool-result character cap applied while reconciling cached counts. */
+    maxToolResultChars?: number;
     startIndex: number;
     tokenCounter: TokenCounter;
     indexTokenCountMap: Record<string, number | undefined>;
@@ -113,7 +117,7 @@ export declare function repairOrphanedToolMessages({ context, allMessages, token
  * Includes a fast-path: if every tool_call has a matching tool_result and
  * vice-versa, the original array is returned immediately with zero allocation.
  */
-export declare function sanitizeOrphanToolBlocks(messages: BaseMessage[]): BaseMessage[];
+export declare function sanitizeOrphanToolBlocks(messages: BaseMessage[], onMessageCloned?: (source: BaseMessage, clone: BaseMessage) => void): BaseMessage[];
 /**
  * Calculates the total tokens from a single usage object
  *
@@ -200,18 +204,18 @@ export declare function preFlightTruncateToolResults(params: {
     tokenCounter: TokenCounter;
 }): number;
 /**
- * Pre-flight truncation: truncates oversized `tool_use` input fields in AI messages.
- *
- * Tool call inputs (arguments) can be very large — e.g., code evaluation payloads from
- * MCP tools like chrome-devtools. Since these tool calls have already been executed,
- * the model only needs a summary of what was called, not the full arguments. Truncating
- * them before pruning can prevent entire messages from being dropped.
- *
- * Uses 15% of the context window (in estimated characters, ~4 chars/token) as the
- * per-input cap, capped at 200K chars.
- *
- * @returns The number of AI messages that had tool_use inputs truncated.
+ * Serializes one structured tool-call input as valid, bounded JSON without
+ * invoking user-defined accessors or `toJSON`.
+ */
+export declare function serializeToolCallInput(input: unknown, maxChars?: number): string;
+/** Per-input cap: 15% of context at ~4 chars/token, never above 200K chars. */
+export declare function calculateMaxToolCallInputChars(maxContextTokens?: number): number;
+/**
+ * Projects historical tool-call inputs into a provider-safe bounded form.
+ * Returns the original array when no message changes and otherwise clones only
+ * the array and AI messages whose inline input or `tool_calls` args changed.
  */
+export declare function projectToolCallInputs(messages: BaseMessage[], maxInputChars: number): BaseMessage[];
 export declare function preFlightTruncateToolCallInputs(params: {
     messages: BaseMessage[];
     maxContextTokens: number;

package/dist/types/run.d.ts

@@ -17,6 +17,7 @@ export declare class Run<_T extends t.BaseGraphState> {
     private interruptingToolNames?;
     private toolExecution?;
     private subagentUsageSink?;
+    private preemption?;
     private indexTokenCountMap?;
     calibrationRatio: number;
     graphRunnable?: t.CompiledStateWorkflow;
@@ -109,6 +110,12 @@ export declare class Run<_T extends t.BaseGraphState> {
      */
     getCalibrationRatio(): number;
     getResolvedInstructionOverhead(): number | undefined;
+    /**
+     * Cooperative-seal counters for this run. `emptyBoundaries` is the one to
+     * watch: it counts seals whose `PreemptBoundary` produced nothing to
+     * inject, which ends the turn early and leaves the answer unfinished.
+     */
+    getPreemptStats(): t.PreemptStats;
     getToolCount(): number;
     /**
      * Creates a custom event callback handler that intercepts custom events

package/dist/types/stream.d.ts

@@ -8,7 +8,21 @@ export declare function getChunkContent({ chunk, provider, reasoningKey, }: {
     provider?: Providers;
     reasoningKey: 'reasoning_content' | 'reasoning';
 }): string | t.MessageContentComplex[] | undefined;
+/**
+ * Brands a handler as one that dispatches content parts for the SDK — either
+ * `ChatModelStreamHandler` itself or a wrapper forwarding to one.
+ *
+ * Identity alone is not a usable contract here. Hosts compose and wrap
+ * handlers (`composeEventHandlers`, `createRunHandlers`), and every wrapper
+ * fails `instanceof` while still driving the same dispatch. A brand survives
+ * wrapping, so "does this handler own content-part dispatch" can be answered
+ * about a value the SDK did not construct.
+ */
+export declare const SDK_STREAM_DISPATCH: unique symbol;
+/** True when `handler` is, or forwards to, the SDK's stream dispatcher. */
+export declare function dispatchesChatModelStream(handler?: t.EventHandler): boolean;
 export declare class ChatModelStreamHandler implements t.EventHandler {
+    readonly [SDK_STREAM_DISPATCH] = true;
     handle(event: string, data: t.StreamEventData, metadata?: Record<string, unknown>, graph?: StandardGraph): Promise<void>;
     handleReasoning(chunk: Partial<AIMessageChunk>, agentContext: AgentContext): void;
 }

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

@@ -401,13 +401,6 @@ export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
      * actually dispatched so the caller can fall back to batch-time emission.
      */
     private dispatchEarlyToolCompletion;
-    /**
-     * Converts InjectedMessage instances to LangChain HumanMessage objects.
-     * Both 'user' and 'system' roles become HumanMessage to avoid provider
-     * rejections (Anthropic/Google reject non-leading SystemMessages).
-     * The original role is preserved in additional_kwargs for downstream consumers.
-     */
-    private convertInjectedMessages;
     /**
      * Execute a group of direct (in-process) tool calls with interrupt-safe
      * ordering, returning outputs aligned 1:1 with `directCalls`.

package/dist/types/tools/search/keenable-scraper.d.ts

@@ -0,0 +1,15 @@
+import type * as t from './types';
+export declare class KeenableScraper implements t.BaseScraper {
+    private apiKey;
+    private apiUrl;
+    private timeout;
+    private attributionTitle;
+    private logger;
+    constructor(config?: t.KeenableScraperConfig);
+    private buildHeaders;
+    scrapeUrl(url: string, options?: t.KeenableScrapeOptions): Promise<[string, t.KeenableScrapeResponse]>;
+    scrapeUrls(urls: string[], options?: t.KeenableScrapeOptions): Promise<Array<[string, t.KeenableScrapeResponse]>>;
+    extractContent(response: t.KeenableScrapeResponse): [string, undefined | t.References];
+    extractMetadata(response: t.KeenableScrapeResponse): t.GenericScrapeMetadata;
+}
+export declare const createKeenableScraper: (config?: t.KeenableScraperConfig) => KeenableScraper;

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

@@ -3,7 +3,7 @@ import type { Logger as WinstonLogger } from 'winston';
 import type { BaseReranker } from './rerankers';
 import { DATE_RANGE } from './schema';
 export type SearchProvider = 'serper' | 'searxng' | 'tavily' | 'keenable' | 'crw';
-export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'crw';
+export type ScraperProvider = 'firecrawl' | 'serper' | 'tavily' | 'crw' | 'keenable';
 export type RerankerType = 'infinity' | 'jina' | 'cohere' | 'none';
 export interface Highlight {
     score: number;
@@ -172,6 +172,34 @@ export interface KeenableSearchResult {
 export interface KeenableSearchResponse {
     results?: KeenableSearchResult[];
 }
+export interface KeenableScraperConfig {
+    apiKey?: string;
+    /** Override the fetch endpoint base (default: public keyless, keyed when a
+     * key is set). Env fallback: KEENABLE_FETCH_URL. */
+    apiUrl?: string;
+    timeout?: number;
+    logger?: Logger;
+    /** Sent as the X-Keenable-Title attribution header. Defaults to "LibreChat". */
+    attributionTitle?: string;
+}
+export type KeenableScrapeOptions = Omit<KeenableScraperConfig, 'apiKey' | 'apiUrl' | 'logger'>;
+/** Raw JSON shape returned by GET /v1/fetch{,/public}?url=... */
+export interface KeenableFetchResult {
+    url?: string;
+    title?: string;
+    content?: string;
+    description?: string;
+}
+export interface KeenableScrapeResponse {
+    success: boolean;
+    data?: {
+        content: string;
+        title?: string;
+        description?: string;
+        url?: string;
+    };
+    error?: string;
+}
 export type References = {
     links: MediaReference[];
     images: MediaReference[];
@@ -272,6 +300,7 @@ export type Logger = WinstonLogger;
 export interface SearchToolConfig extends SearchConfig, ProcessSourcesConfig, FirecrawlConfig {
     tavilyScraperOptions?: TavilyScraperConfig;
     crwScraperOptions?: CrwScraperConfig;
+    keenableScraperOptions?: KeenableScraperConfig;
     /** Max chars of highlight content this tool feeds the MODEL per search (the
      * dominant, otherwise-unbounded part of the output). Distinct from
      * `maxContentLength`, which caps scraped/reranked content per source — full
@@ -303,7 +332,7 @@ export type UsedReferences = {
     originalIndex: number;
     reference: MediaReference;
 }[];
-export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse | CrwScrapeResponse;
+export type AnyScraperResponse = FirecrawlScrapeResponse | SerperScrapeResponse | TavilyScrapeResponse | CrwScrapeResponse | KeenableScrapeResponse;
 /** Base Scraper Interface */
 export interface BaseScraper {
     scrapeUrl(url: string, options?: unknown): Promise<[string, AnyScraperResponse]>;

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

@@ -7,7 +7,7 @@ import type { GoogleAIToolType } from '@langchain/google-common';
 import type { SummarizationNodeInput, SummarizeCompleteEvent, SummarizationConfig, SummarizeStartEvent, SummarizeDeltaEvent } from '@/types/summarize';
 import type { ToolMap, ToolEndEvent, GenericTool, LCTool, ToolExecuteBatchRequest } from '@/types/tools';
 import type { RunStep, RunStepDeltaEvent, MessageDeltaEvent, ReasoningDeltaEvent } from '@/types/stream';
-import type { TokenCounter, TokenBudgetBreakdown } from '@/types/run';
+import type { TokenCounter, StreamPreemption, TokenBudgetBreakdown } from '@/types/run';
 import type { Providers, Callback, GraphNodeKeys } from '@/common';
 import type { StandardGraph, MultiAgentGraph } from '@/graphs';
 import type { ClientOptions } from '@/types/llm';
@@ -243,6 +243,13 @@ export type StandardGraphInput = {
      * hook inputs carry only `executingAgentId`.
      */
     subagentScope?: boolean;
+    /**
+     * Cooperative preemption, forwarded from `RunConfig.preemption`. Only ever
+     * set on the top-level graph: a steer targets the conversation, so subagent
+     * children must run to completion and `buildChildInputs` does not propagate
+     * this field.
+     */
+    preemption?: StreamPreemption;
 };
 export type GraphEdge = {
     /** Agent ID, use a list for multiple sources */