@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/agents/pi-embedded-subscribe.js

@@ -6,7 +6,8 @@ import { buildCodeSpanIndex, createInlineCodeState } from "../markdown/code-span
 import { EmbeddedBlockChunker } from "./pi-embedded-block-chunker.js";
 import { isMessagingToolDuplicateNormalized, normalizeTextForComparison, } from "./pi-embedded-helpers.js";
 import { createEmbeddedPiSessionEventHandler } from "./pi-embedded-subscribe.handlers.js";
-import { formatReasoningMessage } from "./pi-embedded-utils.js";
+import { formatReasoningMessage, stripDowngradedToolCallText } from "./pi-embedded-utils.js";
+import { hasNonzeroUsage, normalizeUsage } from "./usage.js";
 const THINKING_TAG_SCAN_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\s*>/gi;
 const FINAL_TAG_SCAN_RE = /<\s*(\/?)\s*final\s*>/gi;
 const log = createSubsystemLogger("agent/embedded");
@@ -29,7 +30,10 @@ export function subscribeEmbeddedPiSession(params) {
         blockBuffer: "",
         // Track if a streamed chunk opened a <think> block (stateful across chunks).
         blockState: { thinking: false, final: false, inlineCode: createInlineCodeState() },
+        partialBlockState: { thinking: false, final: false, inlineCode: createInlineCodeState() },
         lastStreamedAssistant: undefined,
+        lastStreamedAssistantCleaned: undefined,
+        emittedAssistantUpdate: false,
         lastStreamedReasoning: undefined,
         lastBlockReplyText: undefined,
         assistantMessageIndex: 0,
@@ -49,6 +53,14 @@ export function subscribeEmbeddedPiSession(params) {
         pendingMessagingTexts: new Map(),
         pendingMessagingTargets: new Map(),
     };
+    const usageTotals = {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        total: 0,
+    };
+    let compactionCount = 0;
     const assistantTexts = state.assistantTexts;
     const toolMetas = state.toolMetas;
     const toolMetaById = state.toolMetaById;
@@ -59,15 +71,22 @@ export function subscribeEmbeddedPiSession(params) {
     const pendingMessagingTexts = state.pendingMessagingTexts;
     const pendingMessagingTargets = state.pendingMessagingTargets;
     const replyDirectiveAccumulator = createStreamingDirectiveAccumulator();
+    const partialReplyDirectiveAccumulator = createStreamingDirectiveAccumulator();
     const resetAssistantMessageState = (nextAssistantTextBaseline) => {
         state.deltaBuffer = "";
         state.blockBuffer = "";
         blockChunker?.reset();
         replyDirectiveAccumulator.reset();
+        partialReplyDirectiveAccumulator.reset();
         state.blockState.thinking = false;
         state.blockState.final = false;
         state.blockState.inlineCode = createInlineCodeState();
+        state.partialBlockState.thinking = false;
+        state.partialBlockState.final = false;
+        state.partialBlockState.inlineCode = createInlineCodeState();
         state.lastStreamedAssistant = undefined;
+        state.lastStreamedAssistantCleaned = undefined;
+        state.emittedAssistantUpdate = false;
         state.lastBlockReplyText = undefined;
         state.lastStreamedReasoning = undefined;
         state.lastReasoningSent = undefined;
@@ -85,21 +104,26 @@ export function subscribeEmbeddedPiSession(params) {
         state.lastAssistantTextNormalized = normalized.length > 0 ? normalized : undefined;
     };
     const shouldSkipAssistantText = (text) => {
-        if (state.lastAssistantTextMessageIndex !== state.assistantMessageIndex)
+        if (state.lastAssistantTextMessageIndex !== state.assistantMessageIndex) {
             return false;
+        }
         const trimmed = text.trimEnd();
-        if (trimmed && trimmed === state.lastAssistantTextTrimmed)
+        if (trimmed && trimmed === state.lastAssistantTextTrimmed) {
             return true;
+        }
         const normalized = normalizeTextForComparison(text);
-        if (normalized.length > 0 && normalized === state.lastAssistantTextNormalized)
+        if (normalized.length > 0 && normalized === state.lastAssistantTextNormalized) {
             return true;
+        }
         return false;
     };
     const pushAssistantText = (text) => {
-        if (!text)
+        if (!text) {
             return;
-        if (shouldSkipAssistantText(text))
+        }
+        if (shouldSkipAssistantText(text)) {
             return;
+        }
         assistantTexts.push(text);
         rememberAssistantText(text);
     };
@@ -154,8 +178,9 @@ export function subscribeEmbeddedPiSession(params) {
         ensureCompactionPromise();
     };
     const resolveCompactionRetry = () => {
-        if (state.pendingCompactionRetry <= 0)
+        if (state.pendingCompactionRetry <= 0) {
             return;
+        }
         state.pendingCompactionRetry -= 1;
         if (state.pendingCompactionRetry === 0 && !state.compactionInFlight) {
             state.compactionRetryResolve?.();
@@ -170,6 +195,40 @@ export function subscribeEmbeddedPiSession(params) {
             state.compactionRetryPromise = null;
         }
     };
+    const recordAssistantUsage = (usageLike) => {
+        const usage = normalizeUsage((usageLike ?? undefined));
+        if (!hasNonzeroUsage(usage)) {
+            return;
+        }
+        usageTotals.input += usage.input ?? 0;
+        usageTotals.output += usage.output ?? 0;
+        usageTotals.cacheRead += usage.cacheRead ?? 0;
+        usageTotals.cacheWrite += usage.cacheWrite ?? 0;
+        const usageTotal = usage.total ??
+            (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+        usageTotals.total += usageTotal;
+    };
+    const getUsageTotals = () => {
+        const hasUsage = usageTotals.input > 0 ||
+            usageTotals.output > 0 ||
+            usageTotals.cacheRead > 0 ||
+            usageTotals.cacheWrite > 0 ||
+            usageTotals.total > 0;
+        if (!hasUsage) {
+            return undefined;
+        }
+        const derivedTotal = usageTotals.input + usageTotals.output + usageTotals.cacheRead + usageTotals.cacheWrite;
+        return {
+            input: usageTotals.input || undefined,
+            output: usageTotals.output || undefined,
+            cacheRead: usageTotals.cacheRead || undefined,
+            cacheWrite: usageTotals.cacheWrite || undefined,
+            total: usageTotals.total || derivedTotal || undefined,
+        };
+    };
+    const incrementCompactionCount = () => {
+        compactionCount += 1;
+    };
     const blockChunking = params.blockReplyChunking;
     const blockChunker = blockChunking ? new EmbeddedBlockChunker(blockChunking) : null;
     // KNOWN: Provider streams are not strictly once-only or perfectly ordered.
@@ -183,21 +242,25 @@ export function subscribeEmbeddedPiSession(params) {
         : params.verboseLevel === "full";
     const formatToolOutputBlock = (text) => {
         const trimmed = text.trim();
-        if (!trimmed)
+        if (!trimmed) {
             return "(no output)";
-        if (!useMarkdown)
+        }
+        if (!useMarkdown) {
             return trimmed;
+        }
         return `\`\`\`txt\n${trimmed}\n\`\`\``;
     };
     const emitToolSummary = (toolName, meta) => {
-        if (!params.onToolResult)
+        if (!params.onToolResult) {
             return;
+        }
         const agg = formatToolAggregate(toolName, meta ? [meta] : undefined, {
             markdown: useMarkdown,
         });
         const { text: cleanedText, mediaUrls } = parseReplyDirectives(agg);
-        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0))
+        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0)) {
             return;
+        }
         try {
             void params.onToolResult({
                 text: cleanedText,
@@ -209,15 +272,17 @@ export function subscribeEmbeddedPiSession(params) {
         }
     };
     const emitToolOutput = (toolName, meta, output) => {
-        if (!params.onToolResult || !output)
+        if (!params.onToolResult || !output) {
             return;
+        }
         const agg = formatToolAggregate(toolName, meta ? [meta] : undefined, {
             markdown: useMarkdown,
         });
         const message = `${agg}\n${formatToolOutputBlock(output)}`;
         const { text: cleanedText, mediaUrls } = parseReplyDirectives(message);
-        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0))
+        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0)) {
             return;
+        }
         try {
             void params.onToolResult({
                 text: cleanedText,
@@ -229,8 +294,9 @@ export function subscribeEmbeddedPiSession(params) {
         }
     };
     const stripBlockTags = (text, state) => {
-        if (!text)
+        if (!text) {
             return text;
+        }
         const inlineStateStart = state.inlineCode ?? createInlineCodeState();
         const codeSpans = buildCodeSpanIndex(text, inlineStateStart);
         // 1. Handle <think> blocks (stateful, strip content inside)
@@ -240,8 +306,9 @@ export function subscribeEmbeddedPiSession(params) {
         let inThinking = state.thinking;
         for (const match of text.matchAll(THINKING_TAG_SCAN_RE)) {
             const idx = match.index ?? 0;
-            if (codeSpans.isInside(idx))
+            if (codeSpans.isInside(idx)) {
                 continue;
+            }
             if (!inThinking) {
                 processed += text.slice(lastIndex, idx);
             }
@@ -271,8 +338,9 @@ export function subscribeEmbeddedPiSession(params) {
         let everInFinal = state.final;
         for (const match of processed.matchAll(FINAL_TAG_SCAN_RE)) {
             const idx = match.index ?? 0;
-            if (finalCodeSpans.isInside(idx))
+            if (finalCodeSpans.isInside(idx)) {
                 continue;
+            }
             const isClose = match[1] === "/";
             if (!inFinal && !isClose) {
                 // Found <final> start tag.
@@ -309,8 +377,9 @@ export function subscribeEmbeddedPiSession(params) {
         pattern.lastIndex = 0;
         for (const match of text.matchAll(pattern)) {
             const idx = match.index ?? 0;
-            if (isInside(idx))
+            if (isInside(idx)) {
                 continue;
+            }
             output += text.slice(lastIndex, idx);
             lastIndex = idx + match[0].length;
         }
@@ -318,14 +387,18 @@ export function subscribeEmbeddedPiSession(params) {
         return output;
     };
     const emitBlockChunk = (text) => {
-        if (state.suppressBlockChunks)
+        if (state.suppressBlockChunks) {
             return;
+        }
         // Strip <think> and <final> blocks across chunk boundaries to avoid leaking reasoning.
-        const chunk = stripBlockTags(text, state.blockState).trimEnd();
-        if (!chunk)
+        // Also strip downgraded tool call text ([Tool Call: ...], [Historical context: ...], etc.).
+        const chunk = stripDowngradedToolCallText(stripBlockTags(text, state.blockState)).trimEnd();
+        if (!chunk) {
             return;
-        if (chunk === state.lastBlockReplyText)
+        }
+        if (chunk === state.lastBlockReplyText) {
             return;
+        }
         // Only check committed (successful) messaging tool texts - checking pending texts
         // is risky because if the tool fails after suppression, the user gets no response
         const normalizedChunk = normalizeTextForComparison(chunk);
@@ -333,20 +406,24 @@ export function subscribeEmbeddedPiSession(params) {
             log.debug(`Skipping block reply - already sent via messaging tool: ${chunk.slice(0, 50)}...`);
             return;
         }
-        if (shouldSkipAssistantText(chunk))
+        if (shouldSkipAssistantText(chunk)) {
             return;
+        }
         state.lastBlockReplyText = chunk;
         assistantTexts.push(chunk);
         rememberAssistantText(chunk);
-        if (!params.onBlockReply)
+        if (!params.onBlockReply) {
             return;
+        }
         const splitResult = replyDirectiveAccumulator.consume(chunk);
-        if (!splitResult)
+        if (!splitResult) {
             return;
+        }
         const { text: cleanedText, mediaUrls, audioAsVoice, replyToId, replyToTag, replyToCurrent, } = splitResult;
         // Skip empty payloads, but always emit if audioAsVoice is set (to propagate the flag)
-        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0) && !audioAsVoice)
+        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0) && !audioAsVoice) {
             return;
+        }
         void params.onBlockReply({
             text: cleanedText,
             mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
@@ -357,9 +434,11 @@ export function subscribeEmbeddedPiSession(params) {
         });
     };
     const consumeReplyDirectives = (text, options) => replyDirectiveAccumulator.consume(text, options);
+    const consumePartialReplyDirectives = (text, options) => partialReplyDirectiveAccumulator.consume(text, options);
     const flushBlockReplyBuffer = () => {
-        if (!params.onBlockReply)
+        if (!params.onBlockReply) {
             return;
+        }
         if (blockChunker?.hasBuffered()) {
             blockChunker.drain({ force: true, emit: emitBlockChunk });
             blockChunker.reset();
@@ -371,13 +450,16 @@ export function subscribeEmbeddedPiSession(params) {
         }
     };
     const emitReasoningStream = (text) => {
-        if (!state.streamReasoning || !params.onReasoningStream)
+        if (!state.streamReasoning || !params.onReasoningStream) {
             return;
+        }
         const formatted = formatReasoningMessage(text);
-        if (!formatted)
+        if (!formatted) {
             return;
-        if (formatted === state.lastStreamedReasoning)
+        }
+        if (formatted === state.lastStreamedReasoning) {
             return;
+        }
         state.lastStreamedReasoning = formatted;
         void params.onReasoningStream({
             text: formatted,
@@ -411,6 +493,7 @@ export function subscribeEmbeddedPiSession(params) {
         flushBlockReplyBuffer,
         emitReasoningStream,
         consumeReplyDirectives,
+        consumePartialReplyDirectives,
         resetAssistantMessageState,
         resetForCompactionRetry,
         finalizeAssistantTexts,
@@ -419,6 +502,10 @@ export function subscribeEmbeddedPiSession(params) {
         noteCompactionRetry,
         resolveCompactionRetry,
         maybeResolveCompactionWait,
+        recordAssistantUsage,
+        incrementCompactionCount,
+        getUsageTotals,
+        getCompactionCount: () => compactionCount,
     };
     const unsubscribe = params.session.subscribe(createEmbeddedPiSessionEventHandler(ctx));
     return {
@@ -433,6 +520,8 @@ export function subscribeEmbeddedPiSession(params) {
         // which is generated AFTER the tool sends the actual answer.
         didSendViaMessagingTool: () => messagingToolSentTexts.length > 0,
         getLastToolError: () => (state.lastToolError ? { ...state.lastToolError } : undefined),
+        getUsageTotals,
+        getCompactionCount: () => compactionCount,
         waitForCompactionRetry: () => {
             if (state.compactionInFlight || state.pendingCompactionRetry > 0) {
                 ensureCompactionPromise();

package/dist/agents/pi-tools.js

@@ -10,7 +10,7 @@ import { wrapToolWithBeforeToolCallHook } from "./pi-tools.before-tool-call.js";
 import { filterToolsByPolicy, isToolAllowedByPolicies, resolveEffectiveToolPolicy, resolveGroupToolPolicy, resolveSubagentToolPolicy, } from "./pi-tools.policy.js";
 import { assertRequiredParams, CLAUDE_PARAM_GROUPS, createPoolbotReadTool, createSandboxedEditTool, createSandboxedReadTool, createSandboxedWriteTool, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization, } from "./pi-tools.read.js";
 import { cleanToolSchemaForGemini, normalizeToolParameters } from "./pi-tools.schema.js";
-import { buildPluginToolGroups, collectExplicitAllowlist, expandPolicyWithPluginGroups, normalizeToolName, resolveToolProfilePolicy, stripPluginOnlyAllowlist, } from "./tool-policy.js";
+import { buildPluginToolGroups, collectExplicitAllowlist, expandPolicyWithPluginGroups, normalizeToolName, resolveToolProfilePolicy, stripPluginOnlyAllowlist, applyOwnerOnlyToolPolicy, } from "./tool-policy.js";
 import { getPluginToolMeta } from "../plugins/tools.js";
 import { logWarn } from "../logger.js";
 function isOpenAIProvider(provider) {
@@ -227,15 +227,20 @@ export function createPoolbotCodingTools(options) {
             replyToMode: options?.replyToMode,
             hasRepliedRef: options?.hasRepliedRef,
             modelHasVision: options?.modelHasVision,
+            requireExplicitMessageTarget: options?.requireExplicitMessageTarget,
+            disableMessageTool: options?.disableMessageTool,
             requesterAgentIdOverride: agentId,
         }),
     ];
-    const coreToolNames = new Set(tools
+    // Security: treat unknown/undefined as unauthorized (opt-in, not opt-out)
+    const senderIsOwner = options?.senderIsOwner === true;
+    const toolsByAuthorization = applyOwnerOnlyToolPolicy(tools, senderIsOwner);
+    const coreToolNames = new Set(toolsByAuthorization
         .filter((tool) => !getPluginToolMeta(tool))
         .map((tool) => normalizeToolName(tool.name))
         .filter(Boolean));
     const pluginGroups = buildPluginToolGroups({
-        tools,
+        tools: toolsByAuthorization,
         toolMeta: (tool) => getPluginToolMeta(tool),
     });
     const resolvePolicy = (policy, label) => {
@@ -259,8 +264,8 @@ export function createPoolbotCodingTools(options) {
     const sandboxPolicyExpanded = expandPolicyWithPluginGroups(sandbox?.tools, pluginGroups);
     const subagentPolicyExpanded = expandPolicyWithPluginGroups(subagentPolicy, pluginGroups);
     const toolsFiltered = profilePolicyExpanded
-        ? filterToolsByPolicy(tools, profilePolicyExpanded)
-        : tools;
+        ? filterToolsByPolicy(toolsByAuthorization, profilePolicyExpanded)
+        : toolsByAuthorization;
     const providerProfileFiltered = providerProfileExpanded
         ? filterToolsByPolicy(toolsFiltered, providerProfileExpanded)
         : toolsFiltered;

package/dist/agents/poolbot-tools.js

@@ -32,6 +32,20 @@ export function createPoolBotTools(options) {
         config: options?.config,
         sandboxed: options?.sandboxed,
     });
+    const messageTool = options?.disableMessageTool
+        ? null
+        : createMessageTool({
+            agentAccountId: options?.agentAccountId,
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+            currentChannelId: options?.currentChannelId,
+            currentChannelProvider: options?.agentChannel,
+            currentThreadTs: options?.currentThreadTs,
+            replyToMode: options?.replyToMode,
+            hasRepliedRef: options?.hasRepliedRef,
+            sandboxRoot: options?.sandboxRoot,
+            requireExplicitTarget: options?.requireExplicitMessageTarget,
+        });
     const tools = [
         createBrowserTool({
             sandboxBridgeUrl: options?.sandboxBrowserBridgeUrl,
@@ -45,16 +59,7 @@ export function createPoolBotTools(options) {
         createCronTool({
             agentSessionKey: options?.agentSessionKey,
         }),
-        createMessageTool({
-            agentAccountId: options?.agentAccountId,
-            agentSessionKey: options?.agentSessionKey,
-            config: options?.config,
-            currentChannelId: options?.currentChannelId,
-            currentChannelProvider: options?.agentChannel,
-            currentThreadTs: options?.currentThreadTs,
-            replyToMode: options?.replyToMode,
-            hasRepliedRef: options?.hasRepliedRef,
-        }),
+        ...(messageTool ? [messageTool] : []),
         createTtsTool({
             agentChannel: options?.agentChannel,
             config: options?.config,

package/dist/agents/sandbox-paths.js

@@ -1,6 +1,9 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
+const HTTP_URL_RE = /^https?:\/\//i;
+const DATA_URL_RE = /^data:/i;
 const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 function normalizeUnicodeSpaces(str) {
     return str.replace(UNICODE_SPACES, " ");
@@ -38,6 +41,34 @@ export async function assertSandboxPath(params) {
     await assertNoSymlink(resolved.relative, path.resolve(params.root));
     return resolved;
 }
+export function assertMediaNotDataUrl(media) {
+    const raw = media.trim();
+    if (DATA_URL_RE.test(raw)) {
+        throw new Error("data: URLs are not supported for media. Use buffer instead.");
+    }
+}
+export async function resolveSandboxedMediaSource(params) {
+    const raw = params.media.trim();
+    if (!raw)
+        return raw;
+    if (HTTP_URL_RE.test(raw))
+        return raw;
+    let candidate = raw;
+    if (/^file:\/\//i.test(candidate)) {
+        try {
+            candidate = fileURLToPath(candidate);
+        }
+        catch {
+            throw new Error(`Invalid file:// URL for sandboxed media: ${raw}`);
+        }
+    }
+    const resolved = await assertSandboxPath({
+        filePath: candidate,
+        cwd: params.sandboxRoot,
+        root: params.sandboxRoot,
+    });
+    return resolved.resolved;
+}
 async function assertNoSymlink(relative, root) {
     if (!relative)
         return;

package/dist/agents/session-tool-result-guard.js

@@ -1,16 +1,76 @@
-import { makeMissingToolResult } from "./session-transcript-repair.js";
 import { emitSessionTranscriptUpdate } from "../sessions/transcript-events.js";
+import { HARD_MAX_TOOL_RESULT_CHARS } from "./pi-embedded-runner/tool-result-truncation.js";
+import { makeMissingToolResult, sanitizeToolCallInputs } from "./session-transcript-repair.js";
+const GUARD_TRUNCATION_SUFFIX = "\n\n⚠️ [Content truncated during persistence — original exceeded size limit. " +
+    "Use offset/limit parameters or request specific sections for large content.]";
+/**
+ * Truncate oversized text content blocks in a tool result message.
+ * Returns the original message if under the limit, or a new message with
+ * truncated text blocks otherwise.
+ */
+function capToolResultSize(msg) {
+    const role = msg.role;
+    if (role !== "toolResult") {
+        return msg;
+    }
+    const content = msg.content;
+    if (!Array.isArray(content)) {
+        return msg;
+    }
+    // Calculate total text size
+    let totalTextChars = 0;
+    for (const block of content) {
+        if (block && typeof block === "object" && block.type === "text") {
+            const text = block.text;
+            if (typeof text === "string") {
+                totalTextChars += text.length;
+            }
+        }
+    }
+    if (totalTextChars <= HARD_MAX_TOOL_RESULT_CHARS) {
+        return msg;
+    }
+    // Truncate proportionally
+    const newContent = content.map((block) => {
+        if (!block || typeof block !== "object" || block.type !== "text") {
+            return block;
+        }
+        const textBlock = block;
+        if (typeof textBlock.text !== "string") {
+            return block;
+        }
+        const blockShare = textBlock.text.length / totalTextChars;
+        const blockBudget = Math.max(2_000, Math.floor(HARD_MAX_TOOL_RESULT_CHARS * blockShare) - GUARD_TRUNCATION_SUFFIX.length);
+        if (textBlock.text.length <= blockBudget) {
+            return block;
+        }
+        // Try to cut at a newline boundary
+        let cutPoint = blockBudget;
+        const lastNewline = textBlock.text.lastIndexOf("\n", blockBudget);
+        if (lastNewline > blockBudget * 0.8) {
+            cutPoint = lastNewline;
+        }
+        return {
+            ...textBlock,
+            text: textBlock.text.slice(0, cutPoint) + GUARD_TRUNCATION_SUFFIX,
+        };
+    });
+    return { ...msg, content: newContent };
+}
 function extractAssistantToolCalls(msg) {
     const content = msg.content;
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return [];
+    }
     const toolCalls = [];
     for (const block of content) {
-        if (!block || typeof block !== "object")
+        if (!block || typeof block !== "object") {
             continue;
+        }
         const rec = block;
-        if (typeof rec.id !== "string" || !rec.id)
+        if (typeof rec.id !== "string" || !rec.id) {
             continue;
+        }
         if (rec.type === "toolCall" || rec.type === "toolUse" || rec.type === "functionCall") {
             toolCalls.push({
                 id: rec.id,
@@ -22,11 +82,13 @@ function extractAssistantToolCalls(msg) {
 }
 function extractToolResultId(msg) {
     const toolCallId = msg.toolCallId;
-    if (typeof toolCallId === "string" && toolCallId)
+    if (typeof toolCallId === "string" && toolCallId) {
         return toolCallId;
+    }
     const toolUseId = msg.toolUseId;
-    if (typeof toolUseId === "string" && toolUseId)
+    if (typeof toolUseId === "string" && toolUseId) {
         return toolUseId;
+    }
     return null;
 }
 export function installSessionToolResultGuard(sessionManager, opts) {
@@ -38,8 +100,9 @@ export function installSessionToolResultGuard(sessionManager, opts) {
     };
     const allowSyntheticToolResults = opts?.allowSyntheticToolResults ?? true;
     const flushPendingToolResults = () => {
-        if (pending.size === 0)
+        if (pending.size === 0) {
             return;
+        }
         if (allowSyntheticToolResults) {
             for (const [id, name] of pending.entries()) {
                 const synthetic = makeMissingToolResult({ toolCallId: id, toolName: name });
@@ -53,24 +116,40 @@ export function installSessionToolResultGuard(sessionManager, opts) {
         pending.clear();
     };
     const guardedAppend = (message) => {
+        let nextMessage = message;
         const role = message.role;
-        if (role === "toolResult") {
-            const id = extractToolResultId(message);
+        if (role === "assistant") {
+            const sanitized = sanitizeToolCallInputs([message]);
+            if (sanitized.length === 0) {
+                if (allowSyntheticToolResults && pending.size > 0) {
+                    flushPendingToolResults();
+                }
+                return undefined;
+            }
+            nextMessage = sanitized[0];
+        }
+        const nextRole = nextMessage.role;
+        if (nextRole === "toolResult") {
+            const id = extractToolResultId(nextMessage);
             const toolName = id ? pending.get(id) : undefined;
-            if (id)
+            if (id) {
                 pending.delete(id);
-            return originalAppend(persistToolResult(message, {
+            }
+            // Apply hard size cap before persistence to prevent oversized tool results
+            // from consuming the entire context window on subsequent LLM calls.
+            const capped = capToolResultSize(nextMessage);
+            return originalAppend(persistToolResult(capped, {
                 toolCallId: id ?? undefined,
                 toolName,
                 isSynthetic: false,
             }));
         }
-        const toolCalls = role === "assistant"
-            ? extractAssistantToolCalls(message)
+        const toolCalls = nextRole === "assistant"
+            ? extractAssistantToolCalls(nextMessage)
             : [];
         if (allowSyntheticToolResults) {
             // If previous tool calls are still pending, flush before non-tool results.
-            if (pending.size > 0 && (toolCalls.length === 0 || role !== "assistant")) {
+            if (pending.size > 0 && (toolCalls.length === 0 || nextRole !== "assistant")) {
                 flushPendingToolResults();
             }
             // If new tool calls arrive while older ones are pending, flush the old ones first.
@@ -78,7 +157,7 @@ export function installSessionToolResultGuard(sessionManager, opts) {
                 flushPendingToolResults();
             }
         }
-        const result = originalAppend(message);
+        const result = originalAppend(nextMessage);
         const sessionFile = sessionManager.getSessionFile?.();
         if (sessionFile) {
             emitSessionTranscriptUpdate(sessionFile);