@gguf/claw 2026.2.1 → 2026.2.3

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

@@ -1,6 +1,18 @@
 import { logDebug, logError } from "../logger.js";
+import { runBeforeToolCallHook } from "./pi-tools.before-tool-call.js";
 import { normalizeToolName } from "./tool-policy.js";
 import { jsonResult } from "./tools/common.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbortSignal(value) {
+    return typeof value === "object" && value !== null && "aborted" in value;
+}
+function isLegacyToolExecuteArgs(args) {
+    const third = args[2];
+    const fourth = args[3];
+    return isAbortSignal(third) || typeof fourth === "function";
+}
 function describeToolExecutionError(err) {
     if (err instanceof Error) {
         const message = err.message?.trim() ? err.message : String(err);
@@ -8,6 +20,24 @@ function describeToolExecutionError(err) {
     }
     return { message: String(err) };
 }
+function splitToolExecuteArgs(args) {
+    if (isLegacyToolExecuteArgs(args)) {
+        const [toolCallId, params, signal, onUpdate] = args;
+        return {
+            toolCallId,
+            params,
+            onUpdate,
+            signal,
+        };
+    }
+    const [toolCallId, params, onUpdate, _ctx, signal] = args;
+    return {
+        toolCallId,
+        params,
+        onUpdate,
+        signal,
+    };
+}
 export function toToolDefinitions(tools) {
     return tools.map((tool) => {
         const name = tool.name || "tool";
@@ -16,11 +46,9 @@ export function toToolDefinitions(tools) {
             name,
             label: tool.label ?? name,
             description: tool.description ?? "",
-            // biome-ignore lint/suspicious/noExplicitAny: TypeBox schema from pi-agent-core uses a different module instance.
             parameters: tool.parameters,
-            execute: async (toolCallId, params, onUpdate, _ctx, signal) => {
-                // KNOWN: pi-coding-agent `ToolDefinition.execute` has a different signature/order
-                // than pi-agent-core `AgentTool.execute`. This adapter keeps our existing tools intact.
+            execute: async (...args) => {
+                const { toolCallId, params, onUpdate, signal } = splitToolExecuteArgs(args);
                 try {
                     return await tool.execute(toolCallId, params, signal, onUpdate);
                 }
@@ -51,18 +79,31 @@ export function toToolDefinitions(tools) {
 }
 // Convert client tools (OpenResponses hosted tools) to ToolDefinition format
 // These tools are intercepted to return a "pending" result instead of executing
-export function toClientToolDefinitions(tools, onClientToolCall) {
+export function toClientToolDefinitions(tools, onClientToolCall, hookContext) {
     return tools.map((tool) => {
         const func = tool.function;
         return {
             name: func.name,
             label: func.name,
             description: func.description ?? "",
+            // oxlint-disable-next-line typescript/no-explicit-any
             parameters: func.parameters,
-            execute: async (toolCallId, params, _onUpdate, _ctx, _signal) => {
+            execute: async (...args) => {
+                const { toolCallId, params } = splitToolExecuteArgs(args);
+                const outcome = await runBeforeToolCallHook({
+                    toolName: func.name,
+                    params,
+                    toolCallId,
+                    ctx: hookContext,
+                });
+                if (outcome.blocked) {
+                    throw new Error(outcome.reason);
+                }
+                const adjustedParams = outcome.params;
+                const paramsRecord = isPlainObject(adjustedParams) ? adjustedParams : {};
                 // Notify handler that a client tool was called
                 if (onClientToolCall) {
-                    onClientToolCall(func.name, params);
+                    onClientToolCall(func.name, paramsRecord);
                 }
                 // Return a pending result - the client will execute this tool
                 return jsonResult({

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

@@ -3,6 +3,14 @@ function throwAbortError() {
     err.name = "AbortError";
     throw err;
 }
+/**
+ * Checks if an object is a valid AbortSignal using structural typing.
+ * This is more reliable than `instanceof` across different realms (VM, iframe, etc.)
+ * where the AbortSignal constructor may differ.
+ */
+function isAbortSignal(obj) {
+    return obj instanceof AbortSignal;
+}
 function combineAbortSignals(a, b) {
     if (!a && !b) {
         return undefined;
@@ -19,7 +27,7 @@ function combineAbortSignals(a, b) {
     if (b?.aborted) {
         return b;
     }
-    if (typeof AbortSignal.any === "function") {
+    if (typeof AbortSignal.any === "function" && isAbortSignal(a) && isAbortSignal(b)) {
         return AbortSignal.any([a, b]);
     }
     const controller = new AbortController();

package/dist/agents/pi-tools.before-tool-call.d.ts

@@ -0,0 +1,25 @@
+import type { AnyAgentTool } from "./tools/common.js";
+type HookContext = {
+    agentId?: string;
+    sessionKey?: string;
+};
+type HookOutcome = {
+    blocked: true;
+    reason: string;
+} | {
+    blocked: false;
+    params: unknown;
+};
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function runBeforeToolCallHook(args: {
+    toolName: string;
+    params: unknown;
+    toolCallId?: string;
+    ctx?: HookContext;
+}): Promise<HookOutcome>;
+export declare function wrapToolWithBeforeToolCallHook(tool: AnyAgentTool, ctx?: HookContext): AnyAgentTool;
+export declare const __testing: {
+    runBeforeToolCallHook: typeof runBeforeToolCallHook;
+    isPlainObject: typeof isPlainObject;
+};
+export {};

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

@@ -0,0 +1,69 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
+import { normalizeToolName } from "./tool-policy.js";
+const log = createSubsystemLogger("agents/tools");
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export async function runBeforeToolCallHook(args) {
+    const hookRunner = getGlobalHookRunner();
+    if (!hookRunner?.hasHooks("before_tool_call")) {
+        return { blocked: false, params: args.params };
+    }
+    const toolName = normalizeToolName(args.toolName || "tool");
+    const 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";
+    return {
+        ...tool,
+        execute: async (toolCallId, params, signal, onUpdate) => {
+            const outcome = await runBeforeToolCallHook({
+                toolName,
+                params,
+                toolCallId,
+                ctx,
+            });
+            if (outcome.blocked) {
+                throw new Error(outcome.reason);
+            }
+            return await execute(toolCallId, outcome.params, signal, onUpdate);
+        },
+    };
+}
+export const __testing = {
+    runBeforeToolCallHook,
+    isPlainObject,
+};

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

@@ -1,10 +1,10 @@
 import type { OpenClawConfig } from "../config/config.js";
-import { type ExecToolDefaults, type ProcessToolDefaults } from "./bash-tools.js";
 import type { ModelAuthMode } from "./model-auth.js";
-import { assertRequiredParams, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization } from "./pi-tools.read.js";
-import { cleanToolSchemaForGemini } from "./pi-tools.schema.js";
 import type { AnyAgentTool } from "./pi-tools.types.js";
 import type { SandboxContext } from "./sandbox.js";
+import { type ExecToolDefaults, type ProcessToolDefaults } from "./bash-tools.js";
+import { assertRequiredParams, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization } from "./pi-tools.read.js";
+import { cleanToolSchemaForGemini } from "./pi-tools.schema.js";
 export declare const __testing: {
     readonly cleanToolSchemaForGemini: typeof cleanToolSchemaForGemini;
     readonly normalizeToolParams: typeof normalizeToolParams;

package/dist/agents/pi-tools.js

@@ -1,4 +1,6 @@
 import { codingTools, createEditTool, createReadTool, createWriteTool, readTool, } from "@mariozechner/pi-coding-agent";
+import { logWarn } from "../logger.js";
+import { getPluginToolMeta } from "../plugins/tools.js";
 import { isSubagentSessionKey } from "../routing/session-key.js";
 import { resolveGatewayMessageChannel } from "../utils/message-channel.js";
 import { createApplyPatchTool } from "./apply-patch.js";
@@ -6,12 +8,11 @@ import { createExecTool, createProcessTool, } from "./bash-tools.js";
 import { listChannelAgentTools } from "./channel-tools.js";
 import { createOpenClawTools } from "./openclaw-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, createOpenClawReadTool, 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";
 function isOpenAIProvider(provider) {
     const normalized = provider?.trim().toLowerCase();
     return normalized === "openai" || normalized === "openai-codex";
@@ -294,9 +295,13 @@ export function createOpenClawCodingTools(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,
+    }));
     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/pi-tools.policy.js

@@ -1,9 +1,9 @@
 import { getChannelDock } from "../channels/dock.js";
 import { resolveChannelGroupToolsPolicy } from "../config/group-policy.js";
+import { resolveThreadParentSessionKey } from "../sessions/session-key-utils.js";
+import { normalizeMessageChannel } from "../utils/message-channel.js";
 import { resolveAgentConfig, resolveAgentIdFromSessionKey } from "./agent-scope.js";
 import { expandToolGroups, normalizeToolName } from "./tool-policy.js";
-import { normalizeMessageChannel } from "../utils/message-channel.js";
-import { resolveThreadParentSessionKey } from "../sessions/session-key-utils.js";
 function compilePattern(pattern) {
     const normalized = normalizeToolName(pattern);
     if (!normalized) {

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

@@ -149,7 +149,7 @@ export function patchToolSchemaForClaudeCompatibility(tool) {
         parameters: {
             ...schema,
             properties,
-            ...(required.length > 0 ? { required } : {}),
+            required,
         },
     };
 }

package/dist/agents/sandbox/context.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
+import { DEFAULT_BROWSER_EVALUATE_ENABLED } from "../../browser/constants.js";
 import { defaultRuntime } from "../../runtime.js";
 import { resolveUserPath } from "../../utils.js";
-import { DEFAULT_BROWSER_EVALUATE_ENABLED } from "../../browser/constants.js";
 import { syncSkillsToWorkspace } from "../skills.js";
 import { DEFAULT_AGENT_WORKSPACE_DIR } from "../workspace.js";
 import { ensureSandboxBrowser } from "./browser.js";

package/dist/agents/sandbox/docker.js

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
-import { defaultRuntime } from "../../runtime.js";
 import { formatCliCommand } from "../../cli/command-format.js";
+import { defaultRuntime } from "../../runtime.js";
+import { computeSandboxConfigHash } from "./config-hash.js";
 import { DEFAULT_SANDBOX_IMAGE, SANDBOX_AGENT_WORKSPACE_MOUNT } from "./constants.js";
 import { readRegistry, updateRegistry } from "./registry.js";
-import { computeSandboxConfigHash } from "./config-hash.js";
 import { resolveSandboxAgentId, resolveSandboxScopeKey, slugifySessionKey } from "./shared.js";
 const HOT_CONTAINER_WINDOW_MS = 5 * 60 * 1000;
 export function execDocker(args, opts) {

package/dist/agents/sandbox/runtime-status.js

@@ -1,7 +1,7 @@
+import { formatCliCommand } from "../../cli/command-format.js";
 import { canonicalizeMainSessionAlias, resolveAgentMainSessionKey } from "../../config/sessions.js";
 import { resolveSessionAgentId } from "../agent-scope.js";
 import { expandToolGroups } from "../tool-policy.js";
-import { formatCliCommand } from "../../cli/command-format.js";
 import { resolveSandboxConfigForAgent } from "./config.js";
 import { resolveSandboxToolPolicyForAgent } from "./tool-policy.js";
 function shouldSandboxSession(cfg, sessionKey, mainSessionKey) {

package/dist/agents/session-file-repair.d.ts

@@ -0,0 +1,11 @@
+type RepairReport = {
+    repaired: boolean;
+    droppedLines: number;
+    backupPath?: string;
+    reason?: string;
+};
+export declare function repairSessionFileIfNeeded(params: {
+    sessionFile: string;
+    warn?: (message: string) => void;
+}): Promise<RepairReport>;
+export {};

package/dist/agents/session-file-repair.js

@@ -0,0 +1,83 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+function isSessionHeader(entry) {
+    if (!entry || typeof entry !== "object") {
+        return false;
+    }
+    const record = entry;
+    return record.type === "session" && typeof record.id === "string" && record.id.length > 0;
+}
+export async function repairSessionFileIfNeeded(params) {
+    const sessionFile = params.sessionFile.trim();
+    if (!sessionFile) {
+        return { repaired: false, droppedLines: 0, reason: "missing session file" };
+    }
+    let content;
+    try {
+        content = await fs.readFile(sessionFile, "utf-8");
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT") {
+            return { repaired: false, droppedLines: 0, reason: "missing session file" };
+        }
+        const reason = `failed to read session file: ${err instanceof Error ? err.message : "unknown error"}`;
+        params.warn?.(`session file repair skipped: ${reason} (${path.basename(sessionFile)})`);
+        return { repaired: false, droppedLines: 0, reason };
+    }
+    const lines = content.split(/\r?\n/);
+    const entries = [];
+    let droppedLines = 0;
+    for (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const entry = JSON.parse(line);
+            entries.push(entry);
+        }
+        catch {
+            droppedLines += 1;
+        }
+    }
+    if (entries.length === 0) {
+        return { repaired: false, droppedLines, reason: "empty session file" };
+    }
+    if (!isSessionHeader(entries[0])) {
+        params.warn?.(`session file repair skipped: invalid session header (${path.basename(sessionFile)})`);
+        return { repaired: false, droppedLines, reason: "invalid session header" };
+    }
+    if (droppedLines === 0) {
+        return { repaired: false, droppedLines: 0 };
+    }
+    const cleaned = `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`;
+    const backupPath = `${sessionFile}.bak-${process.pid}-${Date.now()}`;
+    const tmpPath = `${sessionFile}.repair-${process.pid}-${Date.now()}.tmp`;
+    try {
+        const stat = await fs.stat(sessionFile).catch(() => null);
+        await fs.writeFile(backupPath, content, "utf-8");
+        if (stat) {
+            await fs.chmod(backupPath, stat.mode);
+        }
+        await fs.writeFile(tmpPath, cleaned, "utf-8");
+        if (stat) {
+            await fs.chmod(tmpPath, stat.mode);
+        }
+        await fs.rename(tmpPath, sessionFile);
+    }
+    catch (err) {
+        try {
+            await fs.unlink(tmpPath);
+        }
+        catch (cleanupErr) {
+            params.warn?.(`session file repair cleanup failed: ${cleanupErr instanceof Error ? cleanupErr.message : "unknown error"} (${path.basename(tmpPath)})`);
+        }
+        return {
+            repaired: false,
+            droppedLines,
+            reason: `repair failed: ${err instanceof Error ? err.message : "unknown error"}`,
+        };
+    }
+    params.warn?.(`session file repaired: dropped ${droppedLines} malformed line(s) (${path.basename(sessionFile)})`);
+    return { repaired: true, droppedLines, backupPath };
+}

package/dist/agents/session-tool-result-guard-wrapper.js

@@ -10,20 +10,21 @@ export function guardSessionManager(sessionManager, opts) {
     }
     const hookRunner = getGlobalHookRunner();
     const transform = hookRunner?.hasHooks("tool_result_persist")
-        ? (message, meta) => {
-            const out = hookRunner.runToolResultPersist({
-                toolName: meta.toolName,
-                toolCallId: meta.toolCallId,
-                message,
-                isSynthetic: meta.isSynthetic,
-            }, {
-                agentId: opts?.agentId,
-                sessionKey: opts?.sessionKey,
-                toolName: meta.toolName,
-                toolCallId: meta.toolCallId,
-            });
-            return out?.message ?? message;
-        }
+        ? // oxlint-disable-next-line typescript/no-explicit-any
+            (message, meta) => {
+                const out = hookRunner.runToolResultPersist({
+                    toolName: meta.toolName,
+                    toolCallId: meta.toolCallId,
+                    message,
+                    isSynthetic: meta.isSynthetic,
+                }, {
+                    agentId: opts?.agentId,
+                    sessionKey: opts?.sessionKey,
+                    toolName: meta.toolName,
+                    toolCallId: meta.toolCallId,
+                });
+                return out?.message ?? message;
+            }
         : undefined;
     const guard = installSessionToolResultGuard(sessionManager, {
         transformToolResultForPersistence: transform,

package/dist/agents/session-tool-result-guard.js

@@ -1,5 +1,5 @@
-import { makeMissingToolResult } from "./session-transcript-repair.js";
 import { emitSessionTranscriptUpdate } from "../sessions/transcript-events.js";
+import { makeMissingToolResult, sanitizeToolCallInputs } from "./session-transcript-repair.js";
 function extractAssistantToolCalls(msg) {
     const content = msg.content;
     if (!Array.isArray(content)) {
@@ -59,25 +59,37 @@ export function installSessionToolResultGuard(sessionManager, opts) {
         pending.clear();
     };
     const guardedAppend = (message) => {
+        let nextMessage = message;
         const role = message.role;
-        if (role === "toolResult") {
-            const id = extractToolResultId(message);
+        if (role === "assistant") {
+            const sanitized = sanitizeToolCallInputs([message]);
+            if (sanitized.length === 0) {
+                if (allowSyntheticToolResults && pending.size > 0) {
+                    flushPendingToolResults();
+                }
+                return undefined;
+            }
+            nextMessage = sanitized[0];
+        }
+        const nextRole = nextMessage.role;
+        if (nextRole === "toolResult") {
+            const id = extractToolResultId(nextMessage);
             const toolName = id ? pending.get(id) : undefined;
             if (id) {
                 pending.delete(id);
             }
-            return originalAppend(persistToolResult(message, {
+            return originalAppend(persistToolResult(nextMessage, {
                 toolCallId: id ?? undefined,
                 toolName,
                 isSynthetic: false,
             }));
         }
-        const toolCalls = role === "assistant"
-            ? extractAssistantToolCalls(message)
+        const toolCalls = nextRole === "assistant"
+            ? extractAssistantToolCalls(nextMessage)
             : [];
         if (allowSyntheticToolResults) {
             // If previous tool calls are still pending, flush before non-tool results.
-            if (pending.size > 0 && (toolCalls.length === 0 || role !== "assistant")) {
+            if (pending.size > 0 && (toolCalls.length === 0 || nextRole !== "assistant")) {
                 flushPendingToolResults();
             }
             // If new tool calls arrive while older ones are pending, flush the old ones first.
@@ -85,7 +97,7 @@ export function installSessionToolResultGuard(sessionManager, opts) {
                 flushPendingToolResults();
             }
         }
-        const result = originalAppend(message);
+        const result = originalAppend(nextMessage);
         const sessionFile = sessionManager.getSessionFile?.();
         if (sessionFile) {
             emitSessionTranscriptUpdate(sessionFile);

package/dist/agents/session-transcript-repair.d.ts

@@ -6,6 +6,13 @@ declare function makeMissingToolResult(params: {
     role: "toolResult";
 }>;
 export { makeMissingToolResult };
+export type ToolCallInputRepairReport = {
+    messages: AgentMessage[];
+    droppedToolCalls: number;
+    droppedAssistantMessages: number;
+};
+export declare function repairToolCallInputs(messages: AgentMessage[]): ToolCallInputRepairReport;
+export declare function sanitizeToolCallInputs(messages: AgentMessage[]): AgentMessage[];
 export declare function sanitizeToolUseResultPairing(messages: AgentMessage[]): AgentMessage[];
 export type ToolUseRepairReport = {
     messages: AgentMessage[];

package/dist/agents/session-transcript-repair.js

@@ -1,3 +1,4 @@
+const TOOL_CALL_TYPES = new Set(["toolCall", "toolUse", "functionCall"]);
 function extractToolCallsFromAssistant(msg) {
     const content = msg.content;
     if (!Array.isArray(content)) {
@@ -21,6 +22,18 @@ function extractToolCallsFromAssistant(msg) {
     }
     return toolCalls;
 }
+function isToolCallBlock(block) {
+    if (!block || typeof block !== "object") {
+        return false;
+    }
+    const type = block.type;
+    return typeof type === "string" && TOOL_CALL_TYPES.has(type);
+}
+function hasToolCallInput(block) {
+    const hasInput = "input" in block ? block.input !== undefined && block.input !== null : false;
+    const hasArguments = "arguments" in block ? block.arguments !== undefined && block.arguments !== null : false;
+    return hasInput || hasArguments;
+}
 function extractToolResultId(msg) {
     const toolCallId = msg.toolCallId;
     if (typeof toolCallId === "string" && toolCallId) {
@@ -48,6 +61,51 @@ function makeMissingToolResult(params) {
     };
 }
 export { makeMissingToolResult };
+export function repairToolCallInputs(messages) {
+    let droppedToolCalls = 0;
+    let droppedAssistantMessages = 0;
+    let changed = false;
+    const out = [];
+    for (const msg of messages) {
+        if (!msg || typeof msg !== "object") {
+            out.push(msg);
+            continue;
+        }
+        if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
+            out.push(msg);
+            continue;
+        }
+        const nextContent = [];
+        let droppedInMessage = 0;
+        for (const block of msg.content) {
+            if (isToolCallBlock(block) && !hasToolCallInput(block)) {
+                droppedToolCalls += 1;
+                droppedInMessage += 1;
+                changed = true;
+                continue;
+            }
+            nextContent.push(block);
+        }
+        if (droppedInMessage > 0) {
+            if (nextContent.length === 0) {
+                droppedAssistantMessages += 1;
+                changed = true;
+                continue;
+            }
+            out.push({ ...msg, content: nextContent });
+            continue;
+        }
+        out.push(msg);
+    }
+    return {
+        messages: changed ? out : messages,
+        droppedToolCalls,
+        droppedAssistantMessages,
+    };
+}
+export function sanitizeToolCallInputs(messages) {
+    return repairToolCallInputs(messages).messages;
+}
 export function sanitizeToolUseResultPairing(messages) {
     return repairToolUseResultPairing(messages).messages;
 }

package/dist/agents/skills/refresh.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import chokidar from "chokidar";
+import path from "node:path";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { CONFIG_DIR, resolveUserPath } from "../../utils.js";
 import { resolvePluginSkillDirs } from "./plugin-skills.js";

package/dist/agents/skills/workspace.js

@@ -1,6 +1,6 @@
+import { formatSkillsForPrompt, loadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
 import fs from "node:fs";
 import path from "node:path";
-import { formatSkillsForPrompt, loadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
 import { createSubsystemLogger } from "../../logging/subsystem.js";
 import { CONFIG_DIR, resolveUserPath } from "../../utils.js";
 import { resolveBundledSkillsDir } from "./bundled-dir.js";

package/dist/agents/skills-install.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { resolveBrewExecutable } from "../infra/brew.js";
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
 import { runCommandWithTimeout } from "../process/exec.js";
 import { CONFIG_DIR, ensureDir, resolveUserPath } from "../utils.js";
 import { hasBinary, loadWorkspaceSkillEntries, resolveSkillsInstallPreferences, } from "./skills.js";
@@ -124,10 +125,11 @@ function resolveArchiveType(spec, filename) {
     return undefined;
 }
 async function downloadFile(url, destPath, timeoutMs) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), Math.max(1_000, timeoutMs));
+    const { response, release } = await fetchWithSsrFGuard({
+        url,
+        timeoutMs: Math.max(1_000, timeoutMs),
+    });
     try {
-        const response = await fetch(url, { signal: controller.signal });
         if (!response.ok || !response.body) {
             throw new Error(`Download failed (${response.status} ${response.statusText})`);
         }
@@ -142,7 +144,7 @@ async function downloadFile(url, destPath, timeoutMs) {
         return { bytes: stat.size };
     }
     finally {
-        clearTimeout(timeout);
+        await release();
     }
 }
 async function extractArchive(params) {