@takibeiy/moltbot_cn 2026.2.1 → 2026.2.2

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

@@ -9,32 +9,38 @@ function normalizeFailureText(text) {
     return text.replace(/\s+/g, " ").trim();
 }
 function truncateFailureText(text, maxChars) {
-    if (text.length <= maxChars)
+    if (text.length <= maxChars) {
         return text;
+    }
     return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
 }
 function formatToolFailureMeta(details) {
-    if (!details || typeof details !== "object")
+    if (!details || typeof details !== "object") {
         return undefined;
+    }
     const record = details;
     const status = typeof record.status === "string" ? record.status : undefined;
     const exitCode = typeof record.exitCode === "number" && Number.isFinite(record.exitCode)
         ? record.exitCode
         : undefined;
     const parts = [];
-    if (status)
+    if (status) {
         parts.push(`status=${status}`);
-    if (exitCode !== undefined)
+    }
+    if (exitCode !== undefined) {
         parts.push(`exitCode=${exitCode}`);
+    }
     return parts.length > 0 ? parts.join(" ") : undefined;
 }
 function extractToolResultText(content) {
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return "";
+    }
     const parts = [];
     for (const block of content) {
-        if (!block || typeof block !== "object")
+        if (!block || typeof block !== "object") {
             continue;
+        }
         const rec = block;
         if (rec.type === "text" && typeof rec.text === "string") {
             parts.push(rec.text);
@@ -46,17 +52,21 @@ function collectToolFailures(messages) {
     const failures = [];
     const seen = new Set();
     for (const message of messages) {
-        if (!message || typeof message !== "object")
+        if (!message || typeof message !== "object") {
             continue;
+        }
         const role = message.role;
-        if (role !== "toolResult")
+        if (role !== "toolResult") {
             continue;
+        }
         const toolResult = message;
-        if (toolResult.isError !== true)
+        if (toolResult.isError !== true) {
             continue;
+        }
         const toolCallId = typeof toolResult.toolCallId === "string" ? toolResult.toolCallId : "";
-        if (!toolCallId || seen.has(toolCallId))
+        if (!toolCallId || seen.has(toolCallId)) {
             continue;
+        }
         seen.add(toolCallId);
         const toolName = typeof toolResult.toolName === "string" && toolResult.toolName.trim()
             ? toolResult.toolName
@@ -70,8 +80,9 @@ function collectToolFailures(messages) {
     return failures;
 }
 function formatToolFailuresSection(failures) {
-    if (failures.length === 0)
+    if (failures.length === 0) {
         return "";
+    }
     const lines = failures.slice(0, MAX_TOOL_FAILURES).map((failure) => {
         const meta = failure.meta ? ` (${failure.meta})` : "";
         return `- ${failure.toolName}${meta}: ${failure.summary}`;
@@ -83,8 +94,8 @@ function formatToolFailuresSection(failures) {
 }
 function computeFileLists(fileOps) {
     const modified = new Set([...fileOps.edited, ...fileOps.written]);
-    const readFiles = [...fileOps.read].filter((f) => !modified.has(f)).sort();
-    const modifiedFiles = [...modified].sort();
+    const readFiles = [...fileOps.read].filter((f) => !modified.has(f)).toSorted();
+    const modifiedFiles = [...modified].toSorted();
     return { readFiles, modifiedFiles };
 }
 function formatFileOperations(readFiles, modifiedFiles) {
@@ -95,8 +106,9 @@ function formatFileOperations(readFiles, modifiedFiles) {
     if (modifiedFiles.length > 0) {
         sections.push(`<modified-files>\n${modifiedFiles.join("\n")}\n</modified-files>`);
     }
-    if (sections.length === 0)
+    if (sections.length === 0) {
         return "";
+    }
     return `\n\n${sections.join("\n\n")}`;
 }
 export default function compactionSafeguardExtension(api) {

package/dist/agents/pi-extensions/context-pruning/extension.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export default function contextPruningExtension(api: ExtensionAPI): void;

package/dist/agents/pi-extensions/context-pruning/extension.js

@@ -3,8 +3,9 @@ import { getContextPruningRuntime } from "./runtime.js";
 export default function contextPruningExtension(api) {
     api.on("context", (event, ctx) => {
         const runtime = getContextPruningRuntime(ctx.sessionManager);
-        if (!runtime)
+        if (!runtime) {
             return undefined;
+        }
         if (runtime.settings.mode === "cache-ttl") {
             const ttlMs = runtime.settings.ttlMs;
             const lastTouch = runtime.lastCacheTouchAt ?? null;
@@ -22,8 +23,9 @@ export default function contextPruningExtension(api) {
             isToolPrunable: runtime.isToolPrunable,
             contextWindowTokensOverride: runtime.contextWindowTokens ?? undefined,
         });
-        if (next === event.messages)
+        if (next === event.messages) {
             return undefined;
+        }
         if (runtime.settings.mode === "cache-ttl") {
             runtime.lastCacheTouchAt = Date.now();
         }

package/dist/agents/pi-extensions/context-pruning/pruner.d.ts

@@ -0,0 +1,10 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { EffectiveContextPruningSettings } from "./settings.js";
+export declare function pruneContextMessages(params: {
+    messages: AgentMessage[];
+    settings: EffectiveContextPruningSettings;
+    ctx: Pick<ExtensionContext, "model">;
+    isToolPrunable?: (toolName: string) => boolean;
+    contextWindowTokensOverride?: number;
+}): AgentMessage[];

package/dist/agents/pi-extensions/context-pruning/pruner.js

@@ -9,32 +9,37 @@ function asText(text) {
 function collectTextSegments(content) {
     const parts = [];
     for (const block of content) {
-        if (block.type === "text")
+        if (block.type === "text") {
             parts.push(block.text);
+        }
     }
     return parts;
 }
 function estimateJoinedTextLength(parts) {
-    if (parts.length === 0)
+    if (parts.length === 0) {
         return 0;
+    }
     let len = 0;
-    for (const p of parts)
+    for (const p of parts) {
         len += p.length;
+    }
     // Joined with "\n" separators between blocks.
     len += Math.max(0, parts.length - 1);
     return len;
 }
 function takeHeadFromJoinedText(parts, maxChars) {
-    if (maxChars <= 0 || parts.length === 0)
+    if (maxChars <= 0 || parts.length === 0) {
         return "";
+    }
     let remaining = maxChars;
     let out = "";
     for (let i = 0; i < parts.length && remaining > 0; i++) {
         if (i > 0) {
             out += "\n";
             remaining -= 1;
-            if (remaining <= 0)
+            if (remaining <= 0) {
                 break;
+            }
         }
         const p = parts[i];
         if (p.length <= remaining) {
@@ -49,8 +54,9 @@ function takeHeadFromJoinedText(parts, maxChars) {
     return out;
 }
 function takeTailFromJoinedText(parts, maxChars) {
-    if (maxChars <= 0 || parts.length === 0)
+    if (maxChars <= 0 || parts.length === 0) {
         return "";
+    }
     let remaining = maxChars;
     const out = [];
     for (let i = parts.length - 1; i >= 0 && remaining > 0; i--) {
@@ -74,32 +80,38 @@ function takeTailFromJoinedText(parts, maxChars) {
 }
 function hasImageBlocks(content) {
     for (const block of content) {
-        if (block.type === "image")
+        if (block.type === "image") {
             return true;
+        }
     }
     return false;
 }
 function estimateMessageChars(message) {
     if (message.role === "user") {
         const content = message.content;
-        if (typeof content === "string")
+        if (typeof content === "string") {
             return content.length;
+        }
         let chars = 0;
         for (const b of content) {
-            if (b.type === "text")
+            if (b.type === "text") {
                 chars += b.text.length;
-            if (b.type === "image")
+            }
+            if (b.type === "image") {
                 chars += IMAGE_CHAR_ESTIMATE;
+            }
         }
         return chars;
     }
     if (message.role === "assistant") {
         let chars = 0;
         for (const b of message.content) {
-            if (b.type === "text")
+            if (b.type === "text") {
                 chars += b.text.length;
-            if (b.type === "thinking")
+            }
+            if (b.type === "thinking") {
                 chars += b.thinking.length;
+            }
             if (b.type === "toolCall") {
                 try {
                     chars += JSON.stringify(b.arguments ?? {}).length;
@@ -114,10 +126,12 @@ function estimateMessageChars(message) {
     if (message.role === "toolResult") {
         let chars = 0;
         for (const b of message.content) {
-            if (b.type === "text")
+            if (b.type === "text") {
                 chars += b.text.length;
-            if (b.type === "image")
+            }
+            if (b.type === "image") {
                 chars += IMAGE_CHAR_ESTIMATE;
+            }
         }
         return chars;
     }
@@ -128,39 +142,46 @@ function estimateContextChars(messages) {
 }
 function findAssistantCutoffIndex(messages, keepLastAssistants) {
     // keepLastAssistants <= 0 => everything is potentially prunable.
-    if (keepLastAssistants <= 0)
+    if (keepLastAssistants <= 0) {
         return messages.length;
+    }
     let remaining = keepLastAssistants;
     for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i]?.role !== "assistant")
+        if (messages[i]?.role !== "assistant") {
             continue;
+        }
         remaining--;
-        if (remaining === 0)
+        if (remaining === 0) {
             return i;
+        }
     }
     // Not enough assistant messages to establish a protected tail.
     return null;
 }
 function findFirstUserIndex(messages) {
     for (let i = 0; i < messages.length; i++) {
-        if (messages[i]?.role === "user")
+        if (messages[i]?.role === "user") {
             return i;
+        }
     }
     return null;
 }
 function softTrimToolResultMessage(params) {
     const { msg, settings } = params;
     // Ignore image tool results for now: these are often directly relevant and hard to partially prune safely.
-    if (hasImageBlocks(msg.content))
+    if (hasImageBlocks(msg.content)) {
         return null;
+    }
     const parts = collectTextSegments(msg.content);
     const rawLen = estimateJoinedTextLength(parts);
-    if (rawLen <= settings.softTrim.maxChars)
+    if (rawLen <= settings.softTrim.maxChars) {
         return null;
+    }
     const headChars = Math.max(0, settings.softTrim.headChars);
     const tailChars = Math.max(0, settings.softTrim.tailChars);
-    if (headChars + tailChars >= rawLen)
+    if (headChars + tailChars >= rawLen) {
         return null;
+    }
     const head = takeHeadFromJoinedText(parts, headChars);
     const tail = takeTailFromJoinedText(parts, tailChars);
     const trimmed = `${head}
@@ -178,14 +199,17 @@ export function pruneContextMessages(params) {
         params.contextWindowTokensOverride > 0
         ? params.contextWindowTokensOverride
         : ctx.model?.contextWindow;
-    if (!contextWindowTokens || contextWindowTokens <= 0)
+    if (!contextWindowTokens || contextWindowTokens <= 0) {
         return messages;
+    }
     const charWindow = contextWindowTokens * CHARS_PER_TOKEN_ESTIMATE;
-    if (charWindow <= 0)
+    if (charWindow <= 0) {
         return messages;
+    }
     const cutoffIndex = findAssistantCutoffIndex(messages, settings.keepLastAssistants);
-    if (cutoffIndex === null)
+    if (cutoffIndex === null) {
         return messages;
+    }
     // Bootstrap safety: never prune anything before the first user message. This protects initial
     // "identity" reads (SOUL.md, USER.md, etc.) which typically happen before the first inbound user
     // message exists in the session transcript.
@@ -202,10 +226,12 @@ export function pruneContextMessages(params) {
     let next = null;
     for (let i = pruneStartIndex; i < cutoffIndex; i++) {
         const msg = messages[i];
-        if (!msg || msg.role !== "toolResult")
+        if (!msg || msg.role !== "toolResult") {
             continue;
-        if (!isToolPrunable(msg.toolName))
+        }
+        if (!isToolPrunable(msg.toolName)) {
             continue;
+        }
         if (hasImageBlocks(msg.content)) {
             continue;
         }
@@ -214,13 +240,15 @@ export function pruneContextMessages(params) {
             msg: msg,
             settings,
         });
-        if (!updated)
+        if (!updated) {
             continue;
+        }
         const beforeChars = estimateMessageChars(msg);
         const afterChars = estimateMessageChars(updated);
         totalChars += afterChars - beforeChars;
-        if (!next)
+        if (!next) {
             next = messages.slice();
+        }
         next[i] = updated;
     }
     const outputAfterSoftTrim = next ?? messages;
@@ -234,26 +262,30 @@ export function pruneContextMessages(params) {
     let prunableToolChars = 0;
     for (const i of prunableToolIndexes) {
         const msg = outputAfterSoftTrim[i];
-        if (!msg || msg.role !== "toolResult")
+        if (!msg || msg.role !== "toolResult") {
             continue;
+        }
         prunableToolChars += estimateMessageChars(msg);
     }
     if (prunableToolChars < settings.minPrunableToolChars) {
         return outputAfterSoftTrim;
     }
     for (const i of prunableToolIndexes) {
-        if (ratio < settings.hardClearRatio)
+        if (ratio < settings.hardClearRatio) {
             break;
+        }
         const msg = (next ?? messages)[i];
-        if (!msg || msg.role !== "toolResult")
+        if (!msg || msg.role !== "toolResult") {
             continue;
+        }
         const beforeChars = estimateMessageChars(msg);
         const cleared = {
             ...msg,
             content: [asText(settings.hardClear.placeholder)],
         };
-        if (!next)
+        if (!next) {
             next = messages.slice();
+        }
         next[i] = cleared;
         const afterChars = estimateMessageChars(cleared);
         totalChars += afterChars - beforeChars;

package/dist/agents/pi-extensions/context-pruning/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { EffectiveContextPruningSettings } from "./settings.js";
+export type ContextPruningRuntimeValue = {
+    settings: EffectiveContextPruningSettings;
+    contextWindowTokens?: number | null;
+    isToolPrunable: (toolName: string) => boolean;
+    lastCacheTouchAt?: number | null;
+};
+export declare function setContextPruningRuntime(sessionManager: unknown, value: ContextPruningRuntimeValue | null): void;
+export declare function getContextPruningRuntime(sessionManager: unknown): ContextPruningRuntimeValue | null;

package/dist/agents/pi-extensions/context-pruning/settings.d.ts

@@ -0,0 +1,44 @@
+export type ContextPruningToolMatch = {
+    allow?: string[];
+    deny?: string[];
+};
+export type ContextPruningMode = "off" | "cache-ttl";
+export type ContextPruningConfig = {
+    mode?: ContextPruningMode;
+    /** TTL to consider cache expired (duration string, default unit: minutes). */
+    ttl?: string;
+    keepLastAssistants?: number;
+    softTrimRatio?: number;
+    hardClearRatio?: number;
+    minPrunableToolChars?: number;
+    tools?: ContextPruningToolMatch;
+    softTrim?: {
+        maxChars?: number;
+        headChars?: number;
+        tailChars?: number;
+    };
+    hardClear?: {
+        enabled?: boolean;
+        placeholder?: string;
+    };
+};
+export type EffectiveContextPruningSettings = {
+    mode: Exclude<ContextPruningMode, "off">;
+    ttlMs: number;
+    keepLastAssistants: number;
+    softTrimRatio: number;
+    hardClearRatio: number;
+    minPrunableToolChars: number;
+    tools: ContextPruningToolMatch;
+    softTrim: {
+        maxChars: number;
+        headChars: number;
+        tailChars: number;
+    };
+    hardClear: {
+        enabled: boolean;
+        placeholder: string;
+    };
+};
+export declare const DEFAULT_CONTEXT_PRUNING_SETTINGS: EffectiveContextPruningSettings;
+export declare function computeEffectiveSettings(raw: unknown): EffectiveContextPruningSettings | null;

package/dist/agents/pi-extensions/context-pruning/settings.js

@@ -18,11 +18,13 @@ export const DEFAULT_CONTEXT_PRUNING_SETTINGS = {
     },
 };
 export function computeEffectiveSettings(raw) {
-    if (!raw || typeof raw !== "object")
+    if (!raw || typeof raw !== "object") {
         return null;
+    }
     const cfg = raw;
-    if (cfg.mode !== "cache-ttl")
+    if (cfg.mode !== "cache-ttl") {
         return null;
+    }
     const s = structuredClone(DEFAULT_CONTEXT_PRUNING_SETTINGS);
     s.mode = cfg.mode;
     if (typeof cfg.ttl === "string") {

package/dist/agents/pi-extensions/context-pruning/tools.d.ts

@@ -0,0 +1,2 @@
+import type { ContextPruningToolMatch } from "./settings.js";
+export declare function makeToolPrunablePredicate(match: ContextPruningToolMatch): (toolName: string) => boolean;

package/dist/agents/pi-extensions/context-pruning/tools.js

@@ -1,6 +1,7 @@
 function normalizePatterns(patterns) {
-    if (!Array.isArray(patterns))
+    if (!Array.isArray(patterns)) {
         return [];
+    }
     return patterns
         .map((p) => String(p ?? "")
         .trim()
@@ -8,10 +9,12 @@ function normalizePatterns(patterns) {
         .filter(Boolean);
 }
 function compilePattern(pattern) {
-    if (pattern === "*")
+    if (pattern === "*") {
         return { kind: "all" };
-    if (!pattern.includes("*"))
+    }
+    if (!pattern.includes("*")) {
         return { kind: "exact", value: pattern };
+    }
     const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const re = new RegExp(`^${escaped.replaceAll("\\*", ".*")}$`);
     return { kind: "regex", value: re };
@@ -21,12 +24,15 @@ function compilePatterns(patterns) {
 }
 function matchesAny(toolName, patterns) {
     for (const p of patterns) {
-        if (p.kind === "all")
+        if (p.kind === "all") {
             return true;
-        if (p.kind === "exact" && toolName === p.value)
+        }
+        if (p.kind === "exact" && toolName === p.value) {
             return true;
-        if (p.kind === "regex" && p.value.test(toolName))
+        }
+        if (p.kind === "regex" && p.value.test(toolName)) {
             return true;
+        }
     }
     return false;
 }
@@ -35,10 +41,12 @@ export function makeToolPrunablePredicate(match) {
     const allow = compilePatterns(match.allow);
     return (toolName) => {
         const normalized = toolName.trim().toLowerCase();
-        if (matchesAny(normalized, deny))
+        if (matchesAny(normalized, deny)) {
             return false;
-        if (allow.length === 0)
+        }
+        if (allow.length === 0) {
             return true;
+        }
         return matchesAny(normalized, allow);
     };
 }

package/dist/agents/pi-extensions/context-pruning.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Opt-in context pruning (“microcompact”-style) for Pi sessions.
+ *
+ * This only affects the in-memory context for the current request; it does not rewrite session
+ * history persisted on disk.
+ */
+export { default } from "./context-pruning/extension.js";
+export { pruneContextMessages } from "./context-pruning/pruner.js";
+export type { ContextPruningConfig, ContextPruningToolMatch, EffectiveContextPruningSettings, } from "./context-pruning/settings.js";
+export { computeEffectiveSettings, DEFAULT_CONTEXT_PRUNING_SETTINGS, } from "./context-pruning/settings.js";

package/dist/agents/pi-model-discovery.d.ts

@@ -0,0 +1,4 @@
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+export { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+export declare function discoverAuthStorage(agentDir: string): AuthStorage;
+export declare function discoverModels(authStorage: AuthStorage, agentDir: string): ModelRegistry;

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

@@ -0,0 +1,10 @@
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import path from "node:path";
+export { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+// Compatibility helpers for pi-coding-agent 0.50+ (discover* helpers removed).
+export function discoverAuthStorage(agentDir) {
+    return new AuthStorage(path.join(agentDir, "auth.json"));
+}
+export function discoverModels(authStorage, agentDir) {
+    return new ModelRegistry(authStorage, path.join(agentDir, "models.json"));
+}

package/dist/agents/pi-settings.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawConfig } from "../config/config.js";
+export declare const DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR = 20000;
+type PiSettingsManagerLike = {
+    getCompactionReserveTokens: () => number;
+    applyOverrides: (overrides: {
+        compaction: {
+            reserveTokens: number;
+        };
+    }) => void;
+};
+export declare function ensurePiCompactionReserveTokens(params: {
+    settingsManager: PiSettingsManagerLike;
+    minReserveTokens?: number;
+}): {
+    didOverride: boolean;
+    reserveTokens: number;
+};
+export declare function resolveCompactionReserveTokensFloor(cfg?: OpenClawConfig): number;
+export {};

package/dist/agents/pi-tool-definition-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { ClientToolDefinition } from "./pi-embedded-runner/run/params.js";
+type AnyAgentTool = AgentTool<any, unknown>;
+export declare function toToolDefinitions(tools: AnyAgentTool[]): ToolDefinition[];
+export declare function toClientToolDefinitions(tools: ClientToolDefinition[], onClientToolCall?: (toolName: string, params: Record<string, unknown>) => void): ToolDefinition[];
+export {};

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

@@ -25,13 +25,15 @@ export function toToolDefinitions(tools) {
                     return await tool.execute(toolCallId, params, signal, onUpdate);
                 }
                 catch (err) {
-                    if (signal?.aborted)
+                    if (signal?.aborted) {
                         throw err;
+                    }
                     const name = err && typeof err === "object" && "name" in err
                         ? String(err.name)
                         : "";
-                    if (name === "AbortError")
+                    if (name === "AbortError") {
                         throw err;
+                    }
                     const described = describeToolExecutionError(err);
                     if (described.stack && described.stack !== described.message) {
                         logDebug(`tools: ${normalizedName} failed stack:\n${described.stack}`);

package/dist/agents/pi-tools.abort.d.ts

@@ -0,0 +1,2 @@
+import type { AnyAgentTool } from "./pi-tools.types.js";
+export declare function wrapToolWithAbortSignal(tool: AnyAgentTool, abortSignal?: AbortSignal): AnyAgentTool;

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

@@ -4,16 +4,21 @@ function throwAbortError() {
     throw err;
 }
 function combineAbortSignals(a, b) {
-    if (!a && !b)
+    if (!a && !b) {
         return undefined;
-    if (a && !b)
+    }
+    if (a && !b) {
         return a;
-    if (b && !a)
+    }
+    if (b && !a) {
         return b;
-    if (a?.aborted)
+    }
+    if (a?.aborted) {
         return a;
-    if (b?.aborted)
+    }
+    if (b?.aborted) {
         return b;
+    }
     if (typeof AbortSignal.any === "function") {
         return AbortSignal.any([a, b]);
     }
@@ -24,17 +29,20 @@ function combineAbortSignals(a, b) {
     return controller.signal;
 }
 export function wrapToolWithAbortSignal(tool, abortSignal) {
-    if (!abortSignal)
+    if (!abortSignal) {
         return tool;
+    }
     const execute = tool.execute;
-    if (!execute)
+    if (!execute) {
         return tool;
+    }
     return {
         ...tool,
         execute: async (toolCallId, params, signal, onUpdate) => {
             const combined = combineAbortSignals(signal, abortSignal);
-            if (combined?.aborted)
+            if (combined?.aborted) {
                 throwAbortError();
+            }
             return await execute(toolCallId, params, combined, onUpdate);
         },
     };