@poolzin/pool-bot 2026.2.21 → 2026.2.22

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

@@ -1,58 +1,71 @@
 import { getChannelPlugin, normalizeChannelId } from "../channels/plugins/index.js";
-import { truncateUtf16Safe } from "../utils.js";
 import { normalizeTargetForProvider } from "../infra/outbound/target-normalization.js";
+import { MEDIA_TOKEN_RE } from "../media/parse.js";
+import { truncateUtf16Safe } from "../utils.js";
 const TOOL_RESULT_MAX_CHARS = 8000;
 const TOOL_ERROR_MAX_CHARS = 400;
 function truncateToolText(text) {
-    if (text.length <= TOOL_RESULT_MAX_CHARS)
+    if (text.length <= TOOL_RESULT_MAX_CHARS) {
         return text;
+    }
     return `${truncateUtf16Safe(text, TOOL_RESULT_MAX_CHARS)}\n…(truncated)…`;
 }
 function normalizeToolErrorText(text) {
     const trimmed = text.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return undefined;
+    }
     const firstLine = trimmed.split(/\r?\n/)[0]?.trim() ?? "";
-    if (!firstLine)
+    if (!firstLine) {
         return undefined;
+    }
     return firstLine.length > TOOL_ERROR_MAX_CHARS
         ? `${truncateUtf16Safe(firstLine, TOOL_ERROR_MAX_CHARS)}…`
         : firstLine;
 }
 function readErrorCandidate(value) {
-    if (typeof value === "string")
+    if (typeof value === "string") {
         return normalizeToolErrorText(value);
-    if (!value || typeof value !== "object")
+    }
+    if (!value || typeof value !== "object") {
         return undefined;
+    }
     const record = value;
-    if (typeof record.message === "string")
+    if (typeof record.message === "string") {
         return normalizeToolErrorText(record.message);
-    if (typeof record.error === "string")
+    }
+    if (typeof record.error === "string") {
         return normalizeToolErrorText(record.error);
+    }
     return undefined;
 }
 function extractErrorField(value) {
-    if (!value || typeof value !== "object")
+    if (!value || typeof value !== "object") {
         return undefined;
+    }
     const record = value;
     const direct = readErrorCandidate(record.error) ??
         readErrorCandidate(record.message) ??
         readErrorCandidate(record.reason);
-    if (direct)
+    if (direct) {
         return direct;
+    }
     const status = typeof record.status === "string" ? record.status.trim() : "";
     return status ? normalizeToolErrorText(status) : undefined;
 }
 export function sanitizeToolResult(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== "object") {
         return result;
+    }
     const record = result;
     const content = Array.isArray(record.content) ? record.content : null;
