@poolzin/pool-bot 2026.3.13 → 2026.3.15

package/dist/agents/tool-result-truncation.js

@@ -0,0 +1,299 @@
+/**
+ * Tool Result Truncation & Context Pruning
+ *
+ * Implements:
+ * - Head+tail truncation (preserves diagnostics)
+ * - Context pruning for tool-results during soft-trim
+ * - Preserve recent turns verbatim
+ * - Multimodal + tool-result hints
+ *
+ * OpenClaw #32384, #30951
+ */
+/**
+ * Default truncation config
+ * Head+tail approach preserves important diagnostics
+ */
+export const DEFAULT_TRUNCATION_CONFIG = {
+    maxToolResultChars: 50_000,
+    headChars: 10_000,
+    tailChars: 10_000,
+    minCharsForTruncation: 20_000,
+    preserveErrors: true,
+};
+/**
+ * Truncate tool result content with head+tail strategy
+ * OpenClaw #32384 - preserves diagnostic information
+ */
+export function truncateToolResult(content, config = DEFAULT_TRUNCATION_CONFIG) {
+    const originalLength = content.length;
+    // Don't truncate if under threshold
+    if (originalLength <= config.minCharsForTruncation) {
+        return { truncated: content, wasTruncated: false, originalLength };
+    }
+    // Don't truncate if under max
+    if (originalLength <= config.maxToolResultChars) {
+        return { truncated: content, wasTruncated: false, originalLength };
+    }
+    // Head+tail truncation
+    const head = content.slice(0, config.headChars);
+    const tail = content.slice(-config.tailChars);
+    const omitted = originalLength - config.headChars - config.tailChars;
+    const truncated = `${head}\n\n[...${omitted.toLocaleString()} characters omitted...]\n\n${tail}`;
+    return { truncated, wasTruncated: true, originalLength };
+}
+/**
+ * Check if a message is a tool result
+ */
+export function isToolResultMessage(message) {
+    return message.role === "toolResult";
+}
+/**
+ * Check if a tool result contains an error
+ */
+export function isToolResultError(message) {
+    if (!isToolResultMessage(message)) {
+        return false;
+    }
+    return message.isError === true;
+}
+/**
+ * Extract tool result content from message
+ */
+export function extractToolResultContent(message) {
+    const content = message.content;
+    if (typeof content === "string") {
+        return content;
+    }
+    if (content && typeof content === "object") {
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return JSON.stringify({ error: "Failed to stringify content" });
+        }
+    }
+    return "";
+}
+/**
+ * Apply truncation to tool result messages
+ * Preserves errors by default
+ */
+export function truncateToolResultMessages(messages, config = DEFAULT_TRUNCATION_CONFIG) {
+    return messages.map((message) => {
+        if (!isToolResultMessage(message)) {
+            return message;
+        }
+        // Preserve errors if configured
+        if (config.preserveErrors && isToolResultError(message)) {
+            return message;
+        }
+        const content = extractToolResultContent(message);
+        const { truncated, wasTruncated } = truncateToolResult(content, config);
+        if (!wasTruncated) {
+            return message;
+        }
+        // Create new message with truncated content
+        return {
+            ...message,
+            content: truncated,
+        };
+    });
+}
+/**
+ * Default context pruning config
+ */
+export const DEFAULT_CONTEXT_PRUNING_CONFIG = {
+    keepRecentTurns: 10,
+    pruneToolResultsOlderThan: 20,
+    keepErrorToolResults: true,
+    keepMultimodalContent: true,
+    compressToolResults: false,
+};
+/**
+ * Count turns in message history
+ * A turn = user message + assistant response
+ */
+export function countTurns(messages) {
+    let turns = 0;
+    let hasUserMessage = false;
+    for (const message of messages) {
+        const role = message.role;
+        if (role === "user") {
+            hasUserMessage = true;
+        }
+        else if (role === "assistant" && hasUserMessage) {
+            turns += 1;
+            hasUserMessage = false;
+        }
+    }
+    // Count incomplete turn if there's a user message without response
+    if (hasUserMessage) {
+        turns += 1;
+    }
+    return turns;
+}
+/**
+ * Prune context for soft-trim while preserving important information
+ * OpenClaw #30951 - maintains diagnostic quality
+ */
+export function pruneContextForSoftTrim(messages, config = DEFAULT_CONTEXT_PRUNING_CONFIG) {
+    let currentTurn = 0;
+    // Process messages in reverse to identify recent turns
+    const reversedMessages = [...messages].reverse();
+    const keptMessages = [];
+    for (const message of reversedMessages) {
+        const role = message.role;
+        const isToolResult = isToolResultMessage(message);
+        const isToolError = isToolResultError(message);
+        const hasMultimodal = hasMultimodalContent(message);
+        // Always keep user and assistant messages in recent turns
+        if (role === "user" || role === "assistant") {
+            if (currentTurn < config.keepRecentTurns) {
+                keptMessages.unshift(message);
+                if (role === "assistant") {
+                    currentTurn += 1;
+                }
+            }
+            else {
+                // Older turns: selectively prune
+                if (!isToolResult) {
+                    keptMessages.unshift(message);
+                }
+                else if (config.keepErrorToolResults && isToolError) {
+                    keptMessages.unshift(message);
+                }
+                else if (config.keepMultimodalContent && hasMultimodal) {
+                    keptMessages.unshift(message);
+                }
+                else if (config.compressToolResults) {
+                    // Compress to summary instead of full content
+                    const compressed = compressToolResult(message);
+                    keptMessages.unshift(compressed);
+                }
+            }
+            continue;
+        }
+        // Tool results: apply pruning rules
+        if (isToolResult) {
+            if (currentTurn < config.keepRecentTurns) {
+                // Keep recent tool results
+                keptMessages.unshift(message);
+            }
+            else if (config.keepErrorToolResults && isToolError) {
+                // Always keep errors
+                keptMessages.unshift(message);
+            }
+            else if (config.keepMultimodalContent && hasMultimodal) {
+                // Keep multimodal content
+                keptMessages.unshift(message);
+            }
+            else if (config.compressToolResults) {
+                // Compress older tool results
+                const compressed = compressToolResult(message);
+                keptMessages.unshift(compressed);
+            }
+            // Otherwise: prune (don't add to keptMessages)
+        }
+    }
+    return keptMessages;
+}
+/**
+ * Check if a message has multimodal content (images, files, etc.)
+ */
+export function hasMultimodalContent(message) {
+    const content = message.content;
+    if (!content) {
+        return false;
+    }
+    if (Array.isArray(content)) {
+        return content.some((item) => {
+            if (!item || typeof item !== "object") {
+                return false;
+            }
+            const record = item;
+            return (typeof record.image === "string" ||
+                typeof record.file === "string" ||
+                typeof record.data === "string" ||
+                typeof record.url === "string");
+        });
+    }
+    return false;
+}
+/**
+ * Compress tool result to summary (for context pruning)
+ */
+export function compressToolResult(message) {
+    if (!isToolResultMessage(message)) {
+        return message;
+    }
+    const toolName = message.toolName;
+    const toolNameStr = typeof toolName === "string" && toolName.trim() ? toolName : "unknown";
+    const content = extractToolResultContent(message);
+    // Create summary instead of full content
+    const summary = `[Tool: ${toolNameStr}] - ${content.length.toLocaleString()} characters`;
+    return {
+        ...message,
+        content: summary,
+    };
+}
+/**
+ * Audit compaction quality
+ * OpenClaw #30951 - ensures compaction doesn't lose critical information
+ */
+export function auditCompactionQuality(params) {
+    const { originalMessages, compactedMessages, summary } = params;
+    const issues = [];
+    const recommendations = [];
+    let score = 100;
+    // Check 1: Tool errors preserved
+    const originalErrors = originalMessages.filter(isToolResultError).length;
+    const compactedErrors = compactedMessages.filter(isToolResultError).length;
+    if (compactedErrors < originalErrors) {
+        issues.push(`Lost ${originalErrors - compactedErrors} tool error messages`);
+        recommendations.push("Preserve all tool errors during compaction");
+        score -= 20;
+    }
+    // Check 2: Recent turns preserved
+    const originalTurns = countTurns(originalMessages);
+    const compactedTurns = countTurns(compactedMessages);
+    if (compactedTurns < originalTurns * 0.3) {
+        issues.push("Compaction ratio too aggressive (<30% of turns preserved)");
+        recommendations.push("Keep at least 30% of recent turns verbatim");
+        score -= 15;
+    }
+    // Check 3: Summary quality
+    if (summary) {
+        if (summary.length < 50) {
+            issues.push("Summary too short (may lack detail)");
+            recommendations.push("Generate more detailed summaries (min 50 chars)");
+            score -= 10;
+        }
+        if (summary.length > 5000) {
+            issues.push("Summary too long (defeats compaction purpose)");
+            recommendations.push("Keep summaries concise (<5000 chars)");
+            score -= 5;
+        }
+    }
+    // Check 4: Multimodal content
+    const originalMultimodal = originalMessages.filter(hasMultimodalContent).length;
+    const compactedMultimodal = compactedMessages.filter(hasMultimodalContent).length;
+    if (compactedMultimodal < originalMultimodal) {
+        issues.push(`Lost ${originalMultimodal - compactedMultimodal} multimodal messages`);
+        recommendations.push("Preserve multimodal content during compaction");
+        score -= 15;
+    }
+    // Check 5: Message order
+    const lastOriginalRole = originalMessages[originalMessages.length - 1]?.role;
+    const lastCompactedRole = compactedMessages[compactedMessages.length - 1]?.role;
+    if (lastOriginalRole !== lastCompactedRole) {
+        issues.push("Message order may be incorrect (last message role mismatch)");
+        recommendations.push("Verify message ordering after compaction");
+        score -= 10;
+    }
+    return {
+        score: Math.max(0, score),
+        issues,
+        recommendations,
+        passed: score >= 70,
+    };
+}

