@nfreeness/clawdbot 0.124.22101 → 0.124.22103

package/dist/agents/command-poll-backoff.js

@@ -0,0 +1,63 @@
+// Exponential backoff schedule for command polling
+const BACKOFF_SCHEDULE_MS = [5000, 10000, 30000, 60000];
+/**
+ * Calculate suggested retry delay based on consecutive no-output poll count.
+ * Implements exponential backoff schedule: 5s → 10s → 30s → 60s (capped).
+ */
+export function calculateBackoffMs(consecutiveNoOutputPolls) {
+    const index = Math.min(consecutiveNoOutputPolls, BACKOFF_SCHEDULE_MS.length - 1);
+    return BACKOFF_SCHEDULE_MS[index] ?? 60000;
+}
+/**
+ * Record a command poll and return suggested retry delay.
+ * @param state Session state to track polling in
+ * @param commandId Unique identifier for the command being polled
+ * @param hasNewOutput Whether this poll returned new output
+ * @returns Suggested delay in milliseconds before next poll
+ */
+export function recordCommandPoll(state, commandId, hasNewOutput) {
+    if (!state.commandPollCounts) {
+        state.commandPollCounts = new Map();
+    }
+    const existing = state.commandPollCounts.get(commandId);
+    const now = Date.now();
+    if (hasNewOutput) {
+        state.commandPollCounts.set(commandId, { count: 0, lastPollAt: now });
+        return BACKOFF_SCHEDULE_MS[0] ?? 5000;
+    }
+    const newCount = (existing?.count ?? -1) + 1;
+    state.commandPollCounts.set(commandId, { count: newCount, lastPollAt: now });
+    return calculateBackoffMs(newCount);
+}
+/**
+ * Get current suggested backoff for a command without modifying state.
+ * Useful for checking current backoff level.
+ */
+export function getCommandPollSuggestion(state, commandId) {
+    const pollData = state.commandPollCounts?.get(commandId);
+    if (!pollData) {
+        return undefined;
+    }
+    return calculateBackoffMs(pollData.count);
+}
+/**
+ * Reset poll count for a command (e.g., when command completes).
+ */
+export function resetCommandPollCount(state, commandId) {
+    state.commandPollCounts?.delete(commandId);
+}
+/**
+ * Prune stale command poll records (older than 1 hour).
+ * Call periodically to prevent memory bloat.
+ */
+export function pruneStaleCommandPolls(state, maxAgeMs = 3600000) {
+    if (!state.commandPollCounts) {
+        return;
+    }
+    const now = Date.now();
+    for (const [commandId, data] of state.commandPollCounts.entries()) {
+        if (now - data.lastPollAt > maxAgeMs) {
+            state.commandPollCounts.delete(commandId);
+        }
+    }
+}

package/dist/agents/compaction.js

@@ -1,4 +1,4 @@
-import { convertToLlm, estimateTokens, generateSummary, serializeConversation } from "@mariozechner/pi-coding-agent";
+import { convertToLlm, estimateTokens, generateSummary, serializeConversation, } from "@mariozechner/pi-coding-agent";
 import { completeSimple } from "@mariozechner/pi-ai";
 import { DEFAULT_CONTEXT_TOKENS } from "./defaults.js";
 export const BASE_CHUNK_RATIO = 0.4;

package/dist/agents/current-time.js

@@ -0,0 +1,16 @@
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "./date-time.js";
+export function resolveCronStyleNow(cfg, nowMs) {
+    const userTimezone = resolveUserTimezone(cfg.agents?.defaults?.userTimezone);
+    const userTimeFormat = resolveUserTimeFormat(cfg.agents?.defaults?.timeFormat);
+    const formattedTime = formatUserTime(new Date(nowMs), userTimezone, userTimeFormat) ?? new Date(nowMs).toISOString();
+    const timeLine = `Current time: ${formattedTime} (${userTimezone})`;
+    return { userTimezone, formattedTime, timeLine };
+}
+export function appendCronStyleCurrentTimeLine(text, cfg, nowMs) {
+    const base = text.trimEnd();
+    if (!base || base.includes("Current time:")) {
+        return base;
+    }
+    const { timeLine } = resolveCronStyleNow(cfg, nowMs);
+    return `${base}\n${timeLine}`;
+}