-    if (!content)
+    if (!content) {
         return record;
+    }
     const sanitized = content.map((item) => {
-        if (!item || typeof item !== "object")
+        if (!item || typeof item !== "object") {
             return item;
+        }
         const entry = item;
         const type = typeof entry.type === "string" ? entry.type : undefined;
         if (type === "text" && typeof entry.text === "string") {
@@ -70,58 +83,138 @@ export function sanitizeToolResult(result) {
     return { ...record, content: sanitized };
 }
 export function extractToolResultText(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== "object") {
         return undefined;
+    }
     const record = result;
     const content = Array.isArray(record.content) ? record.content : null;
-    if (!content)
+    if (!content) {
         return undefined;
+    }
     const texts = content
         .map((item) => {
-        if (!item || typeof item !== "object")
+        if (!item || typeof item !== "object") {
             return undefined;
+        }
         const entry = item;
-        if (entry.type !== "text" || typeof entry.text !== "string")
+        if (entry.type !== "text" || typeof entry.text !== "string") {
             return undefined;
+        }
         const trimmed = entry.text.trim();
         return trimmed ? trimmed : undefined;
     })
         .filter((value) => Boolean(value));
-    if (texts.length === 0)
+    if (texts.length === 0) {
         return undefined;
+    }
     return texts.join("\n");
 }
+/**
+ * Extract media file paths from a tool result.
+ *
+ * Strategy (first match wins):
+ * 1. Parse `MEDIA:` tokens from text content blocks (all Pool Bot tools).
+ * 2. Fall back to `details.path` when image content exists (Pool Bot imageResult).
+ *
+ * Returns an empty array when no media is found (e.g. Pi SDK `read` tool
+ * returns base64 image data but no file path; those need a different delivery
+ * path like saving to a temp file).
+ */
+export function extractToolResultMediaPaths(result) {
+    if (!result || typeof result !== "object") {
+        return [];
+    }
+    const record = result;
+    const content = Array.isArray(record.content) ? record.content : null;
+    if (!content) {
+        return [];
+    }
+    // Extract MEDIA: paths from text content blocks.
+    const paths = [];
+    let hasImageContent = false;
+    for (const item of content) {
+        if (!item || typeof item !== "object") {
+            continue;
+        }
+        const entry = item;
+        if (entry.type === "image") {
+            hasImageContent = true;
+            continue;
+        }
+        if (entry.type === "text" && typeof entry.text === "string") {
+            // Only parse lines that start with MEDIA: (after trimming) to avoid
+            // false-matching placeholders like <media:audio> or mid-line mentions.
+            // Mirrors the line-start guard in splitMediaFromOutput (media/parse.ts).
+            for (const line of entry.text.split("\n")) {
+                if (!line.trimStart().startsWith("MEDIA:")) {
+                    continue;
+                }
+                MEDIA_TOKEN_RE.lastIndex = 0;
+                let match;
+                while ((match = MEDIA_TOKEN_RE.exec(line)) !== null) {
+                    const p = match[1]
+                        ?.replace(/^[`"'[{(]+/, "")
+                        .replace(/[`"'\]})\\,]+$/, "")
+                        .trim();
+                    if (p && p.length <= 4096) {
+                        paths.push(p);
+                    }
+                }
+            }
+        }
+    }
+    if (paths.length > 0) {
+        return paths;
+    }
+    // Fall back to details.path when image content exists but no MEDIA: text.
+    if (hasImageContent) {
+        const details = record.details;
+        const p = typeof details?.path === "string" ? details.path.trim() : "";
+        if (p) {
+            return [p];
+        }
+    }
+    return [];
+}
 export function isToolResultError(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== "object") {
         return false;
+    }
     const record = result;
     const details = record.details;
-    if (!details || typeof details !== "object")
+    if (!details || typeof details !== "object") {
         return false;
+    }
     const status = details.status;
-    if (typeof status !== "string")
+    if (typeof status !== "string") {
         return false;
+    }
     const normalized = status.trim().toLowerCase();
     return normalized === "error" || normalized === "timeout";
 }
 export function extractToolErrorMessage(result) {
-    if (!result || typeof result !== "object")
+    if (!result || typeof result !== "object") {
         return undefined;
+    }
     const record = result;
     const fromDetails = extractErrorField(record.details);
-    if (fromDetails)
+    if (fromDetails) {
         return fromDetails;
+    }
     const fromRoot = extractErrorField(record);
-    if (fromRoot)
+    if (fromRoot) {
         return fromRoot;
+    }
     const text = extractToolResultText(result);
-    if (!text)
+    if (!text) {
         return undefined;
+    }
     try {
         const parsed = JSON.parse(text);
         const fromJson = extractErrorField(parsed);
-        if (fromJson)
+        if (fromJson) {
             return fromJson;
+        }
     }
     catch {
         // Fall through to first-line text fallback.
@@ -134,11 +227,13 @@ export function extractMessagingToolSend(toolName, args) {
     const accountIdRaw = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
     const accountId = accountIdRaw ? accountIdRaw : undefined;
     if (toolName === "message") {
-        if (action !== "send" && action !== "thread-reply")
+        if (action !== "send" && action !== "thread-reply") {
             return undefined;
+        }
         const toRaw = typeof args.to === "string" ? args.to : undefined;
-        if (!toRaw)
+        if (!toRaw) {
             return undefined;
+        }
         const providerRaw = typeof args.provider === "string" ? args.provider.trim() : "";
         const channelRaw = typeof args.channel === "string" ? args.channel.trim() : "";
         const providerHint = providerRaw || channelRaw;
@@ -148,12 +243,14 @@ export function extractMessagingToolSend(toolName, args) {
         return to ? { tool: toolName, provider, accountId, to } : undefined;
     }
     const providerId = normalizeChannelId(toolName);
-    if (!providerId)
+    if (!providerId) {
         return undefined;
+    }
     const plugin = getChannelPlugin(providerId);
     const extracted = plugin?.actions?.extractToolSend?.({ args });
-    if (!extracted?.to)
+    if (!extracted?.to) {
         return undefined;
+    }
     const to = normalizeTargetForProvider(providerId, extracted.to);
     return to
         ? {

package/dist/agents/pi-model-discovery.js

@@ -1,9 +1,16 @@
-import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
 import path from "node:path";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
 export { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+function createAuthStorage(AuthStorageLike, path) {
+    const withFactory = AuthStorageLike;
+    if (typeof withFactory.create === "function") {
+        return withFactory.create(path);
+    }
+    return new AuthStorageLike(path);
+}
 // Compatibility helpers for pi-coding-agent 0.50+ (discover* helpers removed).
 export function discoverAuthStorage(agentDir) {
-    return new AuthStorage(path.join(agentDir, "auth.json"));
+    return createAuthStorage(AuthStorage, path.join(agentDir, "auth.json"));
 }
 export function discoverModels(authStorage, agentDir) {
     return new ModelRegistry(authStorage, path.join(agentDir, "models.json"));

package/dist/agents/pi-tool-definition-adapter.js

@@ -1,6 +1,7 @@
 import { logDebug, logError } from "../logger.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
 import { isPlainObject } from "../utils.js";
-import { runBeforeToolCallHook } from "./pi-tools.before-tool-call.js";
+import { consumeAdjustedParamsForToolCall, isToolWrappedWithBeforeToolCallHook, runBeforeToolCallHook, } from "./pi-tools.before-tool-call.js";
 import { normalizeToolName } from "./tool-policy.js";
 import { jsonResult } from "./tools/common.js";
 function isAbortSignal(value) {
@@ -8,8 +9,11 @@ function isAbortSignal(value) {
 }
 function isLegacyToolExecuteArgs(args) {
     const third = args[2];
-    const fourth = args[3];
-    return isAbortSignal(third) || typeof fourth === "function";
+    const fifth = args[4];
+    if (typeof third === "function") {
+        return true;
+    }
+    return isAbortSignal(fifth);
 }
 function describeToolExecutionError(err) {
     if (err instanceof Error) {
@@ -20,7 +24,7 @@ function describeToolExecutionError(err) {
 }
 function splitToolExecuteArgs(args) {
     if (isLegacyToolExecuteArgs(args)) {
-        const [toolCallId, params, signal, onUpdate] = args;
+        const [toolCallId, params, onUpdate, _ctx, signal] = args;
         return {
             toolCallId,
             params,
@@ -28,7 +32,7 @@ function splitToolExecuteArgs(args) {
             signal,
         };
     }
-    const [toolCallId, params, onUpdate, _ctx, signal] = args;
+    const [toolCallId, params, signal, onUpdate] = args;
     return {
         toolCallId,
         params,
@@ -40,6 +44,7 @@ export function toToolDefinitions(tools) {
     return tools.map((tool) => {
         const name = tool.name || "tool";
         const normalizedName = normalizeToolName(name);
+        const beforeHookWrapped = isToolWrappedWithBeforeToolCallHook(tool);
         return {
             name,
             label: tool.label ?? name,
@@ -47,8 +52,38 @@ export function toToolDefinitions(tools) {
             parameters: tool.parameters,
             execute: async (...args) => {
                 const { toolCallId, params, onUpdate, signal } = splitToolExecuteArgs(args);
+                let executeParams = params;
                 try {
-                    return await tool.execute(toolCallId, params, signal, onUpdate);
+                    if (!beforeHookWrapped) {
+                        const hookOutcome = await runBeforeToolCallHook({
+                            toolName: name,
+                            params,
+                            toolCallId,
+                        });
+                        if (hookOutcome.blocked) {
+                            throw new Error(hookOutcome.reason);
+                        }
+                        executeParams = hookOutcome.params;
+                    }
+                    const result = await tool.execute(toolCallId, executeParams, signal, onUpdate);
+                    const afterParams = beforeHookWrapped
+                        ? (consumeAdjustedParamsForToolCall(toolCallId) ?? executeParams)
+                        : executeParams;
+                    // Call after_tool_call hook
+                    const hookRunner = getGlobalHookRunner();
+                    if (hookRunner?.hasHooks("after_tool_call")) {
+                        try {
+                            await hookRunner.runAfterToolCall({
+                                toolName: name,
+                                params: isPlainObject(afterParams) ? afterParams : {},
+                                result,
+                            }, { toolName: name });
+                        }
+                        catch (hookErr) {
+                            logDebug(`after_tool_call hook failed: tool=${normalizedName} error=${String(hookErr)}`);
+                        }
+                    }
+                    return result;
                 }
                 catch (err) {
                     if (signal?.aborted) {
@@ -60,16 +95,34 @@ export function toToolDefinitions(tools) {
                     if (name === "AbortError") {
                         throw err;
                     }
+                    if (beforeHookWrapped) {
+                        consumeAdjustedParamsForToolCall(toolCallId);
+                    }
                     const described = describeToolExecutionError(err);
                     if (described.stack && described.stack !== described.message) {
                         logDebug(`tools: ${normalizedName} failed stack:\n${described.stack}`);
                     }
                     logError(`[tools] ${normalizedName} failed: ${described.message}`);
-                    return jsonResult({
+                    const errorResult = jsonResult({
                         status: "error",
                         tool: normalizedName,
                         error: described.message,
                     });
+                    // Call after_tool_call hook for errors too
+                    const hookRunner = getGlobalHookRunner();
+                    if (hookRunner?.hasHooks("after_tool_call")) {
+                        try {
+                            await hookRunner.runAfterToolCall({
+                                toolName: normalizedName,
+                                params: isPlainObject(params) ? params : {},
+                                error: described.message,
+                            }, { toolName: normalizedName });
+                        }
+                        catch (hookErr) {
+                            logDebug(`after_tool_call hook failed: tool=${normalizedName} error=${String(hookErr)}`);
+                        }
+                    }
+                    return errorResult;
                 }
             },
         };
@@ -84,7 +137,6 @@ export function toClientToolDefinitions(tools, onClientToolCall, hookContext) {
             name: func.name,
             label: func.name,
             description: func.description ?? "",
-            // oxlint-disable-next-line typescript/no-explicit-any
             parameters: func.parameters,
             execute: async (...args) => {
                 const { toolCallId, params } = splitToolExecuteArgs(args);

package/dist/agents/pi-tools.before-tool-call.js

@@ -187,7 +187,7 @@ export function wrapToolWithBeforeToolCallHook(tool, ctx) {
     };
     Object.defineProperty(wrappedTool, BEFORE_TOOL_CALL_WRAPPED, {
         value: true,
-        enumerable: false,
+        enumerable: true,
     });
     return wrappedTool;
 }