package/dist/agents/tools/nodes-file-tool.js

@@ -0,0 +1,197 @@
+import crypto from "node:crypto";
+import { Type } from "@sinclair/typebox";
+import { optionalStringEnum, stringEnum } from "../schema/typebox.js";
+import { jsonResult, readStringParam } from "./common.js";
+import { callGatewayTool, readGatewayCallOptions } from "./gateway.js";
+import { resolveNodeId } from "./nodes-utils.js";
+const FILE_TOOL_ACTIONS = ["read", "write", "exists", "delete", "list"];
+const FileToolSchema = Type.Object({
+    action: stringEnum(FILE_TOOL_ACTIONS),
+    gatewayUrl: Type.Optional(Type.String()),
+    gatewayToken: Type.Optional(Type.String()),
+    timeoutMs: Type.Optional(Type.Number()),
+    node: Type.Optional(Type.String()),
+    // read/write/exists/delete
+    path: Type.Optional(Type.String()),
+    // read
+    encoding: optionalStringEnum(["utf8", "base64", "binary"]),
+    maxBytes: Type.Optional(Type.Number()),
+    // write
+    content: Type.Optional(Type.String()),
+    contentBase64: Type.Optional(Type.String()),
+    append: Type.Optional(Type.Boolean()),
+    createDirs: Type.Optional(Type.Boolean()),
+    // list
+    recursive: Type.Optional(Type.Boolean()),
+    includeHidden: Type.Optional(Type.Boolean()),
+});
+export function createNodesFileTool(_options) {
+    return {
+        label: "NodesFile",
+        name: "nodes_file",
+        description: "Read, write, and manage files on paired nodes (remote devices). Supports text and binary content with base64 encoding.",
+        parameters: FileToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = readGatewayCallOptions(params);
+            try {
+                switch (action) {
+                    case "read": {
+                        const node = readStringParam(params, "node", { required: true });
+                        const path = readStringParam(params, "path", { required: true });
+                        const nodeId = await resolveNodeId(gatewayOpts, node);
+                        const encoding = typeof params.encoding === "string" ? params.encoding : "utf8";
+                        const maxBytes = typeof params.maxBytes === "number" && Number.isFinite(params.maxBytes)
+                            ? Math.max(1, Math.floor(params.maxBytes))
+                            : undefined;
+                        const raw = await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "file.read",
+                            params: {
+                                path,
+                                encoding,
+                                maxBytes,
+                            },
+                            idempotencyKey: crypto.randomUUID(),
+                        });
+                        const payload = raw?.payload ?? {};
+                        if (typeof payload === "object" &&
+                            payload !== null &&
+                            "content" in payload &&
+                            typeof payload.content === "string") {
+                            const typedPayload = payload;
+                            return jsonResult({
+                                content: typedPayload.content,
+                                encoding: typedPayload.encoding ?? encoding,
+                                size: typedPayload.size,
+                                truncated: typedPayload.truncated ?? false,
+                                path,
+                            });
+                        }
+                        throw new Error("Invalid response from file.read");
+                    }
+                    case "write": {
+                        const node = readStringParam(params, "node", { required: true });
+                        const path = readStringParam(params, "path", { required: true });
+                        const nodeId = await resolveNodeId(gatewayOpts, node);
+                        const content = typeof params.content === "string" ? params.content : undefined;
+                        const contentBase64 = typeof params.contentBase64 === "string" ? params.contentBase64 : undefined;
+                        if (content === undefined && contentBase64 === undefined) {
+                            throw new Error("content or contentBase64 required for write action");
+                        }
+                        const append = typeof params.append === "boolean" ? params.append : false;
+                        const createDirs = typeof params.createDirs === "boolean" ? params.createDirs : false;
+                        const raw = await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "file.write",
+                            params: {
+                                path,
+                                content,
+                                contentBase64,
+                                append,
+                                createDirs,
+                            },
+                            idempotencyKey: crypto.randomUUID(),
+                        });
+                        const payload = raw?.payload ?? {};
+                        if (typeof payload === "object" &&
+                            payload !== null &&
+                            "ok" in payload &&
+                            payload.ok === true) {
+                            const typedPayload = payload;
+                            return jsonResult({
+                                ok: true,
+                                size: typedPayload.size,
+                                path: typedPayload.path ?? path,
+                            });
+                        }
+                        throw new Error("Invalid response from file.write");
+                    }
+                    case "exists": {
+                        const node = readStringParam(params, "node", { required: true });
+                        const path = readStringParam(params, "path", { required: true });
+                        const nodeId = await resolveNodeId(gatewayOpts, node);
+                        const raw = await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "file.exists",
+                            params: { path },
+                            idempotencyKey: crypto.randomUUID(),
+                        });
+                        const payload = raw?.payload ?? {};
+                        if (typeof payload === "object" &&
+                            payload !== null &&
+                            "exists" in payload &&
+                            typeof payload.exists === "boolean") {
+                            const typedPayload = payload;
+                            return jsonResult({
+                                exists: typedPayload.exists,
+                                isFile: typedPayload.isFile,
+                                isDirectory: typedPayload.isDirectory,
+                                size: typedPayload.size,
+                                modified: typedPayload.modified,
+                                path,
+                            });
+                        }
+                        throw new Error("Invalid response from file.exists");
+                    }
+                    case "delete": {
+                        const node = readStringParam(params, "node", { required: true });
+                        const path = readStringParam(params, "path", { required: true });
+                        const nodeId = await resolveNodeId(gatewayOpts, node);
+                        const raw = await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "file.delete",
+                            params: { path },
+                            idempotencyKey: crypto.randomUUID(),
+                        });
+                        const payload = raw?.payload ?? {};
+                        if (typeof payload === "object" &&
+                            payload !== null &&
+                            "ok" in payload &&
+                            payload.ok === true) {
+                            return jsonResult({ ok: true, path });
+                        }
+                        throw new Error("Invalid response from file.delete");
+                    }
+                    case "list": {
+                        const node = readStringParam(params, "node", { required: true });
+                        const path = readStringParam(params, "path", { required: true });
+                        const nodeId = await resolveNodeId(gatewayOpts, node);
+                        const recursive = typeof params.recursive === "boolean" ? params.recursive : false;
+                        const includeHidden = typeof params.includeHidden === "boolean" ? params.includeHidden : false;
+                        const raw = await callGatewayTool("node.invoke", gatewayOpts, {
+                            nodeId,
+                            command: "file.list",
+                            params: { path, recursive, includeHidden },
+                            idempotencyKey: crypto.randomUUID(),
+                        });
+                        const payload = raw?.payload ?? {};
+                        if (typeof payload === "object" &&
+                            payload !== null &&
+                            "entries" in payload &&
+                            Array.isArray(payload.entries)) {
+                            const typedPayload = payload;
+                            return jsonResult({
+                                entries: typedPayload.entries,
+                                path,
+                                count: typedPayload.entries.length,
+                            });
+                        }
+                        throw new Error("Invalid response from file.list");
+                    }
+                    default:
+                        throw new Error(`Unknown action: ${action}`);
+                }
+            }
+            catch (err) {
+                const nodeLabel = typeof params.node === "string" && params.node.trim() ? params.node.trim() : "auto";
+                const gatewayLabel = gatewayOpts.gatewayUrl && gatewayOpts.gatewayUrl.trim()
+                    ? gatewayOpts.gatewayUrl.trim()
+                    : "default";
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`nodes_file (${action}) failed for node=${nodeLabel} via gateway=${gatewayLabel}: ${message}`, { cause: err });
+            }
+        },
+    };
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.13",
-  "commit": "772f27d4ab21d89af08b22c846efea9a20f86f83",
-  "builtAt": "2026-03-11T03:51:28.829Z"
+  "version": "2026.3.15",
+  "commit": "ecc8dbff78be4290bf7ebeb6b49f8d18b3ef414d",
+  "builtAt": "2026-03-12T05:59:35.973Z"
 }