package/dist/agents/pi-embedded-helpers/bootstrap.js

@@ -54,18 +54,26 @@ export function stripThoughtSignatures(content, options) {
         return next;
     });
 }
-export const DEFAULT_BOOTSTRAP_MAX_CHARS = 20_000;
 const BOOTSTRAP_HEAD_RATIO = 0.7;
 const BOOTSTRAP_TAIL_RATIO = 0.2;
-export function resolveBootstrapMaxChars(cfg) {
-    const raw = cfg?.agents?.defaults?.bootstrapMaxChars;
+function resolveConfiguredBootstrapLimit(raw) {
     if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
         return Math.floor(raw);
     }
-    return DEFAULT_BOOTSTRAP_MAX_CHARS;
+    return undefined;
+}
+export function resolveBootstrapMaxChars(cfg) {
+    return resolveConfiguredBootstrapLimit(cfg?.agents?.defaults?.bootstrapMaxChars);
 }
 function trimBootstrapContent(content, fileName, maxChars) {
     const trimmed = content.trimEnd();
+    if (typeof maxChars !== "number") {
+        return {
+            content: trimmed,
+            truncated: false,
+            originalLength: trimmed.length,
+        };
+    }
     if (trimmed.length <= maxChars) {
         return {
             content: trimmed,
@@ -113,7 +121,7 @@ export async function ensureSessionHeader(params) {
     await fs.writeFile(file, `${JSON.stringify(entry)}\n`, "utf-8");
 }
 export function buildBootstrapContextFiles(files, opts) {
-    const maxChars = opts?.maxChars ?? DEFAULT_BOOTSTRAP_MAX_CHARS;
+    const maxChars = resolveConfiguredBootstrapLimit(opts?.maxChars);
     const result = [];
     for (const file of files) {
         if (file.missing) {

package/dist/agents/pi-embedded-helpers.js

@@ -1,4 +1,4 @@
-export { buildBootstrapContextFiles, DEFAULT_BOOTSTRAP_MAX_CHARS, ensureSessionHeader, resolveBootstrapMaxChars, stripThoughtSignatures, } from "./pi-embedded-helpers/bootstrap.js";
+export { buildBootstrapContextFiles, ensureSessionHeader, resolveBootstrapMaxChars, stripThoughtSignatures, } from "./pi-embedded-helpers/bootstrap.js";
 export { classifyFailoverReason, formatRawAssistantErrorForUi, formatAssistantErrorText, getApiErrorPayloadFingerprint, isAuthAssistantError, isAuthErrorMessage, isBillingAssistantError, parseApiErrorInfo, sanitizeUserFacingText, isBillingErrorMessage, isCloudCodeAssistFormatError, isCompactionFailureError, isContextOverflowError, isLikelyContextOverflowError, isFailoverAssistantError, isFailoverErrorMessage, isImageDimensionErrorMessage, isOverloadedErrorMessage, isRawApiErrorPayload, isRateLimitAssistantError, isRateLimitErrorMessage, isTimeoutErrorMessage, parseImageDimensionError, } from "./pi-embedded-helpers/errors.js";
 export { isGoogleModelApi, sanitizeGoogleTurnOrdering } from "./pi-embedded-helpers/google.js";
 export { downgradeOpenAIReasoningBlocks } from "./pi-embedded-helpers/openai.js";

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

@@ -0,0 +1,208 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
+import { isPlainObject } from "../utils.js";
+import { normalizeToolName } from "./tool-policy.js";
+const log = createSubsystemLogger("agents/tools");
+const BEFORE_TOOL_CALL_WRAPPED = Symbol("beforeToolCallWrapped");
+const adjustedParamsByToolCallId = new Map();
+const MAX_TRACKED_ADJUSTED_PARAMS = 1024;
+const LOOP_WARNING_BUCKET_SIZE = 10;
+const MAX_LOOP_WARNING_KEYS = 256;
+function shouldEmitLoopWarning(state, warningKey, count) {
+    if (!state.toolLoopWarningBuckets) {
+        state.toolLoopWarningBuckets = new Map();
+    }
+    const bucket = Math.floor(count / LOOP_WARNING_BUCKET_SIZE);
+    const lastBucket = state.toolLoopWarningBuckets.get(warningKey) ?? 0;
+    if (bucket <= lastBucket) {
+        return false;
+    }
+    state.toolLoopWarningBuckets.set(warningKey, bucket);
+    if (state.toolLoopWarningBuckets.size > MAX_LOOP_WARNING_KEYS) {
+        const oldest = state.toolLoopWarningBuckets.keys().next().value;
+        if (oldest) {
+            state.toolLoopWarningBuckets.delete(oldest);
+        }
+    }
+    return true;
+}
+async function recordLoopOutcome(args) {
+    if (!args.ctx?.sessionKey) {
+        return;
+    }
+    try {
+        const { getDiagnosticSessionState } = await import("../logging/diagnostic-session-state.js");
+        const { recordToolCallOutcome } = await import("./tool-loop-detection.js");
+        const sessionState = getDiagnosticSessionState({
+            sessionKey: args.ctx.sessionKey,
+            sessionId: args.ctx?.agentId,
+        });
+        recordToolCallOutcome(sessionState, {
+            toolName: args.toolName,
+            toolParams: args.toolParams,
+            toolCallId: args.toolCallId,
+            result: args.result,
+            error: args.error,
+            config: args.ctx.loopDetection,
+        });
+    }
+    catch (err) {
+        log.warn(`tool loop outcome tracking failed: tool=${args.toolName} error=${String(err)}`);
+    }
+}
+export async function runBeforeToolCallHook(args) {
+    const toolName = normalizeToolName(args.toolName || "tool");
+    const params = args.params;
+    if (args.ctx?.sessionKey) {
+        const { getDiagnosticSessionState } = await import("../logging/diagnostic-session-state.js");
+        const { logToolLoopAction } = await import("../logging/diagnostic.js");
+        const { detectToolCallLoop, recordToolCall } = await import("./tool-loop-detection.js");
+        const sessionState = getDiagnosticSessionState({
+            sessionKey: args.ctx.sessionKey,
+            sessionId: args.ctx?.agentId,
+        });
+        const loopResult = detectToolCallLoop(sessionState, toolName, params, args.ctx.loopDetection);
+        if (loopResult.stuck) {
+            if (loopResult.level === "critical") {
+                log.error(`Blocking ${toolName} due to critical loop: ${loopResult.message}`);
+                logToolLoopAction({
+                    sessionKey: args.ctx.sessionKey,
+                    sessionId: args.ctx?.agentId,
+                    toolName,
+                    level: "critical",
+                    action: "block",
+                    detector: loopResult.detector,
+                    count: loopResult.count,
+                    message: loopResult.message,
+                    pairedToolName: loopResult.pairedToolName,
+                });
+                return {
+                    blocked: true,
+                    reason: loopResult.message,
+                };
+            }
+            else {
+                const warningKey = loopResult.warningKey ?? `${loopResult.detector}:${toolName}`;
+                if (shouldEmitLoopWarning(sessionState, warningKey, loopResult.count)) {
+                    log.warn(`Loop warning for ${toolName}: ${loopResult.message}`);
+                    logToolLoopAction({
+                        sessionKey: args.ctx.sessionKey,
+                        sessionId: args.ctx?.agentId,
+                        toolName,
+                        level: "warning",
+                        action: "warn",
+                        detector: loopResult.detector,
+                        count: loopResult.count,
+                        message: loopResult.message,
+                        pairedToolName: loopResult.pairedToolName,
+                    });
+                }
+            }
+        }
+        recordToolCall(sessionState, toolName, params, args.toolCallId, args.ctx.loopDetection);
+    }
+    const hookRunner = getGlobalHookRunner();
+    if (!hookRunner?.hasHooks("before_tool_call")) {
+        return { blocked: false, params: args.params };
+    }
+    try {
+        const normalizedParams = isPlainObject(params) ? params : {};
+        const hookResult = await hookRunner.runBeforeToolCall({
+            toolName,
+            params: normalizedParams,
+        }, {
+            toolName,
+            agentId: args.ctx?.agentId,
+            sessionKey: args.ctx?.sessionKey,
+        });
+        if (hookResult?.block) {
+            return {
+                blocked: true,
+                reason: hookResult.blockReason || "Tool call blocked by plugin hook",
+            };
+        }
+        if (hookResult?.params && isPlainObject(hookResult.params)) {
+            if (isPlainObject(params)) {
+                return { blocked: false, params: { ...params, ...hookResult.params } };
+            }
+            return { blocked: false, params: hookResult.params };
+        }
+    }
+    catch (err) {
+        const toolCallId = args.toolCallId ? ` toolCallId=${args.toolCallId}` : "";
+        log.warn(`before_tool_call hook failed: tool=${toolName}${toolCallId} error=${String(err)}`);
+    }
+    return { blocked: false, params };
+}
+export function wrapToolWithBeforeToolCallHook(tool, ctx) {
+    const execute = tool.execute;
+    if (!execute) {
+        return tool;
+    }
+    const toolName = tool.name || "tool";
+    const wrappedTool = {
+        ...tool,
+        execute: async (toolCallId, params, signal, onUpdate) => {
+            const outcome = await runBeforeToolCallHook({
+                toolName,
+                params,
+                toolCallId,
+                ctx,
+            });
+            if (outcome.blocked) {
+                throw new Error(outcome.reason);
+            }
+            if (toolCallId) {
+                adjustedParamsByToolCallId.set(toolCallId, outcome.params);
+                if (adjustedParamsByToolCallId.size > MAX_TRACKED_ADJUSTED_PARAMS) {
+                    const oldest = adjustedParamsByToolCallId.keys().next().value;
+                    if (oldest) {
+                        adjustedParamsByToolCallId.delete(oldest);
+                    }
+                }
+            }
+            const normalizedToolName = normalizeToolName(toolName || "tool");
+            try {
+                const result = await execute(toolCallId, outcome.params, signal, onUpdate);
+                await recordLoopOutcome({
+                    ctx,
+                    toolName: normalizedToolName,
+                    toolParams: outcome.params,
+                    toolCallId,
+                    result,
+                });
+                return result;
+            }
+            catch (err) {
+                await recordLoopOutcome({
+                    ctx,
+                    toolName: normalizedToolName,
+                    toolParams: outcome.params,
+                    toolCallId,
+                    error: err,
+                });
+                throw err;
+            }
+        },
+    };
+    Object.defineProperty(wrappedTool, BEFORE_TOOL_CALL_WRAPPED, {
+        value: true,
+        enumerable: true,
+    });
+    return wrappedTool;
+}
+export function isToolWrappedWithBeforeToolCallHook(tool) {
+    const taggedTool = tool;
+    return taggedTool[BEFORE_TOOL_CALL_WRAPPED] === true;
+}
+export function consumeAdjustedParamsForToolCall(toolCallId) {
+    const params = adjustedParamsByToolCallId.get(toolCallId);
+    adjustedParamsByToolCallId.delete(toolCallId);
+    return params;
+}
+export const __testing = {
+    BEFORE_TOOL_CALL_WRAPPED,
+    adjustedParamsByToolCallId,
+    runBeforeToolCallHook,
+    isPlainObject,
+};

package/dist/agents/pi-tools.js

@@ -6,12 +6,14 @@ import { createExecTool, createProcessTool, } from "./bash-tools.js";
 import { listChannelAgentTools } from "./channel-tools.js";
 import { createClawdbotTools } from "./clawdbot-tools.js";
 import { wrapToolWithAbortSignal } from "./pi-tools.abort.js";
+import { wrapToolWithBeforeToolCallHook } from "./pi-tools.before-tool-call.js";
 import { filterToolsByPolicy, isToolAllowedByPolicies, resolveEffectiveToolPolicy, resolveGroupToolPolicy, resolveSubagentToolPolicy, } from "./pi-tools.policy.js";
 import { assertRequiredParams, CLAUDE_PARAM_GROUPS, createClawdbotReadTool, createSandboxedEditTool, createSandboxedReadTool, createSandboxedWriteTool, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization, } from "./pi-tools.read.js";
 import { cleanToolSchemaForGemini, normalizeToolParameters } from "./pi-tools.schema.js";
 import { buildPluginToolGroups, collectExplicitAllowlist, expandPolicyWithPluginGroups, normalizeToolName, resolveToolProfilePolicy, stripPluginOnlyAllowlist, } from "./tool-policy.js";
 import { getPluginToolMeta } from "../plugins/tools.js";
 import { logWarn } from "../logger.js";
+import { resolveAgentConfig } from "./agent-scope.js";
 function isOpenAIProvider(provider) {
     const normalized = provider?.trim().toLowerCase();
     return normalized === "openai" || normalized === "openai-codex";
@@ -58,6 +60,21 @@ export const __testing = {
     wrapToolParamNormalization,
     assertRequiredParams,
 };
+export function resolveToolLoopDetectionConfig(params) {
+    const global = params.cfg?.tools?.loopDetection;
+    const agent = params.agentId && params.cfg
+        ? resolveAgentConfig(params.cfg, params.agentId)?.tools?.loopDetection
+        : undefined;
+    if (!agent)
+        return global;
+    if (!global)
+        return agent;
+    return {
+        ...global,
+        ...agent,
+        detectors: { ...global.detectors, ...agent.detectors },
+    };
+}
 export function createClawdbotCodingTools(options) {
     const execToolName = "exec";
     const sandbox = options?.sandbox?.enabled ? options.sandbox : undefined;
@@ -277,9 +294,14 @@ export function createClawdbotCodingTools(options) {
     // Always normalize tool JSON Schemas before handing them to pi-agent/pi-ai.
     // Without this, some providers (notably OpenAI) will reject root-level union schemas.
     const normalized = subagentFiltered.map(normalizeToolParameters);
+    const withHooks = normalized.map((tool) => wrapToolWithBeforeToolCallHook(tool, {
+        agentId,
+        sessionKey: options?.sessionKey,
+        loopDetection: resolveToolLoopDetectionConfig({ cfg: options?.config, agentId }),
+    }));
     const withAbort = options?.abortSignal
-        ? normalized.map((tool) => wrapToolWithAbortSignal(tool, options.abortSignal))
-        : normalized;
+        ? withHooks.map((tool) => wrapToolWithAbortSignal(tool, options.abortSignal))
+        : withHooks;
     // NOTE: Keep canonical (lowercase) tool names here.
     // pi-ai's Anthropic OAuth transport remaps tool names to Claude Code-style names
     // on the wire and maps them back for tool dispatch.

package/dist/agents/system-prompt-report.js

@@ -25,7 +25,9 @@ function buildInjectedWorkspaceFiles(params) {
         const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
         const injected = injectedByName.get(file.name);
         const injectedChars = injected ? injected.length : 0;
-        const truncated = !file.missing && rawChars > params.bootstrapMaxChars;
+        const truncated = !file.missing &&
+            typeof params.bootstrapMaxChars === "number" &&
+            rawChars > params.bootstrapMaxChars;
         return {
             name: file.name,
             path: file.path,