@poolzin/pool-bot 2026.3.4 → 2026.3.7

package/dist/agents/tools/pdf-tool.js

@@ -0,0 +1,508 @@
+import path from "node:path";
+import { complete } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+import { resolveUserPath } from "../../utils.js";
+import { getDefaultLocalRoots, loadWebMedia } from "../../web/media.js";
+import { ensureAuthProfileStore, listProfilesForProvider } from "../auth-profiles.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
+import { getApiKeyForModel, requireApiKey, resolveEnvApiKey } from "../model-auth.js";
+import { runWithImageModelFallback } from "../model-fallback.js";
+import { resolveConfiguredModelRef } from "../model-selection.js";
+import { ensurePoolbotModelsJson } from "../models-config.js";
+import { discoverAuthStorage, discoverModels } from "../pi-model-discovery.js";
+import { normalizeWorkspaceDir } from "../workspace-dir.js";
+import { resolveProviderVisionModelFromConfig } from "./image-tool.helpers.js";
+import { anthropicAnalyzePdf, geminiAnalyzePdf } from "./pdf-native-providers.js";
+import { extractPdfContent, normalizeMimeType, resolveInputFileLimits, } from "../../media/input-files.js";
+import { coercePdfAssistantText, coercePdfModelConfig, parsePageRange, providerSupportsNativePdf, resolvePdfToolMaxTokens, } from "./pdf-tool.helpers.js";
+const DEFAULT_PROMPT = "Analyze the PDF document.";
+const ANTHROPIC_PDF_PRIMARY = "anthropic/claude-opus-4-6";
+const ANTHROPIC_PDF_FALLBACK = "anthropic/claude-opus-4-5";
+const DEFAULT_MAX_PDFS = 10;
+export const __testing = {
+    coercePdfAssistantText,
+    resolvePdfToolMaxTokens,
+};
+function resolveDefaultModelRef(cfg) {
+    if (cfg) {
+        const resolved = resolveConfiguredModelRef({
+            cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+            defaultModel: DEFAULT_MODEL,
+        });
+        return { provider: resolved.provider, model: resolved.model };
+    }
+    return { provider: DEFAULT_PROVIDER, model: DEFAULT_MODEL };
+}
+function hasAuthForProvider(params) {
+    if (resolveEnvApiKey(params.provider)?.apiKey) {
+        return true;
+    }
+    const store = ensureAuthProfileStore(params.agentDir, {
+        allowKeychainPrompt: false,
+    });
+    return listProfilesForProvider(store, params.provider).length > 0;
+}
+/**
+ * Resolve the effective PDF model config for the `pdf` tool.
+ *
+ * - Prefer explicit config (`agents.defaults.pdfModel`).
+ * - Otherwise, try to "pair" the primary model with a PDF-capable model:
+ *   - same provider (best effort)
+ *   - fall back to OpenAI/Anthropic when available
+ */
+export function resolvePdfModelConfigForTool(params) {
+    const explicit = coercePdfModelConfig(params.cfg);
+    if (explicit.primary?.trim() || (explicit.fallbacks?.length ?? 0) > 0) {
+        return explicit;
+    }
+    const primary = resolveDefaultModelRef(params.cfg);
+    const openaiOk = hasAuthForProvider({
+        provider: "openai",
+        agentDir: params.agentDir,
+    });
+    const anthropicOk = hasAuthForProvider({
+        provider: "anthropic",
+        agentDir: params.agentDir,
+    });
+    const fallbacks = [];
+    const addFallback = (modelRef) => {
+        const ref = (modelRef ?? "").trim();
+        if (!ref) {
+            return;
+        }
+        if (fallbacks.includes(ref)) {
+            return;
+        }
+        fallbacks.push(ref);
+    };
+    const providerVisionFromConfig = resolveProviderVisionModelFromConfig({
+        cfg: params.cfg,
+        provider: primary.provider,
+    });
+    const providerOk = hasAuthForProvider({
+        provider: primary.provider,
+        agentDir: params.agentDir,
+    });
+    let preferred = null;
+    if (providerOk && providerVisionFromConfig) {
+        preferred = providerVisionFromConfig;
+    }
+    else if (primary.provider === "openai" && openaiOk) {
+        preferred = "openai/gpt-5-mini";
+    }
+    else if (primary.provider === "anthropic" && anthropicOk) {
+        preferred = ANTHROPIC_PDF_PRIMARY;
+    }
+    if (preferred?.trim()) {
+        if (openaiOk) {
+            addFallback("openai/gpt-5-mini");
+        }
+        if (anthropicOk) {
+            addFallback(ANTHROPIC_PDF_FALLBACK);
+        }
+        // Don't duplicate primary in fallbacks.
+        const pruned = fallbacks.filter((ref) => ref !== preferred);
+        return {
+            primary: preferred,
+            ...(pruned.length > 0 ? { fallbacks: pruned } : {}),
+        };
+    }
+    // Cross-provider fallback when we can't pair with the primary provider.
+    if (openaiOk) {
+        if (anthropicOk) {
+            addFallback(ANTHROPIC_PDF_FALLBACK);
+        }
+        return {
+            primary: "openai/gpt-5-mini",
+            ...(fallbacks.length ? { fallbacks } : {}),
+        };
+    }
+    if (anthropicOk) {
+        return {
+            primary: ANTHROPIC_PDF_PRIMARY,
+            fallbacks: [ANTHROPIC_PDF_FALLBACK],
+        };
+    }
+    return null;
+}
+function pickMaxBytes(cfg, maxBytesMb) {
+    if (typeof maxBytesMb === "number" && Number.isFinite(maxBytesMb) && maxBytesMb > 0) {
+        return Math.floor(maxBytesMb * 1024 * 1024);
+    }
+    const configured = cfg?.agents?.defaults?.mediaMaxMb;
+    if (typeof configured === "number" && Number.isFinite(configured) && configured > 0) {
+        return Math.floor(configured * 1024 * 1024);
+    }
+    return undefined;
+}
+function buildPdfContext(prompt, extractedText, images) {
+    const content = [];
+    // Build text block: prompt + extracted text
+    const textBlock = extractedText.trim()
+        ? `${prompt}\n\n--- Extracted PDF Text ---\n${extractedText}\n--- End Extracted PDF Text ---`
+        : prompt;
+    content.push({ type: "text", text: textBlock });
+    // Add rendered page images
+    for (const img of images) {
+        content.push({ type: "image", data: img.data, mimeType: img.mimeType });
+    }
+    return {
+        messages: [
+            {
+                role: "user",
+                content,
+                timestamp: Date.now(),
+            },
+        ],
+    };
+}
+async function resolveSandboxedPdfPath(params) {
+    const normalize = (p) => (p.startsWith("file://") ? p.slice("file://".length) : p);
+    const filePath = normalize(params.pdfPath);
+    try {
+        const resolved = params.sandbox.bridge.resolvePath({
+            filePath,
+            cwd: params.sandbox.root,
+        });
+        return { resolved: resolved.hostPath };
+    }
+    catch (err) {
+        const name = path.basename(filePath);
+        const candidateRel = path.join("media", "inbound", name);
+        try {
+            const stat = await params.sandbox.bridge.stat({
+                filePath: candidateRel,
+                cwd: params.sandbox.root,
+            });
+            if (!stat) {
+                throw err;
+            }
+        }
+        catch {
+            throw err;
+        }
+        const out = params.sandbox.bridge.resolvePath({
+            filePath: candidateRel,
+            cwd: params.sandbox.root,
+        });
+        return { resolved: out.hostPath, rewrittenFrom: filePath };
+    }
+}
+async function runPdfPrompt(params) {
+    // Overlay pdfModelConfig onto cfg.agents.defaults.imageModel so
+    // runWithImageModelFallback reads our PDF-specific model cascade.
+    const effectiveCfg = params.cfg
+        ? {
+            ...params.cfg,
+            agents: {
+                ...params.cfg.agents,
+                defaults: {
+                    ...params.cfg.agents?.defaults,
+                    imageModel: params.pdfModelConfig,
+                },
+            },
+        }
+        : undefined;
+    await ensurePoolbotModelsJson(effectiveCfg, params.agentDir);
+    const authStorage = discoverAuthStorage(params.agentDir);
+    const modelRegistry = discoverModels(authStorage, params.agentDir);
+    const result = await runWithImageModelFallback({
+        cfg: effectiveCfg,
+        modelOverride: params.modelOverride,
+        run: async (provider, modelId) => {
+            const model = modelRegistry.find(provider, modelId);
+            if (!model) {
+                throw new Error(`Unknown model: ${provider}/${modelId}`);
+            }
+            const apiKeyInfo = await getApiKeyForModel({
+                model,
+                cfg: effectiveCfg,
+                agentDir: params.agentDir,
+            });
+            const apiKey = requireApiKey(apiKeyInfo, model.provider);
+            authStorage.setRuntimeApiKey(model.provider, apiKey);
+            // Native path: send raw PDF bytes to providers with native document support.
+            if (providerSupportsNativePdf(model.provider)) {
+                const pdfs = params.pdfBuffers.map((buf) => ({
+                    base64: buf.toString("base64"),
+                }));
+                if (model.provider === "anthropic") {
+                    const text = await anthropicAnalyzePdf({
+                        apiKey,
+                        modelId: model.id,
+                        prompt: params.prompt,
+                        pdfs,
+                        maxTokens: resolvePdfToolMaxTokens(model.maxTokens),
+                        baseUrl: model.baseUrl,
+                    });
+                    return { text, provider: model.provider, model: model.id };
+                }
+                if (model.provider === "google") {
+                    const text = await geminiAnalyzePdf({
+                        apiKey,
+                        modelId: model.id,
+                        prompt: params.prompt,
+                        pdfs,
+                        baseUrl: model.baseUrl,
+                    });
+                    return { text, provider: model.provider, model: model.id };
+                }
+            }
+            // Non-native fallback: extract text + optional page images, then send
+            // via pi-ai complete().
+            const limits = resolveInputFileLimits();
+            let allText = "";
+            let allImages = [];
+            for (const buf of params.pdfBuffers) {
+                const extracted = await extractPdfContent({
+                    buffer: buf,
+                    limits,
+                    pageNumbers: params.pageNumbers,
+                });
+                if (extracted.text) {
+                    allText += (allText ? "\n\n" : "") + extracted.text;
+                }
+                allImages.push(...extracted.images);
+            }
+            // If model doesn't support images, proceed text-only (don't error).
+            if (!model.input?.includes("image")) {
+                allImages = [];
+            }
+            const context = buildPdfContext(params.prompt, allText, allImages);
+            const message = await complete(model, context, {
+                apiKey,
+                maxTokens: resolvePdfToolMaxTokens(model.maxTokens),
+            });
+            const text = coercePdfAssistantText({
+                message,
+                provider: model.provider,
+                model: model.id,
+            });
+            return { text, provider: model.provider, model: model.id };
+        },
+    });
+    return {
+        text: result.result.text,
+        provider: result.result.provider,
+        model: result.result.model,
+        attempts: result.attempts.map((attempt) => ({
+            provider: attempt.provider,
+            model: attempt.model,
+            error: attempt.error,
+        })),
+    };
+}
+export function createPdfTool(options) {
+    const agentDir = options?.agentDir?.trim();
+    if (!agentDir) {
+        const explicit = coercePdfModelConfig(options?.config);
+        if (explicit.primary?.trim() || (explicit.fallbacks?.length ?? 0) > 0) {
+            throw new Error("createPdfTool requires agentDir when enabled");
+        }
+        return null;
+    }
+    const pdfModelConfig = resolvePdfModelConfigForTool({
+        cfg: options?.config,
+        agentDir,
+    });
+    if (!pdfModelConfig) {
+        return null;
+    }
+    const description = "Analyze one or more PDF documents. Use pdf for a single path/URL, or pdfs for multiple (up to 10). Optionally specify pages to limit analysis to specific page ranges.";
+    const localRoots = (() => {
+        const roots = getDefaultLocalRoots();
+        const workspaceDir = normalizeWorkspaceDir(options?.workspaceDir);
+        if (!workspaceDir) {
+            return roots;
+        }
+        return Array.from(new Set([...roots, workspaceDir]));
+    })();
+    return {
+        label: "PDF",
+        name: "pdf",
+        description,
+        parameters: Type.Object({
+            prompt: Type.Optional(Type.String()),
+            pdf: Type.Optional(Type.String({ description: "Single PDF path or URL." })),
+            pdfs: Type.Optional(Type.Array(Type.String(), {
+                description: "Multiple PDF paths or URLs (up to 10).",
+            })),
+            pages: Type.Optional(Type.String({
+                description: 'Page range to analyze, e.g. "1-5", "3", "1-3,7-9". Omit to analyze all pages.',
+            })),
+            model: Type.Optional(Type.String()),
+            maxBytesMb: Type.Optional(Type.Number()),
+        }),
+        execute: async (_toolCallId, args) => {
+            const record = args && typeof args === "object" ? args : {};
+            // MARK: - Normalize pdf + pdfs input and dedupe while preserving order
+            const pdfCandidates = [];
+            if (typeof record.pdf === "string") {
+                pdfCandidates.push(record.pdf);
+            }
+            if (Array.isArray(record.pdfs)) {
+                pdfCandidates.push(...record.pdfs.filter((v) => typeof v === "string"));
+            }
+            const seenPdfs = new Set();
+            const pdfInputs = [];
+            for (const candidate of pdfCandidates) {
+                const trimmedCandidate = candidate.trim();
+                const normalizedForDedupe = trimmedCandidate.startsWith("@")
+                    ? trimmedCandidate.slice(1).trim()
+                    : trimmedCandidate;
+                if (!normalizedForDedupe || seenPdfs.has(normalizedForDedupe)) {
+                    continue;
+                }
+                seenPdfs.add(normalizedForDedupe);
+                pdfInputs.push(trimmedCandidate);
+            }
+            if (pdfInputs.length === 0) {
+                throw new Error("pdf required");
+            }
+            // MARK: - Enforce max PDFs cap (hardcoded)
+            if (pdfInputs.length > DEFAULT_MAX_PDFS) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Too many PDFs: ${pdfInputs.length} provided, maximum is ${DEFAULT_MAX_PDFS}. Please reduce the number of PDFs.`,
+                        },
+                    ],
+                    details: { error: "too_many_pdfs", count: pdfInputs.length, max: DEFAULT_MAX_PDFS },
+                };
+            }
+            // MARK: - Parse pages param
+            const pagesRaw = typeof record.pages === "string" && record.pages.trim() ? record.pages.trim() : undefined;
+            const pageNumbers = pagesRaw ? parsePageRange(pagesRaw, 9999) : undefined;
+            const promptRaw = typeof record.prompt === "string" && record.prompt.trim()
+                ? record.prompt.trim()
+                : DEFAULT_PROMPT;
+            const modelOverride = typeof record.model === "string" && record.model.trim() ? record.model.trim() : undefined;
+            const maxBytesMb = typeof record.maxBytesMb === "number" ? record.maxBytesMb : undefined;
+            const maxBytes = pickMaxBytes(options?.config, maxBytesMb);
+            const sandboxConfig = options?.sandbox && options?.sandbox.root.trim()
+                ? { root: options.sandbox.root.trim(), bridge: options.sandbox.bridge }
+                : null;
+            // MARK: - Load and resolve each PDF
+            const loadedPdfs = [];
+            for (const pdfRawInput of pdfInputs) {
+                const trimmed = pdfRawInput.trim();
+                const pdfRaw = trimmed.startsWith("@") ? trimmed.slice(1).trim() : trimmed;
+                if (!pdfRaw) {
+                    throw new Error("pdf required (empty string in array)");
+                }
+                // Validate scheme: allow file://, http(s)://, and bare paths.
+                // Reject data: URLs (too large for PDFs) and unsupported schemes.
+                const looksLikeWindowsDrivePath = /^[a-zA-Z]:[\\/]/.test(pdfRaw);
+                const hasScheme = /^[a-z][a-z0-9+.-]*:/i.test(pdfRaw);
+                const isFileUrl = /^file:/i.test(pdfRaw);
+                const isHttpUrl = /^https?:\/\//i.test(pdfRaw);
+                const isDataUrl = /^data:/i.test(pdfRaw);
+                if (isDataUrl) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Data URLs are not supported for PDFs. Use a file path or an http(s) URL instead.`,
+                            },
+                        ],
+                        details: { error: "unsupported_pdf_reference", pdf: pdfRawInput },
+                    };
+                }
+                if (hasScheme && !looksLikeWindowsDrivePath && !isFileUrl && !isHttpUrl) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Unsupported PDF reference: ${pdfRawInput}. Use a file path, a file:// URL, or an http(s) URL.`,
+                            },
+                        ],
+                        details: {
+                            error: "unsupported_pdf_reference",
+                            pdf: pdfRawInput,
+                        },
+                    };
+                }
+                if (sandboxConfig && isHttpUrl) {
+                    throw new Error("Sandboxed PDF tool does not allow remote URLs.");
+                }
+                const resolvedPdf = (() => {
+                    if (sandboxConfig) {
+                        return pdfRaw;
+                    }
+                    if (pdfRaw.startsWith("~")) {
+                        return resolveUserPath(pdfRaw);
+                    }
+                    return pdfRaw;
+                })();
+                const resolvedPathInfo = sandboxConfig
+                    ? await resolveSandboxedPdfPath({
+                        sandbox: sandboxConfig,
+                        pdfPath: resolvedPdf,
+                    })
+                    : {
+                        resolved: resolvedPdf.startsWith("file://")
+                            ? resolvedPdf.slice("file://".length)
+                            : resolvedPdf,
+                    };
+                const resolvedPath = resolvedPathInfo.resolved;
+                const media = sandboxConfig
+                    ? await loadWebMedia(resolvedPath ?? resolvedPdf, {
+                        maxBytes,
+                        sandboxValidated: true,
+                        optimizeImages: false,
+                        readFile: (filePath) => sandboxConfig.bridge.readFile({ filePath, cwd: sandboxConfig.root }),
+                    })
+                    : await loadWebMedia(resolvedPath ?? resolvedPdf, {
+                        maxBytes,
+                        localRoots,
+                        optimizeImages: false,
+                    });
+                const mime = normalizeMimeType(("contentType" in media && media.contentType) || "");
+                if (mime !== "application/pdf") {
+                    throw new Error(`Expected PDF, got: ${("contentType" in media && media.contentType) || "unknown"}`);
+                }
+                loadedPdfs.push({
+                    buffer: media.buffer,
+                    resolvedPdf,
+                    ...(resolvedPathInfo.rewrittenFrom
+                        ? { rewrittenFrom: resolvedPathInfo.rewrittenFrom }
+                        : {}),
+                });
+            }
+            // MARK: - Run PDF prompt with all loaded PDFs
+            const result = await runPdfPrompt({
+                cfg: options?.config,
+                agentDir,
+                pdfModelConfig,
+                modelOverride,
+                prompt: promptRaw,
+                pdfBuffers: loadedPdfs.map((p) => p.buffer),
+                pageNumbers,
+            });
+            const pdfDetails = loadedPdfs.length === 1
+                ? {
+                    pdf: loadedPdfs[0].resolvedPdf,
+                    ...(loadedPdfs[0].rewrittenFrom
+                        ? { rewrittenFrom: loadedPdfs[0].rewrittenFrom }
+                        : {}),
+                }
+                : {
+                    pdfs: loadedPdfs.map((p) => ({
+                        pdf: p.resolvedPdf,
+                        ...(p.rewrittenFrom ? { rewrittenFrom: p.rewrittenFrom } : {}),
+                    })),
+                };
+            return {
+                content: [{ type: "text", text: result.text }],
+                details: {
+                    model: `${result.provider}/${result.model}`,
+                    ...pdfDetails,
+                    ...(pageNumbers ? { pages: pageNumbers } : {}),
+                    attempts: result.attempts,
+                },
+            };
+        },
+    };
+}

