@librechat/agents 3.2.32 → 3.2.33

package/dist/esm/summarization/node.mjs

@@ -1,34 +1,35 @@
-import { ToolMessage, HumanMessage, SystemMessage, AIMessage } from '@langchain/core/messages';
-import { ContentTypes, StepTypes, GraphEvents } from '../common/enum.mjs';
-import { emitAgentLog, safeDispatchCustomEvent } from '../utils/events.mjs';
-import { tryFallbackProviders, attemptInvoke } from '../llm/invoke.mjs';
-import { createRemoveAllMessage } from '../messages/reducer.mjs';
-import { splitAtRecencyBoundary } from '../messages/recency.mjs';
-import { getMaxOutputTokensKey } from '../llm/request.mjs';
-import { addCacheControl } from '../messages/cache.mjs';
-import { initializeModel } from '../llm/init.mjs';
-import { getChunkContent } from '../stream.mjs';
-import { executeHooks } from '../hooks/executeHooks.mjs';
-import '../hooks/createWorkspacePolicyHook.mjs';
-
-const SUMMARIZATION_PARAM_KEYS = new Set(['maxSummaryTokens']);
+import "../common/enum.mjs";
+import "../common/index.mjs";
+import { emitAgentLog, safeDispatchCustomEvent } from "../utils/events.mjs";
+import { addCacheControl } from "../messages/cache.mjs";
+import { createRemoveAllMessage } from "../messages/reducer.mjs";
+import { splitAtRecencyBoundary } from "../messages/recency.mjs";
+import { getChunkContent } from "../stream.mjs";
+import { executeHooks } from "../hooks/executeHooks.mjs";
+import "../hooks/index.mjs";
+import { initializeModel } from "../llm/init.mjs";
+import { attemptInvoke, tryFallbackProviders } from "../llm/invoke.mjs";
+import { getMaxOutputTokensKey } from "../llm/request.mjs";
+import { AIMessage, HumanMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
+//#region src/summarization/node.ts
+const SUMMARIZATION_PARAM_KEYS = new Set(["maxSummaryTokens"]);
 /**
- * Default number of recent user-led turns preserved verbatim during
- * compaction.  A turn begins at a HumanMessage and includes every
- * following AIMessage and ToolMessage up to the next HumanMessage.
- * The most recent turn is always retained regardless of this value;
- * the default of `2` additionally keeps the prior exchange so the
- * model has fresh context on what just happened.  Setting
- * `retainRecent.turns` to `0` reverts to the legacy "summarize every
- * message" behavior.
- */
+* Default number of recent user-led turns preserved verbatim during
+* compaction.  A turn begins at a HumanMessage and includes every
+* following AIMessage and ToolMessage up to the next HumanMessage.
+* The most recent turn is always retained regardless of this value;
+* the default of `2` additionally keeps the prior exchange so the
+* model has fresh context on what just happened.  Setting
+* `retainRecent.turns` to `0` reverts to the legacy "summarize every
+* message" behavior.
+*/
 const DEFAULT_RETAIN_RECENT_TURNS = 2;
 /**
- * Token overhead of the XML wrapper + instruction text added around the
- * summary at injection time in AgentContext.buildSystemRunnable:
- * `<summary>\n${text}\n</summary>\n\nYour context window was compacted...`
- * ~33 tokens on Anthropic, ~24-27 on OpenAI.  Using 33 as a safe ceiling.
- */
+* Token overhead of the XML wrapper + instruction text added around the
+* summary at injection time in AgentContext.buildSystemRunnable:
+* `<summary>\n${text}\n</summary>\n\nYour context window was compacted...`
+* ~33 tokens on Anthropic, ~24-27 on OpenAI.  Using 33 as a safe ceiling.
+*/
 const SUMMARY_WRAPPER_OVERHEAD_TOKENS = 33;
 /** Structured checkpoint prompt for fresh summarization (no prior summary). */
 const DEFAULT_SUMMARIZATION_PROMPT = `Hold on, before you continue I need you to write me a checkpoint of everything so far. Your context window is filling up and this checkpoint replaces the messages above, so capture everything you need to pick right back up.
@@ -81,819 +82,668 @@ Rules:
 - Preserve exact identifiers, names, errors, and references verbatim
 - Skip empty sections`;
 function separateParameters(parameters) {
-    const llmParams = {};
-    let maxSummaryTokens;
-    for (const [key, value] of Object.entries(parameters)) {
-        if (SUMMARIZATION_PARAM_KEYS.has(key)) {
-            if (key === 'maxSummaryTokens' &&
-                typeof value === 'number' &&
-                value > 0) {
-                maxSummaryTokens = value;
-            }
-        }
-        else {
-            llmParams[key] = value;
-        }
-    }
-    return { llmParams, maxSummaryTokens };
+	const llmParams = {};
+	let maxSummaryTokens;
+	for (const [key, value] of Object.entries(parameters)) if (SUMMARIZATION_PARAM_KEYS.has(key)) {
+		if (key === "maxSummaryTokens" && typeof value === "number" && value > 0) maxSummaryTokens = value;
+	} else llmParams[key] = value;
+	return {
+		llmParams,
+		maxSummaryTokens
+	};
 }
 /**
- * Generates a structural metadata summary without making an LLM call.
- * Used as a last-resort fallback when all summarization attempts fail.
- * Preserves tool names and message counts so the agent retains basic context.
- */
+* Generates a structural metadata summary without making an LLM call.
+* Used as a last-resort fallback when all summarization attempts fail.
+* Preserves tool names and message counts so the agent retains basic context.
+*/
 function generateMetadataStub(messages) {
-    const counts = {};
-    const toolNames = new Set();
-    for (const msg of messages) {
-        const role = msg.getType();
-        counts[role] = (counts[role] ?? 0) + 1;
-        if (role === 'tool' && msg.name != null && msg.name !== '') {
-            toolNames.add(msg.name);
-        }
-        if (role === 'ai' &&
-            msg instanceof AIMessage &&
-            msg.tool_calls &&
-            msg.tool_calls.length > 0) {
-            for (const tc of msg.tool_calls) {
-                toolNames.add(tc.name);
-            }
-        }
-    }
-    const countParts = Object.entries(counts)
-        .map(([role, count]) => `${count} ${role}`)
-        .join(', ');
-    const lines = [
-        `[Metadata summary: ${messages.length} messages (${countParts})]`,
-    ];
-    if (toolNames.size > 0) {
-        lines.push(`[Tools used: ${Array.from(toolNames).join(', ')}]`);
-    }
-    return lines.join('\n');
+	const counts = {};
+	const toolNames = /* @__PURE__ */ new Set();
+	for (const msg of messages) {
+		const role = msg.getType();
+		counts[role] = (counts[role] ?? 0) + 1;
+		if (role === "tool" && msg.name != null && msg.name !== "") toolNames.add(msg.name);
+		if (role === "ai" && msg instanceof AIMessage && msg.tool_calls && msg.tool_calls.length > 0) for (const tc of msg.tool_calls) toolNames.add(tc.name);
+	}
+	const countParts = Object.entries(counts).map(([role, count]) => `${count} ${role}`).join(", ");
+	const lines = [`[Metadata summary: ${messages.length} messages (${countParts})]`];
+	if (toolNames.size > 0) lines.push(`[Tools used: ${Array.from(toolNames).join(", ")}]`);
+	return lines.join("\n");
 }
 /** Maximum number of tool failures to include in the enrichment section. */
 const MAX_TOOL_FAILURES = 8;
 /** Maximum chars per failure summary line. */
 const MAX_TOOL_FAILURE_CHARS = 240;
 /**
- * Extracts failed tool results from messages and formats them as a structured
- * section. LLMs often omit specific failure details (exit codes, error messages)
- * from their summaries, this mechanical enrichment guarantees they survive.
- */
+* Extracts failed tool results from messages and formats them as a structured
+* section. LLMs often omit specific failure details (exit codes, error messages)
+* from their summaries, this mechanical enrichment guarantees they survive.
+*/
 function extractToolFailuresSection(messages) {
-    const failures = [];
-    const seen = new Set();
-    for (const msg of messages) {
-        if (msg.getType() !== 'tool') {
-            continue;
-        }
-        const toolMsg = msg;
-        if (toolMsg.status !== 'error') {
-            continue;
-        }
-        // Deduplicate by tool_call_id
-        const callId = toolMsg.tool_call_id;
-        if (callId && seen.has(callId)) {
-            continue;
-        }
-        if (callId) {
-            seen.add(callId);
-        }
-        const toolName = toolMsg.name ?? 'tool';
-        const content = typeof toolMsg.content === 'string'
-            ? toolMsg.content
-            : JSON.stringify(toolMsg.content);
-        const normalized = content.replace(/\s+/g, ' ').trim();
-        const summary = normalized.length > MAX_TOOL_FAILURE_CHARS
-            ? `${normalized.slice(0, MAX_TOOL_FAILURE_CHARS - 3)}...`
-            : normalized;
-        failures.push({ toolName, summary });
-    }
-    if (failures.length === 0) {
-        return '';
-    }
-    const lines = failures
-        .slice(0, MAX_TOOL_FAILURES)
-        .map((f) => `- ${f.toolName}: ${f.summary}`);
-    if (failures.length > MAX_TOOL_FAILURES) {
-        lines.push(`- ...and ${failures.length - MAX_TOOL_FAILURES} more`);
-    }
-    return `\n\n## Tool Failures\n${lines.join('\n')}`;
+	const failures = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const msg of messages) {
+		if (msg.getType() !== "tool") continue;
+		const toolMsg = msg;
+		if (toolMsg.status !== "error") continue;
+		const callId = toolMsg.tool_call_id;
+		if (callId && seen.has(callId)) continue;
+		if (callId) seen.add(callId);
+		const toolName = toolMsg.name ?? "tool";
+		const normalized = (typeof toolMsg.content === "string" ? toolMsg.content : JSON.stringify(toolMsg.content)).replace(/\s+/g, " ").trim();
+		const summary = normalized.length > MAX_TOOL_FAILURE_CHARS ? `${normalized.slice(0, MAX_TOOL_FAILURE_CHARS - 3)}...` : normalized;
+		failures.push({
+			toolName,
+			summary
+		});
+	}
+	if (failures.length === 0) return "";
+	const lines = failures.slice(0, MAX_TOOL_FAILURES).map((f) => `- ${f.toolName}: ${f.summary}`);
+	if (failures.length > MAX_TOOL_FAILURES) lines.push(`- ...and ${failures.length - MAX_TOOL_FAILURES} more`);
+	return `\n\n## Tool Failures\n${lines.join("\n")}`;
 }
 /**
- * Appends mechanical enrichment sections to an LLM-generated summary.
- * Tool failures are appended verbatim because LLMs often omit specific
- * error details from their summaries.
- */
+* Appends mechanical enrichment sections to an LLM-generated summary.
+* Tool failures are appended verbatim because LLMs often omit specific
+* error details from their summaries.
+*/
 function enrichSummary(summaryText, messages) {
-    return summaryText + extractToolFailuresSection(messages);
+	return summaryText + extractToolFailuresSection(messages);
 }
 /**
- * Restores pre-masking tool content onto the messages array using
- * `pendingOriginalToolContent` stored on AgentContext. Only allocates
- * a new array when there are entries to restore; otherwise returns the
- * input reference unchanged.
- */
+* Restores pre-masking tool content onto the messages array using
+* `pendingOriginalToolContent` stored on AgentContext. Only allocates
+* a new array when there are entries to restore; otherwise returns the
+* input reference unchanged.
+*/
 function restoreOriginalToolContent(messages, originalToolContent) {
-    if (originalToolContent == null || originalToolContent.size === 0) {
-        return messages;
-    }
-    const restored = [...messages];
-    for (const [idx, content] of originalToolContent) {
-        const msg = restored[idx];
-        if (msg instanceof ToolMessage) {
-            restored[idx] = new ToolMessage({
-                content,
-                tool_call_id: msg.tool_call_id,
-                name: msg.name,
-                id: msg.id,
-                additional_kwargs: msg.additional_kwargs,
-                response_metadata: msg.response_metadata,
-            });
-        }
-    }
-    return restored;
+	if (originalToolContent == null || originalToolContent.size === 0) return messages;
+	const restored = [...messages];
+	for (const [idx, content] of originalToolContent) {
+		const msg = restored[idx];
+		if (msg instanceof ToolMessage) restored[idx] = new ToolMessage({
+			content,
+			tool_call_id: msg.tool_call_id,
+			name: msg.name,
+			id: msg.id,
+			additional_kwargs: msg.additional_kwargs,
+			response_metadata: msg.response_metadata
+		});
+	}
+	return restored;
 }
 /** Assembles the summarization model's client options from agent and config. */
 function buildSummarizationClientConfig(agentContext, summarizationConfig) {
-    const provider = (summarizationConfig?.provider ??
-        agentContext.provider);
-    const modelName = summarizationConfig?.model;
-    const parameters = summarizationConfig?.parameters ?? {};
-    const promptText = summarizationConfig?.prompt ?? DEFAULT_SUMMARIZATION_PROMPT;
-    const updatePromptText = summarizationConfig?.updatePrompt ?? DEFAULT_UPDATE_SUMMARIZATION_PROMPT;
-    const { llmParams, maxSummaryTokens: paramMaxSummaryTokens } = separateParameters(parameters);
-    const isSelfSummarize = provider === agentContext.provider;
-    const baseOptions = isSelfSummarize && agentContext.clientOptions
-        ? { ...agentContext.clientOptions }
-        : {};
-    const clientOptions = {
-        ...baseOptions,
-        ...llmParams,
-    };
-    if (modelName != null && modelName !== '') {
-        clientOptions.model = modelName;
-        clientOptions.modelName = modelName;
-    }
-    const effectiveMaxSummaryTokens = paramMaxSummaryTokens ?? summarizationConfig?.maxSummaryTokens;
-    if (effectiveMaxSummaryTokens != null) {
-        clientOptions[getMaxOutputTokensKey(provider)] = effectiveMaxSummaryTokens;
-    }
-    return {
-        provider,
-        modelName,
-        clientOptions,
-        effectiveMaxSummaryTokens,
-        promptText,
-        updatePromptText,
-    };
+	const provider = summarizationConfig?.provider ?? agentContext.provider;
+	const modelName = summarizationConfig?.model;
+	const parameters = summarizationConfig?.parameters ?? {};
+	const promptText = summarizationConfig?.prompt ?? DEFAULT_SUMMARIZATION_PROMPT;
+	const updatePromptText = summarizationConfig?.updatePrompt ?? DEFAULT_UPDATE_SUMMARIZATION_PROMPT;
+	const { llmParams, maxSummaryTokens: paramMaxSummaryTokens } = separateParameters(parameters);
+	const clientOptions = {
+		...provider === agentContext.provider && agentContext.clientOptions ? { ...agentContext.clientOptions } : {},
+		...llmParams
+	};
+	if (modelName != null && modelName !== "") {
+		clientOptions.model = modelName;
+		clientOptions.modelName = modelName;
+	}
+	const effectiveMaxSummaryTokens = paramMaxSummaryTokens ?? summarizationConfig?.maxSummaryTokens;
+	if (effectiveMaxSummaryTokens != null) clientOptions[getMaxOutputTokensKey(provider)] = effectiveMaxSummaryTokens;
+	return {
+		provider,
+		modelName,
+		clientOptions,
+		effectiveMaxSummaryTokens,
+		promptText,
+		updatePromptText
+	};
 }
 /** Computes the token count for a summary, preferring provider output tokens when available. */
 function computeSummaryTokenCount(summaryText, summaryUsage, tokenCounter) {
-    const providerOutputTokens = Number(summaryUsage?.output_tokens) || 0;
-    if (providerOutputTokens > 0) {
-        return providerOutputTokens + SUMMARY_WRAPPER_OVERHEAD_TOKENS;
-    }
-    if (tokenCounter) {
-        return (tokenCounter(new SystemMessage(summaryText)) +
-            SUMMARY_WRAPPER_OVERHEAD_TOKENS);
-    }
-    return 0;
+	const providerOutputTokens = Number(summaryUsage?.output_tokens) || 0;
+	if (providerOutputTokens > 0) return providerOutputTokens + SUMMARY_WRAPPER_OVERHEAD_TOKENS;
+	if (tokenCounter) return tokenCounter(new SystemMessage(summaryText)) + SUMMARY_WRAPPER_OVERHEAD_TOKENS;
+	return 0;
 }
 /** Constructs the SummaryContentBlock persisted in the run step and dispatched to events. */
 function buildSummaryBlock(params) {
-    return {
-        type: ContentTypes.SUMMARY,
-        content: [
-            {
-                type: ContentTypes.TEXT,
-                text: params.summaryText,
-            },
-        ],
-        tokenCount: params.tokenCount,
-        summaryVersion: params.summaryVersion,
-        boundary: {
-            messageId: params.stepId,
-            contentIndex: params.stepIndex,
-        },
-        model: params.modelName,
-        provider: params.provider,
-        createdAt: new Date().toISOString(),
-    };
+	return {
+		type: "summary",
+		content: [{
+			type: "text",
+			text: params.summaryText
+		}],
+		tokenCount: params.tokenCount,
+		summaryVersion: params.summaryVersion,
+		boundary: {
+			messageId: params.stepId,
+			contentIndex: params.stepIndex
+		},
+		model: params.modelName,
+		provider: params.provider,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
 }
 /**
- * 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.
- */
+* 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) {
-    if (err == null || typeof err !== 'object') {
-        return undefined;
-    }
-    const errRecord = err;
-    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.status;
-        if (typeof nested === 'number') {
-            return nested;
-        }
-    }
-    return undefined;
+	if (err == null || typeof err !== "object") return;
+	const errRecord = err;
+	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.status;
+		if (typeof nested === "number") return nested;
+	}
 }
 /**
- * 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.
- */
+* 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, provider, modelName) {
-    const providerLabel = `${provider}/${modelName ?? '(no-model)'}`;
-    const errMsg = err instanceof Error ? err.message : String(err);
-    const data = {
-        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,
-    };
+	const providerLabel = `${provider}/${modelName ?? "(no-model)"}`;
+	const errMsg = err instanceof Error ? err.message : String(err);
+	const data = {
+		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.
- */
+* 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, fallbacks) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    const list = Array.isArray(fallbacks)
-        ? fallbacks
-        : [];
-    const providerNames = list
-        .map((f) => {
-        if (f == null || typeof f !== 'object') {
-            return undefined;
-        }
-        const raw = f.provider;
-        return raw != null ? String(raw) : undefined;
-    })
-        .filter((p) => typeof p === 'string');
-    const label = providerNames.length > 0
-        ? `fallbacks=[${providerNames.join(',')}]`
-        : 'no-fallbacks';
-    const data = {
-        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,
-    };
+	const errMsg = err instanceof Error ? err.message : String(err);
+	const list = Array.isArray(fallbacks) ? fallbacks : [];
+	const providerNames = list.map((f) => {
+		if (f == null || typeof f !== "object") return;
+		const raw = f.provider;
+		return raw != null ? String(raw) : void 0;
+	}).filter((p) => typeof p === "string");
+	const label = providerNames.length > 0 ? `fallbacks=[${providerNames.join(",")}]` : "no-fallbacks";
+	const data = {
+		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.
- */
+* Runs the summarization LLM call with primary + fallback providers,
+* falling back to a metadata stub when all calls fail.
+*/
 async function executeSummarizationWithFallback(params) {
-    const { agentContext, messages, clientConfig, summarizeConfig, stepId, usePromptCache, log, } = params;
-    const priorSummaryText = agentContext.getSummaryText()?.trim() ?? '';
-    let summaryText = '';
-    let summaryUsage;
-    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,
-            clientOptions: clientConfig.clientOptions,
-            tools: agentContext.getToolsForBinding(),
-        });
-        const result = await summarizeWithCacheHit({
-            model: summarizationModel,
-            messages,
-            promptText: clientConfig.promptText,
-            updatePromptText: clientConfig.updatePromptText,
-            priorSummaryText,
-            config: summarizeConfig,
-            stepId,
-            provider: clientConfig.provider,
-            reasoningKey: agentContext.reasoningKey,
-            usePromptCache,
-            log,
-        });
-        summaryText = result.text;
-        summaryUsage = result.usage;
-    }
-    catch (primaryError) {
-        const primaryDescribed = describeProviderError(primaryError, clientConfig.provider, clientConfig.modelName);
-        log('error', `Summarization LLM call failed ${primaryDescribed.suffix}`, {
-            ...primaryDescribed.data,
-            messagesToRefineCount: messages.length,
-        });
-        const rawFallbacks = clientConfig.clientOptions?.fallbacks;
-        const fallbacks = Array.isArray(rawFallbacks) ? rawFallbacks : [];
-        if (fallbacks.length > 0) {
-            try {
-                const onChunk = createSummarizationChunkHandler({
-                    stepId,
-                    config: traceConfig(summarizeConfig, 'cache_hit_compaction'),
-                    provider: clientConfig.provider,
-                    reasoningKey: agentContext.reasoningKey,
-                });
-                const fbResult = await tryFallbackProviders({
-                    fallbacks,
-                    tools: agentContext.getToolsForBinding(),
-                    messages: [
-                        ...messages,
-                        new HumanMessage(buildSummarizationInstruction(clientConfig.promptText, clientConfig.updatePromptText, priorSummaryText)),
-                    ],
-                    config: traceConfig(summarizeConfig, 'cache_hit_compaction'),
-                    primaryError,
-                    onChunk,
-                });
-                const fbMsg = fbResult?.messages?.[0];
-                if (fbMsg) {
-                    summaryText = extractResponseText(fbMsg);
-                }
-            }
-            catch (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 ${primaryDescribed.suffix}`, {
-                ...primaryDescribed.data,
-                messagesToRefineCount: messages.length,
-            });
-            summaryText = generateMetadataStub(messages);
-        }
-    }
-    return { text: summaryText, usage: summaryUsage };
+	const { agentContext, messages, clientConfig, summarizeConfig, stepId, usePromptCache, log } = params;
+	const priorSummaryText = agentContext.getSummaryText()?.trim() ?? "";
+	let summaryText = "";
+	let summaryUsage;
+	try {
+		const result = await summarizeWithCacheHit({
+			model: initializeModel({
+				provider: clientConfig.provider,
+				clientOptions: clientConfig.clientOptions,
+				tools: agentContext.getToolsForBinding()
+			}),
+			messages,
+			promptText: clientConfig.promptText,
+			updatePromptText: clientConfig.updatePromptText,
+			priorSummaryText,
+			config: summarizeConfig,
+			stepId,
+			provider: clientConfig.provider,
+			reasoningKey: agentContext.reasoningKey,
+			usePromptCache,
+			log
+		});
+		summaryText = result.text;
+		summaryUsage = result.usage;
+	} catch (primaryError) {
+		const primaryDescribed = describeProviderError(primaryError, clientConfig.provider, clientConfig.modelName);
+		log("error", `Summarization LLM call failed ${primaryDescribed.suffix}`, {
+			...primaryDescribed.data,
+			messagesToRefineCount: messages.length
+		});
+		const rawFallbacks = clientConfig.clientOptions?.fallbacks;
+		const fallbacks = Array.isArray(rawFallbacks) ? rawFallbacks : [];
+		if (fallbacks.length > 0) try {
+			const onChunk = createSummarizationChunkHandler({
+				stepId,
+				config: traceConfig(summarizeConfig, "cache_hit_compaction"),
+				provider: clientConfig.provider,
+				reasoningKey: agentContext.reasoningKey
+			});
+			const fbMsg = (await tryFallbackProviders({
+				fallbacks,
+				tools: agentContext.getToolsForBinding(),
+				messages: [...messages, new HumanMessage(buildSummarizationInstruction(clientConfig.promptText, clientConfig.updatePromptText, priorSummaryText))],
+				config: traceConfig(summarizeConfig, "cache_hit_compaction"),
+				primaryError,
+				onChunk
+			}))?.messages?.[0];
+			if (fbMsg) summaryText = extractResponseText(fbMsg);
+		} catch (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 ${primaryDescribed.suffix}`, {
+				...primaryDescribed.data,
+				messagesToRefineCount: messages.length
+			});
+			summaryText = generateMetadataStub(messages);
+		}
+	}
+	return {
+		text: summaryText,
+		usage: summaryUsage
+	};
 }
 /** Dispatches run step completion, ON_SUMMARIZE_COMPLETE, and rebuilds token map. */
 async function dispatchCompletionEvents(params) {
-    const { graph, runnableConfig, stepId, summaryBlock, agentContext, runStep, summaryUsage, agentId, messagesAfterCount, } = params;
-    runStep.summary = summaryBlock;
-    if (summaryUsage) {
-        runStep.usage = {
-            prompt_tokens: Number(summaryUsage.input_tokens) || 0,
-            completion_tokens: Number(summaryUsage.output_tokens) || 0,
-            total_tokens: (Number(summaryUsage.input_tokens) || 0) +
-                (Number(summaryUsage.output_tokens) || 0),
-        };
-    }
-    await graph.dispatchRunStepCompleted(stepId, { type: 'summary', summary: summaryBlock }, runnableConfig);
-    if (runnableConfig) {
-        await safeDispatchCustomEvent(GraphEvents.ON_SUMMARIZE_COMPLETE, {
-            id: stepId,
-            agentId,
-            summary: summaryBlock,
-        }, runnableConfig);
-    }
-    const sessionId = graph.runId ?? '';
-    if (graph.hookRegistry?.hasHookFor('PostCompact', sessionId) === true) {
-        const threadId = runnableConfig?.configurable?.thread_id;
-        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,
-            },
-            sessionId,
-        }).catch(() => {
-            /* PostCompact is observational — swallow errors */
-        });
-    }
-    agentContext.rebuildTokenMapAfterSummarization({});
+	const { graph, runnableConfig, stepId, summaryBlock, agentContext, runStep, summaryUsage, agentId, messagesAfterCount } = params;
+	runStep.summary = summaryBlock;
+	if (summaryUsage) runStep.usage = {
+		prompt_tokens: Number(summaryUsage.input_tokens) || 0,
+		completion_tokens: Number(summaryUsage.output_tokens) || 0,
+		total_tokens: (Number(summaryUsage.input_tokens) || 0) + (Number(summaryUsage.output_tokens) || 0)
+	};
+	await graph.dispatchRunStepCompleted(stepId, {
+		type: "summary",
+		summary: summaryBlock
+	}, runnableConfig);
+	if (runnableConfig) await safeDispatchCustomEvent("on_summarize_complete", {
+		id: stepId,
+		agentId,
+		summary: summaryBlock
+	}, runnableConfig);
+	const sessionId = graph.runId ?? "";
+	if (graph.hookRegistry?.hasHookFor("PostCompact", sessionId) === true) {
+		const threadId = (runnableConfig?.configurable)?.thread_id;
+		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
+			},
+			sessionId
+		}).catch(() => {});
+	}
+	agentContext.rebuildTokenMapAfterSummarization({});
 }
