@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/agents/pi-embedded-runner/run.js

@@ -43,6 +43,16 @@ const createUsageAccumulator = () => ({
 function createCompactionDiagId() {
     return `ovf-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
+// Defensive guard for the outer run loop across all retry branches.
+const BASE_RUN_RETRY_ITERATIONS = 24;
+const RUN_RETRY_ITERATIONS_PER_PROFILE = 8;
+const MIN_RUN_RETRY_ITERATIONS = 32;
+const MAX_RUN_RETRY_ITERATIONS = 160;
+function resolveMaxRunRetryIterations(profileCandidateCount) {
+    const scaled = BASE_RUN_RETRY_ITERATIONS +
+        Math.max(1, profileCandidateCount) * RUN_RETRY_ITERATIONS_PER_PROFILE;
+    return Math.min(MAX_RUN_RETRY_ITERATIONS, Math.max(MIN_RUN_RETRY_ITERATIONS, scaled));
+}
 const hasUsageValues = (usage) => !!usage &&
     [usage.input, usage.output, usage.cacheRead, usage.cacheWrite, usage.total].some((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
 const mergeUsageIntoAccumulator = (target, usage) => {
@@ -89,6 +99,12 @@ const toNormalizedUsage = (usage) => {
         total: lastPromptTokens + usage.output || undefined,
     };
 };
+function resolveActiveErrorContext(params) {
+    return {
+        provider: params.lastAssistant?.provider ?? params.provider,
+        model: params.lastAssistant?.model ?? params.model,
+    };
+}
 export async function runEmbeddedPiAgent(params) {
     const sessionLane = resolveSessionLane(params.sessionKey?.trim() || params.sessionId);
     const globalLane = resolveGlobalLane(params.lane);
@@ -129,6 +145,7 @@ export async function runEmbeddedPiAgent(params) {
         // Legacy compatibility: before_agent_start is also checked for override
         // fields if present. New hook takes precedence when both are set.
         let modelResolveOverride;
+        let legacyBeforeAgentStartResult;
         const hookRunner = getGlobalHookRunner();
         const hookCtx = {
             agentId: workspaceResolution.agentId,
@@ -147,10 +164,11 @@ export async function runEmbeddedPiAgent(params) {
         }
         if (hookRunner?.hasHooks("before_agent_start")) {
             try {
-                const legacyResult = await hookRunner.runBeforeAgentStart({ prompt: params.prompt }, hookCtx);
+                legacyBeforeAgentStartResult = await hookRunner.runBeforeAgentStart({ prompt: params.prompt }, hookCtx);
                 modelResolveOverride = {
-                    providerOverride: modelResolveOverride?.providerOverride ?? legacyResult?.providerOverride,
-                    modelOverride: modelResolveOverride?.modelOverride ?? legacyResult?.modelOverride,
+                    providerOverride: modelResolveOverride?.providerOverride ??
+                        legacyBeforeAgentStartResult?.providerOverride,
+                    modelOverride: modelResolveOverride?.modelOverride ?? legacyBeforeAgentStartResult?.modelOverride,
                 };
             }
             catch (hookErr) {
@@ -167,7 +185,11 @@ export async function runEmbeddedPiAgent(params) {
         }
         const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
         if (!model) {
-            throw new Error(error ?? `Unknown model: ${provider}/${modelId}`);
+            throw new FailoverError(error ?? `Unknown model: ${provider}/${modelId}`, {
+                reason: "model_not_found",
+                provider,
+                model: modelId,
+            });
         }
         const ctxInfo = resolveContextWindowInfo({
             cfg: params.config,
@@ -335,13 +357,41 @@ export async function runEmbeddedPiAgent(params) {
             }
         }
         const MAX_OVERFLOW_COMPACTION_ATTEMPTS = 3;
+        const MAX_RUN_LOOP_ITERATIONS = resolveMaxRunRetryIterations(profileCandidates.length);
         let overflowCompactionAttempts = 0;
         let toolResultTruncationAttempted = false;
         const usageAccumulator = createUsageAccumulator();
         let lastRunPromptUsage;
         let autoCompactionCount = 0;
+        let runLoopIterations = 0;
         try {
             while (true) {
+                if (runLoopIterations >= MAX_RUN_LOOP_ITERATIONS) {
+                    const message = `Exceeded retry limit after ${runLoopIterations} attempts ` +
+                        `(max=${MAX_RUN_LOOP_ITERATIONS}).`;
+                    log.error(`[run-retry-limit] sessionKey=${params.sessionKey ?? params.sessionId} ` +
+                        `provider=${provider}/${modelId} attempts=${runLoopIterations} ` +
+                        `maxAttempts=${MAX_RUN_LOOP_ITERATIONS}`);
+                    return {
+                        payloads: [
+                            {
+                                text: "Request failed after repeated internal retries. " +
+                                    "Please try again, or use /new to start a fresh session.",
+                                isError: true,
+                            },
+                        ],
+                        meta: {
+                            durationMs: Date.now() - started,
+                            agentMeta: {
+                                sessionId: params.sessionId,
+                                provider,
+                                model: model.id,
+                            },
+                            error: { kind: "retry_limit", message },
+                        },
+                    };
+                }
+                runLoopIterations += 1;
                 attemptedThinking.add(thinkLevel);
                 await fs.mkdir(resolvedWorkspace, { recursive: true });
                 const prompt = provider === "anthropic" ? scrubAnthropicRefusalMagic(params.prompt) : params.prompt;
@@ -376,6 +426,7 @@ export async function runEmbeddedPiAgent(params) {
                     authStorage,
                     modelRegistry,
                     agentId: workspaceResolution.agentId,
+                    legacyBeforeAgentStartResult,
                     thinkLevel,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
@@ -413,11 +464,17 @@ export async function runEmbeddedPiAgent(params) {
                 const lastTurnTotal = lastAssistantUsage?.total ?? attemptUsage?.total;
                 const attemptCompactionCount = Math.max(0, attempt.compactionCount ?? 0);
                 autoCompactionCount += attemptCompactionCount;
+                const activeErrorContext = resolveActiveErrorContext({
+                    lastAssistant,
+                    provider,
+                    model: modelId,
+                });
                 const formattedAssistantErrorText = lastAssistant
                     ? formatAssistantErrorText(lastAssistant, {
                         cfg: params.config,
                         sessionKey: params.sessionKey ?? params.sessionId,
-                        provider,
+                        provider: activeErrorContext.provider,
+                        model: activeErrorContext.model,
                     })
                     : undefined;
                 const assistantErrorText = lastAssistant?.stopReason === "error"
@@ -533,8 +590,8 @@ export async function runEmbeddedPiAgent(params) {
                             });
                             if (truncResult.truncated) {
                                 log.info(`[context-overflow-recovery] Truncated ${truncResult.truncatedCount} tool result(s); retrying prompt`);
-                                // Session is now smaller; allow compaction retries again.
-                                overflowCompactionAttempts = 0;
+                                // Do NOT reset overflowCompactionAttempts here — the global cap must remain
+                                // enforced across all iterations to prevent unbounded compaction cycles (OC-65).
                                 continue;
                             }
                             log.warn(`[context-overflow-recovery] Tool result truncation did not help: ${truncResult.reason ?? "unknown"}`);
@@ -725,7 +782,8 @@ export async function runEmbeddedPiAgent(params) {
                             ? formatAssistantErrorText(lastAssistant, {
                                 cfg: params.config,
                                 sessionKey: params.sessionKey ?? params.sessionId,
-                                provider,
+                                provider: activeErrorContext.provider,
+                                model: activeErrorContext.model,
                             })
                             : undefined) ||
                             lastAssistant?.errorMessage?.trim() ||
@@ -734,7 +792,7 @@ export async function runEmbeddedPiAgent(params) {
                                 : rateLimitFailure
                                     ? "LLM request rate limited."
                                     : billingFailure
-                                        ? formatBillingErrorMessage(provider)
+                                        ? formatBillingErrorMessage(activeErrorContext.provider, activeErrorContext.model)
                                         : authFailure
                                             ? "LLM request unauthorized."
                                             : "LLM request failed.");
@@ -742,8 +800,8 @@ export async function runEmbeddedPiAgent(params) {
                             (isTimeoutErrorMessage(message) ? 408 : undefined);
                         throw new FailoverError(message, {
                             reason: assistantFailoverReason ?? "unknown",
-                            provider,
-                            model: modelId,
+                            provider: activeErrorContext.provider,
+                            model: activeErrorContext.model,
                             profileId: lastProfileId,
                             status,
                         });
@@ -776,7 +834,8 @@ export async function runEmbeddedPiAgent(params) {
                     lastToolError: attempt.lastToolError,
                     config: params.config,
                     sessionKey: params.sessionKey ?? params.sessionId,
-                    provider,
+                    provider: activeErrorContext.provider,
+                    model: activeErrorContext.model,
                     verboseLevel: params.verboseLevel,
                     reasoningLevel: params.reasoningLevel,
                     toolResultFormat: resolvedToolResultFormat,

package/dist/agents/pi-embedded-runner/run.overflow-compaction.mocks.shared.js

@@ -1,4 +1,13 @@
 import { vi } from "vitest";
+export const mockedGlobalHookRunner = {
+    hasHooks: vi.fn((_hookName) => false),
+    runBeforeAgentStart: vi.fn(async (_event, _ctx) => undefined),
+    runBeforePromptBuild: vi.fn(async (_event, _ctx) => undefined),
+    runBeforeModelResolve: vi.fn(async (_event, _ctx) => undefined),
+};
+vi.mock("../../plugins/hook-runner-global.js", () => ({
+    getGlobalHookRunner: vi.fn(() => mockedGlobalHookRunner),
+}));
 vi.mock("../auth-profiles.js", () => ({
     isProfileInCooldown: vi.fn(() => false),
     markAuthProfileFailure: vi.fn(async () => { }),
@@ -78,7 +87,7 @@ vi.mock("../model-auth.js", () => ({
     resolveAuthProfileOrder: vi.fn(() => []),
 }));
 vi.mock("../models-config.js", () => ({
-    ensurePoolbotModelsJson: vi.fn(async () => { }),
+    ensurePoolBotModelsJson: vi.fn(async () => { }),
 }));
 vi.mock("../context-window-guard.js", () => ({
     CONTEXT_WINDOW_HARD_MIN_TOKENS: 1000,
@@ -101,7 +110,7 @@ vi.mock("../../utils/message-channel.js", () => ({
     isMarkdownCapableMessageChannel: vi.fn(() => true),
 }));
 vi.mock("../agent-paths.js", () => ({
-    resolvePoolbotAgentDir: vi.fn(() => "/tmp/agent-dir"),
+    resolvePoolBotAgentDir: vi.fn(() => "/tmp/agent-dir"),
 }));
 vi.mock("../defaults.js", () => ({
     DEFAULT_CONTEXT_TOKENS: 200000,

package/dist/agents/pi-embedded-runner/session-manager-cache.js

@@ -5,8 +5,7 @@ const SESSION_MANAGER_CACHE = new Map();
 const DEFAULT_SESSION_MANAGER_TTL_MS = 45_000; // 45 seconds
 function getSessionManagerTtl() {
     return resolveCacheTtlMs({
-        envValue: process.env.POOLBOT_SESSION_MANAGER_CACHE_TTL_MS ||
-            process.env.CLAWDBOT_SESSION_MANAGER_CACHE_TTL_MS,
+        envValue: process.env.POOLBOT_SESSION_MANAGER_CACHE_TTL_MS,
         defaultTtlMs: DEFAULT_SESSION_MANAGER_TTL_MS,
     });
 }
@@ -14,8 +13,9 @@ function isSessionManagerCacheEnabled() {
     return isCacheEnabled(getSessionManagerTtl());
 }
 export function trackSessionManagerAccess(sessionFile) {
-    if (!isSessionManagerCacheEnabled())
+    if (!isSessionManagerCacheEnabled()) {
         return;
+    }
     const now = Date.now();
     SESSION_MANAGER_CACHE.set(sessionFile, {
         sessionFile,
@@ -23,20 +23,24 @@ export function trackSessionManagerAccess(sessionFile) {
     });
 }
 function isSessionManagerCached(sessionFile) {
-    if (!isSessionManagerCacheEnabled())
+    if (!isSessionManagerCacheEnabled()) {
         return false;
+    }
     const entry = SESSION_MANAGER_CACHE.get(sessionFile);
-    if (!entry)
+    if (!entry) {
         return false;
+    }
     const now = Date.now();
     const ttl = getSessionManagerTtl();
     return now - entry.loadedAt <= ttl;
 }
 export async function prewarmSessionFile(sessionFile) {
-    if (!isSessionManagerCacheEnabled())
+    if (!isSessionManagerCacheEnabled()) {
         return;
-    if (isSessionManagerCached(sessionFile))
+    }
+    if (isSessionManagerCached(sessionFile)) {
         return;
+    }
     try {
         // Read a small chunk to encourage OS page cache warmup.
         const handle = await fs.open(sessionFile, "r");

package/dist/agents/pi-embedded-runner/system-prompt.js

@@ -7,6 +7,8 @@ export function buildEmbeddedSystemPrompt(params) {
         reasoningLevel: params.reasoningLevel,
         extraSystemPrompt: params.extraSystemPrompt,
         ownerNumbers: params.ownerNumbers,
+        ownerDisplay: params.ownerDisplay,
+        ownerDisplaySecret: params.ownerDisplaySecret,
         reasoningTagHint: params.reasoningTagHint,
         heartbeatPrompt: params.heartbeatPrompt,
         skillsPrompt: params.skillsPrompt,

package/dist/agents/pi-embedded-runner/thinking.js

@@ -0,0 +1,42 @@
+/**
+ * Strip all `type: "thinking"` content blocks from assistant messages.
+ *
+ * If an assistant message becomes empty after stripping, it is replaced with
+ * a synthetic `{ type: "text", text: "" }` block to preserve turn structure
+ * (some providers require strict user/assistant alternation).
+ *
+ * Returns the original array reference when nothing was changed (callers can
+ * use reference equality to skip downstream work).
+ */
+export function dropThinkingBlocks(messages) {
+    let touched = false;
+    const out = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== "object" || msg.role !== "assistant") {
+            out.push(msg);
+            continue;
+        }
+        if (!Array.isArray(msg.content)) {
+            out.push(msg);
+            continue;
+        }
+        const nextContent = [];
+        let changed = false;
+        for (const block of msg.content) {
+            if (block && typeof block === "object" && block.type === "thinking") {
+                touched = true;
+                changed = true;
+                continue;
+            }
+            nextContent.push(block);
+        }
+        if (!changed) {
+            out.push(msg);
+            continue;
+        }
+        // Preserve the assistant turn even if all blocks were thinking-only.
+        const content = nextContent.length > 0 ? nextContent : [{ type: "text", text: "" }];
+        out.push({ ...msg, content });
+    }
+    return touched ? out : messages;
+}

package/dist/agents/pi-embedded-runner/tool-name-allowlist.js

@@ -0,0 +1,19 @@
+function addName(names, value) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const trimmed = value.trim();
+    if (trimmed) {
+        names.add(trimmed);
+    }
+}
+export function collectAllowedToolNames(params) {
+    const names = new Set();
+    for (const tool of params.tools) {
+        addName(names, tool.name);
+    }
+    for (const tool of params.clientTools ?? []) {
+        addName(names, tool.function?.name);
+    }
+    return names;
+}

package/dist/agents/pi-embedded-runner/utils.js

@@ -1,20 +1,17 @@
 export function mapThinkingLevel(level) {
-    // pi-agent-core supports "xhigh"; Poolbot enables it for specific models.
-    if (!level)
+    // pi-agent-core supports "xhigh"; Pool Bot enables it for specific models.
+    if (!level) {
         return "off";
+    }
     return level;
 }
-export function resolveExecToolDefaults(config) {
-    const tools = config?.tools;
-    if (!tools?.exec)
-        return undefined;
-    return tools.exec;
-}
 export function describeUnknownError(error) {
-    if (error instanceof Error)
+    if (error instanceof Error) {
         return error.message;
-    if (typeof error === "string")
+    }
+    if (typeof error === "string") {
         return error;
+    }
     try {
         const serialized = JSON.stringify(error);
         return serialized ?? "Unknown error";

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

@@ -1,5 +1,8 @@
 import { emitAgentEvent } from "../infra/agent-events.js";
 import { createInlineCodeState } from "../markdown/code-spans.js";
+import { formatAssistantErrorText } from "./pi-embedded-helpers.js";
+import { isAssistantMessage } from "./pi-embedded-utils.js";
+export { handleAutoCompactionEnd, handleAutoCompactionStart, } from "./pi-embedded-subscribe.handlers.compaction.js";
 export function handleAgentStart(ctx) {
     ctx.log.debug(`embedded run agent start: runId=${ctx.params.runId}`);
     emitAgentEvent({
@@ -15,65 +18,51 @@ export function handleAgentStart(ctx) {
         data: { phase: "start" },
     });
 }
-export function handleAutoCompactionStart(ctx) {
-    ctx.state.compactionInFlight = true;
-    ctx.ensureCompactionPromise();
-    ctx.log.debug(`embedded run compaction start: runId=${ctx.params.runId}`);
-    emitAgentEvent({
-        runId: ctx.params.runId,
-        stream: "compaction",
-        data: { phase: "start" },
-    });
-    void ctx.params.onAgentEvent?.({
-        stream: "compaction",
-        data: { phase: "start" },
-    });
-}
-export function handleAutoCompactionEnd(ctx, evt) {
-    ctx.state.compactionInFlight = false;
-    const willRetry = Boolean(evt.willRetry);
-    if (willRetry) {
-        ctx.noteCompactionRetry();
-        ctx.resetForCompactionRetry();
-        ctx.log.debug(`embedded run compaction retry: runId=${ctx.params.runId}`);
+export function handleAgentEnd(ctx) {
+    const lastAssistant = ctx.state.lastAssistant;
+    const isError = isAssistantMessage(lastAssistant) && lastAssistant.stopReason === "error";
+    if (isError && lastAssistant) {
+        const friendlyError = formatAssistantErrorText(lastAssistant, {
+            cfg: ctx.params.config,
+            sessionKey: ctx.params.sessionKey,
+            provider: lastAssistant.provider,
+            model: lastAssistant.model,
+        });
+        const errorText = (friendlyError || lastAssistant.errorMessage || "LLM request failed.").trim();
+        ctx.log.warn(`embedded run agent end: runId=${ctx.params.runId} isError=true error=${errorText}`);
+        emitAgentEvent({
+            runId: ctx.params.runId,
+            stream: "lifecycle",
+            data: {
+                phase: "error",
+                error: errorText,
+                endedAt: Date.now(),
+            },
+        });
+        void ctx.params.onAgentEvent?.({
+            stream: "lifecycle",
+            data: {
+                phase: "error",
+                error: errorText,
+            },
+        });
     }
     else {
-        ctx.maybeResolveCompactionWait();
-    }
-    emitAgentEvent({
-        runId: ctx.params.runId,
-        stream: "compaction",
-        data: { phase: "end", willRetry },
-    });
-    void ctx.params.onAgentEvent?.({
-        stream: "compaction",
-        data: { phase: "end", willRetry },
-    });
-}
-export function handleAgentEnd(ctx) {
-    ctx.log.debug(`embedded run agent end: runId=${ctx.params.runId}`);
-    emitAgentEvent({
-        runId: ctx.params.runId,
-        stream: "lifecycle",
-        data: {
-            phase: "end",
-            endedAt: Date.now(),
-        },
-    });
-    void ctx.params.onAgentEvent?.({
-        stream: "lifecycle",
-        data: { phase: "end" },
-    });
-    if (ctx.params.onBlockReply) {
-        if (ctx.blockChunker?.hasBuffered()) {
-            ctx.blockChunker.drain({ force: true, emit: ctx.emitBlockChunk });
-            ctx.blockChunker.reset();
-        }
-        else if (ctx.state.blockBuffer.length > 0) {
-            ctx.emitBlockChunk(ctx.state.blockBuffer);
-            ctx.state.blockBuffer = "";
-        }
+        ctx.log.debug(`embedded run agent end: runId=${ctx.params.runId} isError=${isError}`);
+        emitAgentEvent({
+            runId: ctx.params.runId,
+            stream: "lifecycle",
+            data: {
+                phase: "end",
+                endedAt: Date.now(),
+            },
+        });
+        void ctx.params.onAgentEvent?.({
+            stream: "lifecycle",
+            data: { phase: "end" },
+        });
     }
+    ctx.flushBlockReplyBuffer();
     ctx.state.blockState.thinking = false;
     ctx.state.blockState.final = false;
     ctx.state.blockState.inlineCode = createInlineCodeState();

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

@@ -2,7 +2,7 @@ import { emitAgentEvent } from "../infra/agent-events.js";
 import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
 import { normalizeTextForComparison } from "./pi-embedded-helpers.js";
 import { isMessagingTool, isMessagingToolSendAction } from "./pi-embedded-messaging.js";
-import { extractToolErrorMessage, extractToolResultMediaPaths, extractToolResultText, extractMessagingToolSend, isToolResultError, sanitizeToolResult, } from "./pi-embedded-subscribe.tools.js";
+import { extractMessagingToolSend, extractToolErrorMessage, extractToolResultMediaPaths, extractToolResultText, filterToolResultMediaUrls, isToolResultError, sanitizeToolResult, } from "./pi-embedded-subscribe.tools.js";
 import { inferToolMetaFromArgs } from "./pi-embedded-utils.js";
 import { buildToolMutationState, isSameToolMutationAction } from "./tool-mutation.js";
 import { normalizeToolName } from "./tool-policy.js";
@@ -311,7 +311,7 @@ export async function handleToolExecutionEnd(ctx, evt) {
     // When shouldEmitToolOutput() is true, emitToolOutput already delivers media
     // via parseReplyDirectives (MEDIA: text extraction), so skip to avoid duplicates.
     if (ctx.params.onToolResult && !isToolError && !ctx.shouldEmitToolOutput()) {
-        const mediaPaths = extractToolResultMediaPaths(result);
+        const mediaPaths = filterToolResultMediaUrls(toolName, extractToolResultMediaPaths(result));
         if (mediaPaths.length > 0) {
             try {
                 void ctx.params.onToolResult({ mediaUrls: mediaPaths });

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

@@ -7,6 +7,7 @@ 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 { filterToolResultMediaUrls } from "./pi-embedded-subscribe.tools.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;
@@ -44,6 +45,7 @@ export function subscribeEmbeddedPiSession(params) {
         assistantTextBaseline: 0,
         suppressBlockChunks: false, // Avoid late chunk inserts after final text merge.
         lastReasoningSent: undefined,
+        reasoningStreamOpen: false,
         compactionInFlight: false,
         pendingCompactionRetry: 0,
         compactionRetryResolve: undefined,
@@ -97,6 +99,7 @@ export function subscribeEmbeddedPiSession(params) {
         state.lastBlockReplyText = undefined;
         state.lastStreamedReasoning = undefined;
         state.lastReasoningSent = undefined;
+        state.reasoningStreamOpen = false;
         state.suppressBlockChunks = false;
         state.assistantMessageIndex += 1;
         state.lastAssistantTextMessageIndex = -1;
@@ -279,13 +282,14 @@ export function subscribeEmbeddedPiSession(params) {
             markdown: useMarkdown,
         });
         const { text: cleanedText, mediaUrls } = parseReplyDirectives(agg);
-        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0)) {
+        const filteredMediaUrls = filterToolResultMediaUrls(toolName, mediaUrls ?? []);
+        if (!cleanedText && filteredMediaUrls.length === 0) {
             return;
         }
         try {
             void params.onToolResult({
                 text: cleanedText,
-                mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                mediaUrls: filteredMediaUrls.length ? filteredMediaUrls : undefined,
             });
         }
         catch {
@@ -301,13 +305,14 @@ export function subscribeEmbeddedPiSession(params) {
         });
         const message = `${agg}\n${formatToolOutputBlock(output)}`;
         const { text: cleanedText, mediaUrls } = parseReplyDirectives(message);
-        if (!cleanedText && (!mediaUrls || mediaUrls.length === 0)) {
+        const filteredMediaUrls = filterToolResultMediaUrls(toolName, mediaUrls ?? []);
+        if (!cleanedText && filteredMediaUrls.length === 0) {
             return;
         }
         try {
             void params.onToolResult({
                 text: cleanedText,
-                mediaUrls: mediaUrls?.length ? mediaUrls : undefined,
+                mediaUrls: filteredMediaUrls.length ? filteredMediaUrls : undefined,
             });
         }
         catch {