@poolzin/pool-bot 2026.2.24 → 2026.2.26

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 {

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

@@ -2,6 +2,8 @@ import { getChannelPlugin, normalizeChannelId } from "../channels/plugins/index.
 import { normalizeTargetForProvider } from "../infra/outbound/target-normalization.js";
 import { MEDIA_TOKEN_RE } from "../media/parse.js";
 import { truncateUtf16Safe } from "../utils.js";
+import { collectTextContentBlocks } from "./content-blocks.js";
+import { normalizeToolName } from "./tool-policy.js";
 const TOOL_RESULT_MAX_CHARS = 8000;
 const TOOL_ERROR_MAX_CHARS = 400;
 function truncateToolText(text) {
@@ -23,6 +25,20 @@ function normalizeToolErrorText(text) {
         ? `${truncateUtf16Safe(firstLine, TOOL_ERROR_MAX_CHARS)}…`
         : firstLine;
 }
+function isErrorLikeStatus(status) {
+    const normalized = status.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    if (normalized === "0" ||
+        normalized === "ok" ||
+        normalized === "success" ||
+        normalized === "completed" ||
+        normalized === "running") {
+        return false;
+    }
+    return /error|fail|timeout|timed[_\s-]?out|denied|cancel|invalid|forbidden/.test(normalized);
+}
 function readErrorCandidate(value) {
     if (typeof value === "string") {
         return normalizeToolErrorText(value);
@@ -51,7 +67,10 @@ function extractErrorField(value) {
         return direct;
     }
     const status = typeof record.status === "string" ? record.status.trim() : "";
-    return status ? normalizeToolErrorText(status) : undefined;
+    if (!status || !isErrorLikeStatus(status)) {
+        return undefined;
+    }
+    return normalizeToolErrorText(status);
 }
 export function sanitizeToolResult(result) {
     if (!result || typeof result !== "object") {
@@ -87,20 +106,9 @@ export function extractToolResultText(result) {
         return undefined;
     }
     const record = result;
-    const content = Array.isArray(record.content) ? record.content : null;
-    if (!content) {
-        return undefined;
-    }
-    const texts = content
+    const texts = collectTextContentBlocks(record.content)
         .map((item) => {
-        if (!item || typeof item !== "object") {
-            return undefined;
-        }
-        const entry = item;
-        if (entry.type !== "text" || typeof entry.text !== "string") {
-            return undefined;
-        }
-        const trimmed = entry.text.trim();
+        const trimmed = item.trim();
         return trimmed ? trimmed : undefined;
     })
         .filter((value) => Boolean(value));
@@ -109,6 +117,52 @@ export function extractToolResultText(result) {
     }
     return texts.join("\n");
 }
+// Core tool names that are allowed to emit local MEDIA: paths.
+// Plugin/MCP tools are intentionally excluded to prevent untrusted file reads.
+const TRUSTED_TOOL_RESULT_MEDIA = new Set([
+    "agents_list",
+    "apply_patch",
+    "browser",
+    "canvas",
+    "cron",
+    "edit",
+    "exec",
+    "gateway",
+    "image",
+    "memory_get",
+    "memory_search",
+    "message",
+    "nodes",
+    "process",
+    "read",
+    "session_status",
+    "sessions_history",
+    "sessions_list",
+    "sessions_send",
+    "sessions_spawn",
+    "subagents",
+    "tts",
+    "web_fetch",
+    "web_search",
+    "write",
+]);
+const HTTP_URL_RE = /^https?:\/\//i;
+export function isToolResultMediaTrusted(toolName) {
+    if (!toolName) {
+        return false;
+    }
+    const normalized = normalizeToolName(toolName);
+    return TRUSTED_TOOL_RESULT_MEDIA.has(normalized);
+}
+export function filterToolResultMediaUrls(toolName, mediaUrls) {
+    if (mediaUrls.length === 0) {
+        return mediaUrls;
+    }
+    if (isToolResultMediaTrusted(toolName)) {
+        return mediaUrls;
+    }
+    return mediaUrls.filter((url) => HTTP_URL_RE.test(url.trim()));
+}
 /**
  * Extract media file paths from a tool result.
  *

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

@@ -1,6 +1,9 @@
 import { stripReasoningTagsFromText } from "../shared/text/reasoning-tags.js";
 import { sanitizeUserFacingText } from "./pi-embedded-helpers.js";
 import { formatToolDetail, resolveToolDisplay } from "./tool-display.js";
+export function isAssistantMessage(msg) {
+    return msg?.role === "assistant";
+}
 /**
  * Strip malformed Minimax tool invocations that leak into text content.
  * Minimax sometimes embeds tool calls as XML in text blocks instead of

package/dist/agents/pi-extensions/compaction-safeguard-runtime.js

@@ -1,20 +1,4 @@
-// Session-scoped runtime registry keyed by object identity.
-// Follows the same WeakMap pattern as context-pruning/runtime.ts.
-const REGISTRY = new WeakMap();
-export function setCompactionSafeguardRuntime(sessionManager, value) {
-    if (!sessionManager || typeof sessionManager !== "object") {
-        return;
-    }
-    const key = sessionManager;
-    if (value === null) {
-        REGISTRY.delete(key);
-        return;
-    }
-    REGISTRY.set(key, value);
-}
-export function getCompactionSafeguardRuntime(sessionManager) {
-    if (!sessionManager || typeof sessionManager !== "object") {
-        return null;
-    }
-    return REGISTRY.get(sessionManager) ?? null;
-}
+import { createSessionManagerRuntimeRegistry } from "./session-manager-runtime-registry.js";
+const registry = createSessionManagerRuntimeRegistry();
+export const setCompactionSafeguardRuntime = registry.set;
+export const getCompactionSafeguardRuntime = registry.get;