package/dist/auto-reply/reply/get-reply.js

@@ -14,6 +14,7 @@ import { resolveReplyDirectives } from "./get-reply-directives.js";
 import { handleInlineActions } from "./get-reply-inline-actions.js";
 import { runPreparedReply } from "./get-reply-run.js";
 import { finalizeInboundContext } from "./inbound-context.js";
+import { emitPreAgentMessageHooks } from "./message-preprocess-hooks.js";
 import { applyResetModelOverride } from "./session-reset-model.js";
 import { initSessionState } from "./session.js";
 import { stageSandboxMedia } from "./stage-sandbox-media.js";
@@ -110,6 +111,11 @@ export async function getReplyFromConfig(ctx, opts, configOverride) {
             cfg,
         });
     }
+    emitPreAgentMessageHooks({
+        ctx: finalized,
+        cfg,
+        isFastTestEnv,
+    });
     const commandAuthorized = finalized.CommandAuthorized;
     resolveCommandAuthorization({
         ctx: finalized,

package/dist/auto-reply/reply/message-preprocess-hooks.js

@@ -0,0 +1,17 @@
+import { fireAndForgetHook } from "../../hooks/fire-and-forget.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
+import { deriveInboundMessageHookContext, toInternalMessagePreprocessedContext, toInternalMessageTranscribedContext, } from "../../hooks/message-hook-mappers.js";
+export function emitPreAgentMessageHooks(params) {
+    if (params.isFastTestEnv) {
+        return;
+    }
+    const sessionKey = params.ctx.SessionKey?.trim();
+    if (!sessionKey) {
+        return;
+    }
+    const canonical = deriveInboundMessageHookContext(params.ctx);
+    if (canonical.transcript) {
+        fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "transcribed", sessionKey, toInternalMessageTranscribedContext(canonical, params.cfg))), "get-reply: message:transcribed internal hook failed");
+    }
+    fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "preprocessed", sessionKey, toInternalMessagePreprocessedContext(canonical, params.cfg))), "get-reply: message:preprocessed internal hook failed");
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.4",
-  "commit": "8f59018950a00bf223a194a5e8af854aed69c342",
-  "builtAt": "2026-03-04T11:23:48.618Z"
+  "version": "2026.3.7",
+  "commit": "2bb47cd934fe9cb9d58ee7210ee3997714a07f09",
+  "builtAt": "2026-03-07T19:13:06.611Z"
 }