-function createSummarizeNode({ agentContext, graph, generateStepId, }) {
-    return async (state, config) => {
-        const request = state.summarizationRequest;
-        if (request == null) {
-            return { summarizationRequest: undefined };
-        }
-        const maxCtx = agentContext.maxContextTokens ?? 0;
-        if (maxCtx > 0 && agentContext.instructionTokens >= maxCtx) {
-            emitAgentLog(config, 'warn', 'summarize', 'Summarization skipped, instructions exceed context budget. Reduce the number of tools or increase maxContextTokens.', {
-                instructionTokens: agentContext.instructionTokens,
-                maxContextTokens: maxCtx,
-                breakdown: agentContext.formatTokenBudgetBreakdown(),
-            }, { runId: graph.runId, agentId: request.agentId });
-            return { summarizationRequest: undefined };
-        }
-        /**
-         * Capture the original-tool-content map locally before doing the
-         * split.  We need it in three places: to restore the head for
-         * summarizer quality, to leave intact on the skip path (state is
-         * unchanged), and — critically — to carry forward the tail-relevant
-         * entries on the summarize-fired path.  Clearing it eagerly here
-         * would lose the originals for masked tool messages that the
-         * recency window keeps in the tail; a future summarization could
-         * then only summarize the masked stub instead of the full payload.
-         */
-        const originalPending = agentContext.pendingOriginalToolContent;
-        const restoredMessages = restoreOriginalToolContent(state.messages, originalPending);
-        const runnableConfig = config ?? graph.config;
-        const retainRecent = agentContext.summarizationConfig?.retainRecent;
-        const { head: messagesToRefine, tailStartIndex } = splitAtRecencyBoundary(restoredMessages, {
-            turns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS,
-            tokens: retainRecent?.tokens,
-            tokenCounter: agentContext.tokenCounter,
-        });
-        /**
-         * Use the *masked* messages for the retained tail so that any
-         * truncation prune applied to oversized ToolMessage content stays
-         * truncated in live state.  The summarizer above reads the restored
-         * (full-content) head for summary quality, but reinjecting restored
-         * tool payloads into state would defeat masking and bloat the
-         * checkpoint, forcing more expensive re-pruning on later turns.
-         * `restoreOriginalToolContent` returns an array with identical
-         * length and structure to `state.messages` (replacements only at
-         * specific indices), so the same tailStartIndex slices both arrays
-         * at the same turn boundary.
-         */
-        const messagesToRetain = state.messages.slice(tailStartIndex);
-        if (messagesToRefine.length === 0) {
-            /**
-             * Recency window covers the entire conversation — there is no
-             * older content to summarize.  Skipping prevents the model from
-             * destroying the user's most recent message (e.g. a large pasted
-             * payload on the first turn) by replacing it with a generic
-             * checkpoint summary.  Mark the trigger so the same unchanged
-             * state is not re-evaluated on the next prune cycle.
-             */
-            emitAgentLog(config, 'debug', 'summarize', 'Summarization skipped — recency window retains all messages', {
-                messagesRetained: messagesToRetain.length,
-                retainTurns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS,
-            }, { runId: graph.runId, agentId: request.agentId });
-            agentContext.markSummarizationTriggered(state.messages.length);
-            return { summarizationRequest: undefined };
-        }
-        const clientConfig = buildSummarizationClientConfig(agentContext, agentContext.summarizationConfig);
-        const stepKey = `summarize-${request.agentId}`;
-        const [stepId, stepIndex] = generateStepId(stepKey);
-        const placeholderSummary = {
-            type: ContentTypes.SUMMARY,
-            model: clientConfig.modelName,
-            provider: clientConfig.provider,
-        };
-        const runStep = {
-            stepIndex,
-            id: stepId,
-            type: StepTypes.MESSAGE_CREATION,
-            index: graph.contentData.length,
-            stepDetails: {
-                type: StepTypes.MESSAGE_CREATION,
-                message_creation: { message_id: stepId },
-            },
-            summary: placeholderSummary,
-            usage: null,
-        };
-        if (graph.runId != null && graph.runId !== '') {
-            runStep.runId = graph.runId;
-        }
-        if (graph.isMultiAgent && agentContext.agentId) {
-            runStep.agentId = agentContext.agentId;
-        }
-        await graph.dispatchRunStep(runStep, runnableConfig);
-        if (runnableConfig) {
-            await safeDispatchCustomEvent(GraphEvents.ON_SUMMARIZE_START, {
-                agentId: request.agentId,
-                provider: clientConfig.provider,
-                model: clientConfig.modelName,
-                messagesToRefineCount: messagesToRefine.length,
-                summaryVersion: agentContext.summaryVersion + 1,
-            }, runnableConfig);
-        }
-        const sessionId = graph.runId ?? '';
-        if (graph.hookRegistry?.hasHookFor('PreCompact', sessionId) === true) {
-            const threadId = runnableConfig?.configurable?.thread_id;
-            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;
-        const hasPromptCache = isSelfSummarizeModel &&
-            agentContext.clientOptions
-                ?.promptCache === true;
-        const log = (level, message, data) => {
-            emitAgentLog(runnableConfig, level, 'summarize', message, data, {
-                runId: graph.runId,
-                agentId: request.agentId,
-            });
-        };
-        log('debug', 'Summarization starting', {
-            messagesToRefineCount: messagesToRefine.length,
-            hasPriorSummary: (agentContext.getSummaryText()?.trim() ?? '') !== '',
-            summaryVersion: agentContext.summaryVersion + 1,
-            isSelfSummarize: isSelfSummarizeModel,
-            hasPromptCache,
-            provider: clientConfig.provider,
-        });
-        const summarizeConfig = config
-            ? {
-                ...config,
-                metadata: {
-                    ...config.metadata,
-                    agent_id: request.agentId,
-                    summarization_provider: clientConfig.provider,
-                    summarization_model: clientConfig.modelName,
-                },
-            }
-            : undefined;
-        const { text: rawText, usage: summaryUsage } = await executeSummarizationWithFallback({
-            agentContext,
-            messages: messagesToRefine,
-            clientConfig,
-            summarizeConfig,
-            stepId,
-            usePromptCache: isSelfSummarizeModel && hasPromptCache,
-            log,
-        });
-        if (!rawText) {
-            agentContext.markSummarizationTriggered(0);
-            if (runnableConfig) {
-                await safeDispatchCustomEvent(GraphEvents.ON_SUMMARIZE_COMPLETE, {
-                    id: stepId,
-                    agentId: request.agentId,
-                    error: 'Summarization produced empty output',
-                }, runnableConfig);
-            }
-            return { summarizationRequest: undefined };
-        }
-        const summaryText = enrichSummary(rawText, messagesToRefine);
-        const tokenCount = computeSummaryTokenCount(summaryText, summaryUsage, agentContext.tokenCounter);
-        agentContext.setSummary(summaryText, tokenCount);
-        log('info', 'Summary persisted');
-        log('debug', 'Summary details', {
-            summaryTokens: tokenCount,
-            textLength: summaryText.length,
-            messagesCompacted: messagesToRefine.length,
-            summaryVersion: agentContext.summaryVersion,
-            ...(summaryUsage != null
-                ? {
-                    input_tokens: summaryUsage.input_tokens,
-                    output_tokens: summaryUsage.output_tokens,
-                    cache_read: summaryUsage.input_token_details?.cache_read,
-                    cache_creation: summaryUsage.input_token_details?.cache_creation,
-                }
-                : {}),
-        });
-        const summaryBlock = buildSummaryBlock({
-            summaryText,
-            tokenCount,
-            stepId,
-            stepIndex: runStep.index,
-            modelName: clientConfig.modelName,
-            provider: clientConfig.provider,
-            summaryVersion: agentContext.summaryVersion,
-        });
-        await dispatchCompletionEvents({
-            graph,
-            runnableConfig,
-            stepId,
-            summaryBlock,
-            agentContext,
-            runStep,
-            summaryUsage,
-            agentId: request.agentId,
-            messagesAfterCount: messagesToRetain.length,
-        });
-        /**
-         * `dispatchCompletionEvents` calls `rebuildTokenMapAfterSummarization({})`
-         * which resets the dedupe baseline to 0 — correct under the legacy
-         * "remove-all only" shape where no messages survived, but stale once
-         * the recency window keeps a tail.  Realign the baseline to the
-         * surviving tail length so a subsequent prune cycle on the unchanged
-         * tail short-circuits via `shouldSkipSummarization` instead of
-         * looping back into another summarize call.
-         */
-        agentContext.markSummarizationTriggered(messagesToRetain.length);
-        /**
-         * Carry forward the original-content entries that correspond to the
-         * retained tail, reindexed for the post-removeAll state where tail
-         * messages start at index 0.  Without this, a future summarization
-         * that pulls these tail messages into its head would only see the
-         * masked stubs (since `setSummary` clears `pruneMessages`, and the
-         * fresh pruner at the next turn has no record of prior masks).
-         * Entries for indices < `tailStartIndex` belong to messages we just
-         * summarized — they are no longer reachable so they are dropped.
-         */
-        if (originalPending != null && originalPending.size > 0) {
-            const tailPending = new Map();
-            for (const [idx, content] of originalPending) {
-                if (idx >= tailStartIndex) {
-                    tailPending.set(idx - tailStartIndex, content);
-                }
-            }
-            agentContext.pendingOriginalToolContent =
-                tailPending.size > 0 ? tailPending : undefined;
-        }
-        else {
-            agentContext.pendingOriginalToolContent = undefined;
-        }
-        return {
-            summarizationRequest: undefined,
-            messages: messagesToRetain.length > 0
-                ? [createRemoveAllMessage(), ...messagesToRetain]
-                : [createRemoveAllMessage()],
-        };
-    };
+function createSummarizeNode({ agentContext, graph, generateStepId }) {
+	return async (state, config) => {
+		const request = state.summarizationRequest;
+		if (request == null) return { summarizationRequest: void 0 };
+		const maxCtx = agentContext.maxContextTokens ?? 0;
+		if (maxCtx > 0 && agentContext.instructionTokens >= maxCtx) {
+			emitAgentLog(config, "warn", "summarize", "Summarization skipped, instructions exceed context budget. Reduce the number of tools or increase maxContextTokens.", {
+				instructionTokens: agentContext.instructionTokens,
+				maxContextTokens: maxCtx,
+				breakdown: agentContext.formatTokenBudgetBreakdown()
+			}, {
+				runId: graph.runId,
+				agentId: request.agentId
+			});
+			return { summarizationRequest: void 0 };
+		}
+		/**
+		* Capture the original-tool-content map locally before doing the
+		* split.  We need it in three places: to restore the head for
+		* summarizer quality, to leave intact on the skip path (state is
+		* unchanged), and — critically — to carry forward the tail-relevant
+		* entries on the summarize-fired path.  Clearing it eagerly here
+		* would lose the originals for masked tool messages that the
+		* recency window keeps in the tail; a future summarization could
+		* then only summarize the masked stub instead of the full payload.
+		*/
+		const originalPending = agentContext.pendingOriginalToolContent;
+		const restoredMessages = restoreOriginalToolContent(state.messages, originalPending);
+		const runnableConfig = config ?? graph.config;
+		const retainRecent = agentContext.summarizationConfig?.retainRecent;
+		const { head: messagesToRefine, tailStartIndex } = splitAtRecencyBoundary(restoredMessages, {
+			turns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS,
+			tokens: retainRecent?.tokens,
+			tokenCounter: agentContext.tokenCounter
+		});
+		/**
+		* Use the *masked* messages for the retained tail so that any
+		* truncation prune applied to oversized ToolMessage content stays
+		* truncated in live state.  The summarizer above reads the restored
+		* (full-content) head for summary quality, but reinjecting restored
+		* tool payloads into state would defeat masking and bloat the
+		* checkpoint, forcing more expensive re-pruning on later turns.
+		* `restoreOriginalToolContent` returns an array with identical
+		* length and structure to `state.messages` (replacements only at
+		* specific indices), so the same tailStartIndex slices both arrays
+		* at the same turn boundary.
+		*/
+		const messagesToRetain = state.messages.slice(tailStartIndex);
+		if (messagesToRefine.length === 0) {
+			/**
+			* Recency window covers the entire conversation — there is no
+			* older content to summarize.  Skipping prevents the model from
+			* destroying the user's most recent message (e.g. a large pasted
+			* payload on the first turn) by replacing it with a generic
+			* checkpoint summary.  Mark the trigger so the same unchanged
+			* state is not re-evaluated on the next prune cycle.
+			*/
+			emitAgentLog(config, "debug", "summarize", "Summarization skipped — recency window retains all messages", {
+				messagesRetained: messagesToRetain.length,
+				retainTurns: retainRecent?.turns ?? DEFAULT_RETAIN_RECENT_TURNS
+			}, {
+				runId: graph.runId,
+				agentId: request.agentId
+			});
+			agentContext.markSummarizationTriggered(state.messages.length);
+			return { summarizationRequest: void 0 };
+		}
+		const clientConfig = buildSummarizationClientConfig(agentContext, agentContext.summarizationConfig);
+		const [stepId, stepIndex] = generateStepId(`summarize-${request.agentId}`);
+		const placeholderSummary = {
+			type: "summary",
+			model: clientConfig.modelName,
+			provider: clientConfig.provider
+		};
+		const runStep = {
+			stepIndex,
+			id: stepId,
+			type: "message_creation",
+			index: graph.contentData.length,
+			stepDetails: {
+				type: "message_creation",
+				message_creation: { message_id: stepId }
+			},
+			summary: placeholderSummary,
+			usage: null
+		};
+		if (graph.runId != null && graph.runId !== "") runStep.runId = graph.runId;
+		if (graph.isMultiAgent && agentContext.agentId) runStep.agentId = agentContext.agentId;
+		await graph.dispatchRunStep(runStep, runnableConfig);
+		if (runnableConfig) await safeDispatchCustomEvent("on_summarize_start", {
+			agentId: request.agentId,
+			provider: clientConfig.provider,
+			model: clientConfig.modelName,
+			messagesToRefineCount: messagesToRefine.length,
+			summaryVersion: agentContext.summaryVersion + 1
+		}, runnableConfig);
+		const sessionId = graph.runId ?? "";
+		if (graph.hookRegistry?.hasHookFor("PreCompact", sessionId) === true) {
+			const threadId = (runnableConfig?.configurable)?.thread_id;
+			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(() => {});
+		}
+		const isSelfSummarizeModel = clientConfig.provider === agentContext.provider;
+		const hasPromptCache = isSelfSummarizeModel && agentContext.clientOptions?.promptCache === true;
+		const log = (level, message, data) => {
+			emitAgentLog(runnableConfig, level, "summarize", message, data, {
+				runId: graph.runId,
+				agentId: request.agentId
+			});
+		};
+		log("debug", "Summarization starting", {
+			messagesToRefineCount: messagesToRefine.length,
+			hasPriorSummary: (agentContext.getSummaryText()?.trim() ?? "") !== "",
+			summaryVersion: agentContext.summaryVersion + 1,
+			isSelfSummarize: isSelfSummarizeModel,
+			hasPromptCache,
+			provider: clientConfig.provider
+		});
+		const { text: rawText, usage: summaryUsage } = await executeSummarizationWithFallback({
+			agentContext,
+			messages: messagesToRefine,
+			clientConfig,
+			summarizeConfig: config ? {
+				...config,
+				metadata: {
+					...config.metadata,
+					agent_id: request.agentId,
+					summarization_provider: clientConfig.provider,
+					summarization_model: clientConfig.modelName
+				}
+			} : void 0,
+			stepId,
+			usePromptCache: isSelfSummarizeModel && hasPromptCache,
+			log
+		});
+		if (!rawText) {
+			agentContext.markSummarizationTriggered(0);
+			if (runnableConfig) await safeDispatchCustomEvent("on_summarize_complete", {
+				id: stepId,
+				agentId: request.agentId,
+				error: "Summarization produced empty output"
+			}, runnableConfig);
+			return { summarizationRequest: void 0 };
+		}
+		const summaryText = enrichSummary(rawText, messagesToRefine);
+		const tokenCount = computeSummaryTokenCount(summaryText, summaryUsage, agentContext.tokenCounter);
+		agentContext.setSummary(summaryText, tokenCount);
+		log("info", "Summary persisted");
+		log("debug", "Summary details", {
+			summaryTokens: tokenCount,
+			textLength: summaryText.length,
+			messagesCompacted: messagesToRefine.length,
+			summaryVersion: agentContext.summaryVersion,
+			...summaryUsage != null ? {
+				input_tokens: summaryUsage.input_tokens,
+				output_tokens: summaryUsage.output_tokens,
+				cache_read: summaryUsage.input_token_details?.cache_read,
+				cache_creation: summaryUsage.input_token_details?.cache_creation
+			} : {}
+		});
+		await dispatchCompletionEvents({
+			graph,
+			runnableConfig,
+			stepId,
+			summaryBlock: buildSummaryBlock({
+				summaryText,
+				tokenCount,
+				stepId,
+				stepIndex: runStep.index,
+				modelName: clientConfig.modelName,
+				provider: clientConfig.provider,
+				summaryVersion: agentContext.summaryVersion
+			}),
+			agentContext,
+			runStep,
+			summaryUsage,
+			agentId: request.agentId,
+			messagesAfterCount: messagesToRetain.length
+		});
+		/**
+		* `dispatchCompletionEvents` calls `rebuildTokenMapAfterSummarization({})`
+		* which resets the dedupe baseline to 0 — correct under the legacy
+		* "remove-all only" shape where no messages survived, but stale once
+		* the recency window keeps a tail.  Realign the baseline to the
+		* surviving tail length so a subsequent prune cycle on the unchanged
+		* tail short-circuits via `shouldSkipSummarization` instead of
+		* looping back into another summarize call.
+		*/
+		agentContext.markSummarizationTriggered(messagesToRetain.length);
+		/**
+		* Carry forward the original-content entries that correspond to the
+		* retained tail, reindexed for the post-removeAll state where tail
+		* messages start at index 0.  Without this, a future summarization
+		* that pulls these tail messages into its head would only see the
+		* masked stubs (since `setSummary` clears `pruneMessages`, and the
+		* fresh pruner at the next turn has no record of prior masks).
+		* Entries for indices < `tailStartIndex` belong to messages we just
+		* summarized — they are no longer reachable so they are dropped.
+		*/
+		if (originalPending != null && originalPending.size > 0) {
+			const tailPending = /* @__PURE__ */ new Map();
+			for (const [idx, content] of originalPending) if (idx >= tailStartIndex) tailPending.set(idx - tailStartIndex, content);
+			agentContext.pendingOriginalToolContent = tailPending.size > 0 ? tailPending : void 0;
+		} else agentContext.pendingOriginalToolContent = void 0;
+		return {
+			summarizationRequest: void 0,
+			messages: messagesToRetain.length > 0 ? [createRemoveAllMessage(), ...messagesToRetain] : [createRemoveAllMessage()]
+		};
+	};
 }
 /** Extracts text from an LLM response, skipping reasoning/thinking blocks. */
 function extractResponseText(response) {
-    const { content } = response;
-    if (typeof content === 'string') {
-        return content.trim();
-    }
-    if (!Array.isArray(content)) {
-        return '';
-    }
-    const parts = [];
-    for (const block of content) {
-        if (typeof block === 'string') {
-            parts.push(block);
-            continue;
-        }
-        if (block == null || typeof block !== 'object') {
-            continue;
-        }
-        const rec = block;
-        if (rec.type === ContentTypes.THINKING ||
-            rec.type === ContentTypes.REASONING_CONTENT ||
-            rec.type === 'redacted_thinking') {
-            continue;
-        }
-        if (rec.type === 'text' && typeof rec.text === 'string') {
-            parts.push(rec.text);
-        }
-    }
-    return parts.join('').trim();
+	const { content } = response;
+	if (typeof content === "string") return content.trim();
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const block of content) {
+		if (typeof block === "string") {
+			parts.push(block);
+			continue;
+		}
+		if (block == null || typeof block !== "object") continue;
+		const rec = block;
+		if (rec.type === "thinking" || rec.type === "reasoning_content" || rec.type === "redacted_thinking") continue;
+		if (rec.type === "text" && typeof rec.text === "string") parts.push(rec.text);
+	}
+	return parts.join("").trim();
 }
 function buildSummarizationInstruction(promptText, updatePromptText, priorSummaryText) {
-    const effectivePrompt = priorSummaryText
-        ? (updatePromptText ?? promptText)
-        : promptText;
-    const parts = [effectivePrompt];
-    if (priorSummaryText) {
-        parts.push(`\n\n<previous-summary>\n${priorSummaryText}\n</previous-summary>`);
-    }
-    return parts.join('');
+	const parts = [priorSummaryText ? updatePromptText ?? promptText : promptText];
+	if (priorSummaryText) parts.push(`\n\n<previous-summary>\n${priorSummaryText}\n</previous-summary>`);
+	return parts.join("");
 }
 /** Creates an `onChunk` callback that dispatches `ON_SUMMARIZE_DELTA` events for streaming. */
-function createSummarizationChunkHandler({ stepId, config, provider, reasoningKey = 'reasoning_content', }) {
-    if (stepId == null || stepId === '' || !config) {
-        return undefined;
-    }
-    return (chunk) => {
-        const chunkAny = chunk;
-        const raw = getChunkContent({ chunk: chunkAny, provider, reasoningKey });
-        if (raw == null || (typeof raw === 'string' && !raw)) {
-            return;
-        }
-        const contentBlocks = typeof raw === 'string'
-            ? [{ type: ContentTypes.TEXT, text: raw }]
-            : raw;
-        void safeDispatchCustomEvent(GraphEvents.ON_SUMMARIZE_DELTA, {
-            id: stepId,
-            delta: {
-                summary: {
-                    type: ContentTypes.SUMMARY,
-                    content: contentBlocks,
-                    provider: String(config.metadata?.summarization_provider ?? ''),
-                    model: String(config.metadata?.summarization_model ?? ''),
-                },
-            },
-        }, config);
-    };
+function createSummarizationChunkHandler({ stepId, config, provider, reasoningKey = "reasoning_content" }) {
+	if (stepId == null || stepId === "" || !config) return;
+	return (chunk) => {
+		const raw = getChunkContent({
+			chunk,
+			provider,
+			reasoningKey
+		});
+		if (raw == null || typeof raw === "string" && !raw) return;
+		safeDispatchCustomEvent("on_summarize_delta", {
+			id: stepId,
+			delta: { summary: {
+				type: "summary",
+				content: typeof raw === "string" ? [{
+					type: "text",
+					text: raw
+				}] : raw,
+				provider: String(config.metadata?.summarization_provider ?? ""),
+				model: String(config.metadata?.summarization_model ?? "")
+			} }
+		}, config);
+	};
 }
 function traceConfig(config, stage) {
-    if (!config) {
-        return undefined;
-    }
-    return {
-        ...config,
-        runName: `summarization:${stage}`,
-        metadata: { ...config.metadata, summarization: true, stage },
-    };
+	if (!config) return;
+	return {
+		...config,
+		runName: `summarization:${stage}`,
+		metadata: {
+			...config.metadata,
+			summarization: true,
+			stage
+		}
+	};
 }
 /**
- * Cache-friendly compaction: sends raw conversation messages with the
- * summarization instruction appended as the final HumanMessage.
- * Providers with prompt caching get a cache hit on the system prompt +
- * tool definitions prefix.
- */
-async function summarizeWithCacheHit({ model, messages, promptText, updatePromptText, priorSummaryText, config, stepId, provider, reasoningKey, usePromptCache, log, }) {
-    const instruction = buildSummarizationInstruction(promptText, updatePromptText, priorSummaryText);
-    const fullMessages = [...messages, new HumanMessage(instruction)];
-    const invokeMessages = usePromptCache === true ? addCacheControl(fullMessages) : fullMessages;
-    const result = await attemptInvoke({
-        model,
-        messages: invokeMessages,
-        provider,
-        onChunk: createSummarizationChunkHandler({
-            stepId,
-            config: traceConfig(config, 'cache_hit_compaction'),
-            provider,
-            reasoningKey,
-        }),
-    }, traceConfig(config, 'cache_hit_compaction'));
-    const responseMsg = result.messages?.[0];
-    const text = responseMsg
-        ? extractResponseText(responseMsg)
-        : '';
-    let usage;
-    let usageSource = 'none';
-    if (responseMsg != null &&
-        'usage_metadata' in responseMsg &&
-        responseMsg.usage_metadata != null) {
-        usage = responseMsg.usage_metadata;
-        usageSource = 'usage_metadata';
-    }
-    else if (responseMsg != null) {
-        const respMeta = responseMsg.response_metadata;
-        const raw = respMeta?.metadata
-            ?.usage;
-        if (raw != null) {
-            usage = {
-                input_tokens: Number(raw.inputTokens) || undefined,
-                output_tokens: Number(raw.outputTokens) || undefined,
-            };
-            usageSource = 'response_metadata';
-        }
-    }
-    const cacheDetails = usage?.input_token_details;
-    log?.('debug', 'Summarization LLM usage', {
-        source: usageSource,
-        input_tokens: usage?.input_tokens,
-        output_tokens: usage?.output_tokens,
-        ...(cacheDetails?.cache_read != null || cacheDetails?.cache_creation != null
-            ? {
-                'input_token_details.cache_read': cacheDetails.cache_read,
-                'input_token_details.cache_creation': cacheDetails.cache_creation,
-            }
-            : {}),
-    });
-    return { text, usage };
+* Cache-friendly compaction: sends raw conversation messages with the
+* summarization instruction appended as the final HumanMessage.
+* Providers with prompt caching get a cache hit on the system prompt +
+* tool definitions prefix.
+*/
+async function summarizeWithCacheHit({ model, messages, promptText, updatePromptText, priorSummaryText, config, stepId, provider, reasoningKey, usePromptCache, log }) {
+	const instruction = buildSummarizationInstruction(promptText, updatePromptText, priorSummaryText);
+	const fullMessages = [...messages, new HumanMessage(instruction)];
+	const responseMsg = (await attemptInvoke({
+		model,
+		messages: usePromptCache === true ? addCacheControl(fullMessages) : fullMessages,
+		provider,
+		onChunk: createSummarizationChunkHandler({
+			stepId,
+			config: traceConfig(config, "cache_hit_compaction"),
+			provider,
+			reasoningKey
+		})
+	}, traceConfig(config, "cache_hit_compaction"))).messages?.[0];
+	const text = responseMsg ? extractResponseText(responseMsg) : "";
+	let usage;
+	let usageSource = "none";
+	if (responseMsg != null && "usage_metadata" in responseMsg && responseMsg.usage_metadata != null) {
+		usage = responseMsg.usage_metadata;
+		usageSource = "usage_metadata";
+	} else if (responseMsg != null) {
+		const raw = (responseMsg.response_metadata?.metadata)?.usage;
+		if (raw != null) {
+			usage = {
+				input_tokens: Number(raw.inputTokens) || void 0,
+				output_tokens: Number(raw.outputTokens) || void 0
+			};
+			usageSource = "response_metadata";
+		}
+	}
+	const cacheDetails = usage?.input_token_details;
+	log?.("debug", "Summarization LLM usage", {
+		source: usageSource,
+		input_tokens: usage?.input_tokens,
+		output_tokens: usage?.output_tokens,
+		...cacheDetails?.cache_read != null || cacheDetails?.cache_creation != null ? {
+			"input_token_details.cache_read": cacheDetails.cache_read,
+			"input_token_details.cache_creation": cacheDetails.cache_creation
+		} : {}
+	});
+	return {
+		text,
+		usage
+	};
 }
+//#endregion
+export { createSummarizeNode };
 
-export { DEFAULT_SUMMARIZATION_PROMPT, DEFAULT_UPDATE_SUMMARIZATION_PROMPT, createSummarizeNode };
-//# sourceMappingURL=node.mjs.map
+//# sourceMappingURL=node.mjs.map