@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/agents/pi-tools.read.js

@@ -1,22 +1,187 @@
 import { createEditTool, createReadTool, createWriteTool } from "@mariozechner/pi-coding-agent";
 import { detectMime } from "../media/mime.js";
+import { sniffMimeFromBase64 } from "../media/sniff-mime-from-base64.js";
 import { assertSandboxPath } from "./sandbox-paths.js";
 import { sanitizeToolResultImages } from "./tool-images.js";
-async function sniffMimeFromBase64(base64) {
-    const trimmed = base64.trim();
-    if (!trimmed)
+const DEFAULT_READ_PAGE_MAX_BYTES = 50 * 1024;
+const MAX_ADAPTIVE_READ_MAX_BYTES = 512 * 1024;
+const ADAPTIVE_READ_CONTEXT_SHARE = 0.2;
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const MAX_ADAPTIVE_READ_PAGES = 8;
+const READ_CONTINUATION_NOTICE_RE = /\n\n\[(?:Showing lines [^\]]*?Use offset=\d+ to continue\.|\d+ more lines in file\. Use offset=\d+ to continue\.)\]\s*$/;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function resolveAdaptiveReadMaxBytes(options) {
+    const contextWindowTokens = options?.modelContextWindowTokens;
+    if (typeof contextWindowTokens !== "number" ||
+        !Number.isFinite(contextWindowTokens) ||
+        contextWindowTokens <= 0) {
+        return DEFAULT_READ_PAGE_MAX_BYTES;
+    }
+    const fromContext = Math.floor(contextWindowTokens * CHARS_PER_TOKEN_ESTIMATE * ADAPTIVE_READ_CONTEXT_SHARE);
+    return clamp(fromContext, DEFAULT_READ_PAGE_MAX_BYTES, MAX_ADAPTIVE_READ_MAX_BYTES);
+}
+function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+    if (bytes >= 1024) {
+        return `${Math.round(bytes / 1024)}KB`;
+    }
+    return `${bytes}B`;
+}
+function getToolResultText(result) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    const textBlocks = content
+        .map((block) => {
+        if (block &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string") {
+            return block.text;
+        }
         return undefined;
-    const take = Math.min(256, trimmed.length);
-    const sliceLen = take - (take % 4);
-    if (sliceLen < 8)
+    })
+        .filter((value) => typeof value === "string");
+    if (textBlocks.length === 0) {
         return undefined;
-    try {
-        const head = Buffer.from(trimmed.slice(0, sliceLen), "base64");
-        return await detectMime({ buffer: head });
     }
-    catch {
-        return undefined;
+    return textBlocks.join("\n");
+}
+function withToolResultText(result, text) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    let replaced = false;
+    const nextContent = content.map((block) => {
+        if (!replaced &&
+            block &&
+            typeof block === "object" &&
+            block.type === "text") {
+            replaced = true;
+            return {
+                ...block,
+                text,
+            };
+        }
+        return block;
+    });
+    if (replaced) {
+        return {
+            ...result,
+            content: nextContent,
+        };
+    }
+    const textBlock = { type: "text", text };
+    return {
+        ...result,
+        content: [textBlock],
+    };
+}
+function extractReadTruncationDetails(result) {
+    const details = result.details;
+    if (!details || typeof details !== "object") {
+        return null;
+    }
+    const truncation = details.truncation;
+    if (!truncation || typeof truncation !== "object") {
+        return null;
+    }
+    const record = truncation;
+    if (record.truncated !== true) {
+        return null;
+    }
+    const outputLinesRaw = record.outputLines;
+    const outputLines = typeof outputLinesRaw === "number" && Number.isFinite(outputLinesRaw)
+        ? Math.max(0, Math.floor(outputLinesRaw))
+        : 0;
+    return {
+        truncated: true,
+        outputLines,
+        firstLineExceedsLimit: record.firstLineExceedsLimit === true,
+    };
+}
+function stripReadContinuationNotice(text) {
+    return text.replace(READ_CONTINUATION_NOTICE_RE, "");
+}
+function stripReadTruncationContentDetails(result) {
+    const details = result.details;
+    if (!details || typeof details !== "object") {
+        return result;
+    }
+    const detailsRecord = details;
+    const truncationRaw = detailsRecord.truncation;
+    if (!truncationRaw || typeof truncationRaw !== "object") {
+        return result;
+    }
+    const truncation = truncationRaw;
+    if (!Object.prototype.hasOwnProperty.call(truncation, "content")) {
+        return result;
+    }
+    const { content: _content, ...restTruncation } = truncation;
+    return {
+        ...result,
+        details: {
+            ...detailsRecord,
+            truncation: restTruncation,
+        },
+    };
+}
+async function executeReadWithAdaptivePaging(params) {
+    const userLimit = params.args.limit;
+    const hasExplicitLimit = typeof userLimit === "number" && Number.isFinite(userLimit) && userLimit > 0;
+    if (hasExplicitLimit) {
+        return await params.base.execute(params.toolCallId, params.args, params.signal);
+    }
+    const offsetRaw = params.args.offset;
+    let nextOffset = typeof offsetRaw === "number" && Number.isFinite(offsetRaw) && offsetRaw > 0
+        ? Math.floor(offsetRaw)
+        : 1;
+    let firstResult = null;
+    let aggregatedText = "";
+    let aggregatedBytes = 0;
+    let capped = false;
+    let continuationOffset;
+    for (let page = 0; page < MAX_ADAPTIVE_READ_PAGES; page += 1) {
+        const pageArgs = { ...params.args, offset: nextOffset };
+        const pageResult = await params.base.execute(params.toolCallId, pageArgs, params.signal);
+        firstResult ??= pageResult;
+        const rawText = getToolResultText(pageResult);
+        if (typeof rawText !== "string") {
+            return pageResult;
+        }
+        const truncation = extractReadTruncationDetails(pageResult);
+        const canContinue = Boolean(truncation?.truncated) &&
+            !truncation?.firstLineExceedsLimit &&
+            (truncation?.outputLines ?? 0) > 0 &&
+            page < MAX_ADAPTIVE_READ_PAGES - 1;
+        const pageText = canContinue ? stripReadContinuationNotice(rawText) : rawText;
+        const delimiter = aggregatedText ? "\n\n" : "";
+        const nextBytes = Buffer.byteLength(`${delimiter}${pageText}`, "utf-8");
+        if (aggregatedText && aggregatedBytes + nextBytes > params.maxBytes) {
+            capped = true;
+            continuationOffset = nextOffset;
+            break;
+        }
+        aggregatedText += `${delimiter}${pageText}`;
+        aggregatedBytes += nextBytes;
+        if (!canContinue || !truncation) {
+            return withToolResultText(pageResult, aggregatedText);
+        }
+        nextOffset += truncation.outputLines;
+        continuationOffset = nextOffset;
+        if (aggregatedBytes >= params.maxBytes) {
+            capped = true;
+            break;
+        }
+    }
+    if (!firstResult) {
+        return await params.base.execute(params.toolCallId, params.args, params.signal);
+    }
+    let finalText = aggregatedText;
+    if (capped && continuationOffset) {
+        finalText += `\n\n[Read output capped at ${formatBytes(params.maxBytes)} for this call. Use offset=${continuationOffset} to continue.]`;
     }
+    return withToolResultText(firstResult, finalText);
 }
 function rewriteReadImageHeader(text, mimeType) {
     // pi-coding-agent uses: "Read image file [image/png]"
@@ -32,19 +197,22 @@ async function normalizeReadImageResult(result, filePath) {
         b.type === "image" &&
         typeof b.data === "string" &&
         typeof b.mimeType === "string");
-    if (!image)
+    if (!image) {
         return result;
+    }
     if (!image.data.trim()) {
         throw new Error(`read: image payload is empty (${filePath})`);
     }
     const sniffed = await sniffMimeFromBase64(image.data);
-    if (!sniffed)
+    if (!sniffed) {
         return result;
+    }
     if (!sniffed.startsWith("image/")) {
         throw new Error(`read: file looks like ${sniffed} but was treated as ${image.mimeType} (${filePath})`);
     }
-    if (sniffed === image.mimeType)
+    if (sniffed === image.mimeType) {
         return result;
+    }
     const nextContent = content.map((block) => {
         if (block && typeof block === "object" && block.type === "image") {
             const b = block;
@@ -64,9 +232,16 @@ async function normalizeReadImageResult(result, filePath) {
     });
     return { ...result, content: nextContent };
 }
+const RETRY_GUIDANCE_SUFFIX = " Supply correct parameters before retrying.";
+function parameterValidationError(message) {
+    return new Error(`${message}.${RETRY_GUIDANCE_SUFFIX}`);
+}
 export const CLAUDE_PARAM_GROUPS = {
     read: [{ keys: ["path", "file_path"], label: "path (path or file_path)" }],
-    write: [{ keys: ["path", "file_path"], label: "path (path or file_path)" }],
+    write: [
+        { keys: ["path", "file_path"], label: "path (path or file_path)" },
+        { keys: ["content"], label: "content" },
+    ],
     edit: [
         { keys: ["path", "file_path"], label: "path (path or file_path)" },
         {
@@ -79,12 +254,61 @@ export const CLAUDE_PARAM_GROUPS = {
         },
     ],
 };
+function extractStructuredText(value, depth = 0) {
+    if (depth > 6) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => extractStructuredText(entry, depth + 1))
+            .filter((entry) => typeof entry === "string");
+        return parts.length > 0 ? parts.join("") : undefined;
+    }
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const record = value;
+    if (typeof record.text === "string") {
+        return record.text;
+    }
+    if (typeof record.content === "string") {
+        return record.content;
+    }
+    if (Array.isArray(record.content)) {
+        return extractStructuredText(record.content, depth + 1);
+    }
+    if (Array.isArray(record.parts)) {
+        return extractStructuredText(record.parts, depth + 1);
+    }
+    if (typeof record.value === "string" && record.value.length > 0) {
+        const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+        const kind = typeof record.kind === "string" ? record.kind.toLowerCase() : "";
+        if (type.includes("text") || kind === "text") {
+            return record.value;
+        }
+    }
+    return undefined;
+}
+function normalizeTextLikeParam(record, key) {
+    const value = record[key];
+    if (typeof value === "string") {
+        return;
+    }
+    const extracted = extractStructuredText(value);
+    if (typeof extracted === "string") {
+        record[key] = extracted;
+    }
+}
 // Normalize tool parameters from Claude Code conventions to pi-coding-agent conventions.
 // Claude Code uses file_path/old_string/new_string while pi-coding-agent uses path/oldText/newText.
 // This prevents models trained on Claude Code from getting stuck in tool-call loops.
 export function normalizeToolParams(params) {
-    if (!params || typeof params !== "object")
+    if (!params || typeof params !== "object") {
         return undefined;
+    }
     const record = params;
     const normalized = { ...record };
     // file_path → path (read, write, edit)
@@ -102,6 +326,11 @@ export function normalizeToolParams(params) {
         normalized.newText = normalized.new_string;
         delete normalized.new_string;
     }
+    // Some providers/models emit text payloads as structured blocks instead of raw strings.
+    // Normalize these for write/edit so content matching and writes stay deterministic.
+    normalizeTextLikeParam(normalized, "content");
+    normalizeTextLikeParam(normalized, "oldText");
+    normalizeTextLikeParam(normalized, "newText");
     return normalized;
 }
 export function patchToolSchemaForClaudeCompatibility(tool) {
@@ -122,8 +351,9 @@ export function patchToolSchemaForClaudeCompatibility(tool) {
         { original: "newText", alias: "new_string" },
     ];
     for (const { original, alias } of aliasPairs) {
-        if (!(original in properties))
+        if (!(original in properties)) {
             continue;
+        }
         if (!(alias in properties)) {
             properties[alias] = properties[original];
             changed = true;
@@ -134,37 +364,47 @@ export function patchToolSchemaForClaudeCompatibility(tool) {
             changed = true;
         }
     }
-    if (!changed)
+    if (!changed) {
         return tool;
+    }
     return {
         ...tool,
         parameters: {
             ...schema,
             properties,
-            ...(required.length > 0 ? { required } : {}),
+            required,
         },
     };
 }
 export function assertRequiredParams(record, groups, toolName) {
     if (!record || typeof record !== "object") {
-        throw new Error(`Missing parameters for ${toolName}`);
+        throw parameterValidationError(`Missing parameters for ${toolName}`);
     }
+    const missingLabels = [];
     for (const group of groups) {
         const satisfied = group.keys.some((key) => {
-            if (!(key in record))
+            if (!(key in record)) {
                 return false;
+            }
             const value = record[key];
-            if (typeof value !== "string")
+            if (typeof value !== "string") {
                 return false;
-            if (group.allowEmpty)
+            }
+            if (group.allowEmpty) {
                 return true;
+            }
             return value.trim().length > 0;
         });
         if (!satisfied) {
             const label = group.label ?? group.keys.join(" or ");
-            throw new Error(`Missing required parameter: ${label}`);
+            missingLabels.push(label);
         }
     }
+    if (missingLabels.length > 0) {
+        const joined = missingLabels.join(", ");
+        const noun = missingLabels.length === 1 ? "parameter" : "parameters";
+        throw parameterValidationError(`Missing required ${noun}: ${joined}`);
+    }
 }
 // Generic wrapper to normalize parameters for any tool
 export function wrapToolParamNormalization(tool, requiredParamGroups) {
@@ -182,7 +422,7 @@ export function wrapToolParamNormalization(tool, requiredParamGroups) {
         },
     };
 }
-function wrapSandboxPathGuard(tool, root) {
+export function wrapToolWorkspaceRootGuard(tool, root) {
     return {
         ...tool,
         execute: async (toolCallId, args, signal, onUpdate) => {
@@ -197,19 +437,28 @@ function wrapSandboxPathGuard(tool, root) {
         },
     };
 }
-export function createSandboxedReadTool(root) {
-    const base = createReadTool(root);
-    return wrapSandboxPathGuard(createPoolbotReadTool(base), root);
+export function createSandboxedReadTool(params) {
+    const base = createReadTool(params.root, {
+        operations: createSandboxReadOperations(params),
+    });
+    return createPoolbotReadTool(base, {
+        modelContextWindowTokens: params.modelContextWindowTokens,
+        imageSanitization: params.imageSanitization,
+    });
 }
-export function createSandboxedWriteTool(root) {
-    const base = createWriteTool(root);
-    return wrapSandboxPathGuard(wrapToolParamNormalization(base, CLAUDE_PARAM_GROUPS.write), root);
+export function createSandboxedWriteTool(params) {
+    const base = createWriteTool(params.root, {
+        operations: createSandboxWriteOperations(params),
+    });
+    return wrapToolParamNormalization(base, CLAUDE_PARAM_GROUPS.write);
 }
-export function createSandboxedEditTool(root) {
-    const base = createEditTool(root);
-    return wrapSandboxPathGuard(wrapToolParamNormalization(base, CLAUDE_PARAM_GROUPS.edit), root);
+export function createSandboxedEditTool(params) {
+    const base = createEditTool(params.root, {
+        operations: createSandboxEditOperations(params),
+    });
+    return wrapToolParamNormalization(base, CLAUDE_PARAM_GROUPS.edit);
 }
-export function createPoolbotReadTool(base) {
+export function createPoolbotReadTool(base, options) {
     const patched = patchToolSchemaForClaudeCompatibility(base);
     return {
         ...patched,
@@ -218,10 +467,60 @@ export function createPoolbotReadTool(base) {
             const record = normalized ??
                 (params && typeof params === "object" ? params : undefined);
             assertRequiredParams(record, CLAUDE_PARAM_GROUPS.read, base.name);
-            const result = (await base.execute(toolCallId, normalized ?? params, signal));
+            const result = await executeReadWithAdaptivePaging({
+                base,
+                toolCallId,
+                args: (normalized ?? params ?? {}),
+                signal,
+                maxBytes: resolveAdaptiveReadMaxBytes(options),
+            });
             const filePath = typeof record?.path === "string" ? String(record.path) : "<unknown>";
-            const normalizedResult = await normalizeReadImageResult(result, filePath);
-            return sanitizeToolResultImages(normalizedResult, `read:${filePath}`);
+            const strippedDetailsResult = stripReadTruncationContentDetails(result);
+            const normalizedResult = await normalizeReadImageResult(strippedDetailsResult, filePath);
+            return sanitizeToolResultImages(normalizedResult, `read:${filePath}`, options?.imageSanitization);
         },
     };
 }
+function createSandboxReadOperations(params) {
+    return {
+        readFile: (absolutePath) => params.bridge.readFile({ filePath: absolutePath, cwd: params.root }),
+        access: async (absolutePath) => {
+            const stat = await params.bridge.stat({ filePath: absolutePath, cwd: params.root });
+            if (!stat) {
+                throw createFsAccessError("ENOENT", absolutePath);
+            }
+        },
+        detectImageMimeType: async (absolutePath) => {
+            const buffer = await params.bridge.readFile({ filePath: absolutePath, cwd: params.root });
+            const mime = await detectMime({ buffer, filePath: absolutePath });
+            return mime && mime.startsWith("image/") ? mime : undefined;
+        },
+    };
+}
+function createSandboxWriteOperations(params) {
+    return {
+        mkdir: async (dir) => {
+            await params.bridge.mkdirp({ filePath: dir, cwd: params.root });
+        },
+        writeFile: async (absolutePath, content) => {
+            await params.bridge.writeFile({ filePath: absolutePath, cwd: params.root, data: content });
+        },
+    };
+}
+function createSandboxEditOperations(params) {
+    return {
+        readFile: (absolutePath) => params.bridge.readFile({ filePath: absolutePath, cwd: params.root }),
+        writeFile: (absolutePath, content) => params.bridge.writeFile({ filePath: absolutePath, cwd: params.root, data: content }),
+        access: async (absolutePath) => {
+            const stat = await params.bridge.stat({ filePath: absolutePath, cwd: params.root });
+            if (!stat) {
+                throw createFsAccessError("ENOENT", absolutePath);
+            }
+        },
+    };
+}
+function createFsAccessError(code, filePath) {
+    const error = new Error(`Sandbox FS error (${code}): ${filePath}`);
+    error.code = code;
+    return error;
+}

package/dist/agents/poolbot-tools.js

@@ -4,8 +4,8 @@ import { createAgentsListTool } from "./tools/agents-list-tool.js";
 import { createBrowserTool } from "./tools/browser-tool.js";
 import { createCanvasTool } from "./tools/canvas-tool.js";
 import { createCronTool } from "./tools/cron-tool.js";
-import { createGatewayTool } from "./tools/gateway-tool.js";
 import { createDeepResearchTool } from "./tools/deep-research-tool.js";
+import { createGatewayTool } from "./tools/gateway-tool.js";
 import { createImageGenerateTool } from "./tools/image-generate-tool.js";
 import { createImageTool } from "./tools/image-tool.js";
 import { createMessageTool } from "./tools/message-tool.js";
@@ -15,14 +15,20 @@ import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
 import { createSessionsListTool } from "./tools/sessions-list-tool.js";
 import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
 import { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
-import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
+import { createSubagentsTool } from "./tools/subagents-tool.js";
 import { createTtsTool } from "./tools/tts-tool.js";
+import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
+import { resolveWorkspaceRoot } from "./workspace-dir.js";
 export function createPoolBotTools(options) {
+    const workspaceDir = resolveWorkspaceRoot(options?.workspaceDir);
     const imageTool = options?.agentDir?.trim()
         ? createImageTool({
             config: options?.config,
             agentDir: options.agentDir,
-            sandboxRoot: options?.sandboxRoot,
+            workspaceDir,
+            sandbox: options?.sandboxRoot && options?.sandboxFsBridge
+                ? { root: options.sandboxRoot, bridge: options.sandboxFsBridge }
+                : undefined,
             modelHasVision: options?.modelHasVision,
         })
         : null;
@@ -58,7 +64,7 @@ export function createPoolBotTools(options) {
             sandboxBridgeUrl: options?.sandboxBrowserBridgeUrl,
             allowHostControl: options?.allowHostBrowserControl,
         }),
-        createCanvasTool(),
+        createCanvasTool({ config: options?.config }),
         createNodesTool({
             agentSessionKey: options?.agentSessionKey,
             config: options?.config,
@@ -104,6 +110,9 @@ export function createPoolBotTools(options) {
             sandboxed: options?.sandboxed,
             requesterAgentIdOverride: options?.requesterAgentIdOverride,
         }),
+        createSubagentsTool({
+            agentSessionKey: options?.agentSessionKey,
+        }),
         createSessionStatusTool({
             agentSessionKey: options?.agentSessionKey,
             config: options?.config,
@@ -124,7 +133,7 @@ export function createPoolBotTools(options) {
     const pluginTools = resolvePluginTools({
         context: {
             config: options?.config,
-            workspaceDir: options?.workspaceDir,
+            workspaceDir,
             agentDir: options?.agentDir,
             agentId: resolveSessionAgentId({
                 sessionKey: options?.agentSessionKey,

package/dist/agents/sandbox/docker.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { sanitizeEnvVars } from "./sanitize-env-vars.js";
 function createAbortError() {
     const err = new Error("Aborted");
     err.name = "AbortError";
@@ -209,11 +210,15 @@ export function buildSandboxCreateArgs(params) {
     if (params.cfg.user) {
         args.push("--user", params.cfg.user);
     }
-    for (const [key, value] of Object.entries(params.cfg.env ?? {})) {
-        if (!key.trim()) {
-            continue;
-        }
-        args.push("--env", key + "=" + value);
+    const envSanitization = sanitizeEnvVars(params.cfg.env ?? {});
+    if (envSanitization.blocked.length > 0) {
+        console.warn("[Security] Blocked sensitive environment variables:", envSanitization.blocked.join(", "));
+    }
+    if (envSanitization.warnings.length > 0) {
+        console.warn("[Security] Suspicious environment variables:", envSanitization.warnings);
+    }
+    for (const [key, value] of Object.entries(envSanitization.allowed)) {
+        args.push("--env", `${key}=${value}`);
     }
     for (const cap of params.cfg.capDrop) {
         args.push("--cap-drop", cap);