package/dist/cli/banner.js

@@ -1,9 +1,28 @@
+import { loadConfig } from "../config/config.js";
 import { resolveCommitHash } from "../infra/git-commit.js";
 import { visibleWidth } from "../terminal/ansi.js";
 import { isRich, theme } from "../terminal/theme.js";
 import { hasRootVersionAlias } from "./argv.js";
 import { pickTagline } from "./tagline.js";
 import { resolveCliName } from "./cli-name.js";
+function parseTaglineMode(value) {
+    if (value === "random" || value === "default" || value === "off") {
+        return value;
+    }
+    return undefined;
+}
+function resolveTaglineMode(options) {
+    const explicit = parseTaglineMode(options.mode);
+    if (explicit) {
+        return explicit;
+    }
+    try {
+        return parseTaglineMode(loadConfig().cli?.banner?.taglineMode);
+    }
+    catch {
+        return undefined;
+    }
+}
 let bannerEmitted = false;
 const graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl
     ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
@@ -23,7 +42,7 @@ const hasVersionFlag = (argv) => argv.some((arg) => arg === "--version" || arg =
 export function formatCliBannerLine(version, options = {}) {
     const commit = options.commit ?? resolveCommitHash({ env: options.env });
     const commitLabel = commit ?? "unknown";
-    const tagline = pickTagline(options);
+    const tagline = pickTagline({ ...options, mode: resolveTaglineMode(options) });
     const rich = options.richTty ?? isRich();
     const cliName = resolveCliName(options.argv ?? process.argv);
     const title = cliName === "poolbot" ? "🎱 Pool Bot" : "🎱 Pool Bot";