package/dist/cli/config-cli.js

@@ -364,4 +364,64 @@ export function registerConfigCli(program) {
             defaultRuntime.exit(1);
         }
     });
+    cmd
+        .command("validate")
+        .description("Validate the current config file without modifying it")
+        .option("--json", "Output validation result as JSON", false)
+        .action(async (opts) => {
+        try {
+            const snapshot = await readConfigFileSnapshot();
+            const validated = validateConfigObjectWithPlugins(snapshot.parsed);
+            if (opts.json) {
+                defaultRuntime.log(JSON.stringify({
+                    valid: validated.ok,
+                    issues: validated.ok ? [] : validated.issues,
+                    warnings: validated.warnings,
+                    legacyIssues: snapshot.legacyIssues,
+                }, null, 2));
+                defaultRuntime.exit(validated.ok ? 0 : 1);
+                return;
+            }
+            if (validated.ok) {
+                defaultRuntime.log(theme.success("✓ Config is valid"));
+                if (validated.warnings.length > 0) {
+                    defaultRuntime.log(theme.warn(`\n${validated.warnings.length} warning(s):`));
+                    for (const warning of validated.warnings) {
+                        defaultRuntime.log(`  - ${warning.path}: ${warning.message}`);
+                    }
+                }
+                if (snapshot.legacyIssues.length > 0) {
+                    defaultRuntime.log(theme.warn(`\n${snapshot.legacyIssues.length} legacy issue(s) detected:`));
+                    for (const issue of snapshot.legacyIssues) {
+                        defaultRuntime.log(`  - ${issue}`);
+                    }
+                    defaultRuntime.log(theme.muted("\nRun 'poolbot config' wizard to migrate."));
+                }
+                defaultRuntime.exit(0);
+            }
+            else {
+                defaultRuntime.error(danger("✗ Config validation failed"));
+                for (const issue of validated.issues) {
+                    defaultRuntime.error(`  - ${issue.path}: ${issue.message}`);
+                }
+                if (validated.warnings.length > 0) {
+                    defaultRuntime.log(theme.warn(`\n${validated.warnings.length} warning(s):`));
+                    for (const warning of validated.warnings) {
+                        defaultRuntime.log(`  - ${warning.path}: ${warning.message}`);
+                    }
+                }
+                if (snapshot.legacyIssues.length > 0) {
+                    defaultRuntime.log(theme.warn(`\n${snapshot.legacyIssues.length} legacy issue(s) also detected:`));
+                    for (const issue of snapshot.legacyIssues) {
+                        defaultRuntime.log(`  - ${issue}`);
+                    }
+                }
+                defaultRuntime.exit(1);
+            }
+        }
+        catch (err) {
+            defaultRuntime.error(danger(String(err)));
+            defaultRuntime.exit(1);
+        }
+    });
 }