@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/agents/pi-auth-json.js

@@ -0,0 +1,118 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureAuthProfileStore } from "./auth-profiles.js";
+import { normalizeProviderId } from "./model-selection.js";
+async function readAuthJson(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Convert an OpenClaw auth-profiles credential to pi-coding-agent auth.json format.
+ * Returns null if the credential cannot be converted.
+ */
+function convertCredential(cred) {
+    if (cred.type === "api_key") {
+        const key = typeof cred.key === "string" ? cred.key.trim() : "";
+        if (!key) {
+            return null;
+        }
+        return { type: "api_key", key };
+    }
+    if (cred.type === "token") {
+        // pi-coding-agent treats static tokens as api_key type
+        const token = typeof cred.token === "string" ? cred.token.trim() : "";
+        if (!token) {
+            return null;
+        }
+        const expires = typeof cred.expires === "number"
+            ? cred.expires
+            : Number.NaN;
+        if (Number.isFinite(expires) && expires > 0 && Date.now() >= expires) {
+            return null;
+        }
+        return { type: "api_key", key: token };
+    }
+    if (cred.type === "oauth") {
+        const accessRaw = cred.access;
+        const refreshRaw = cred.refresh;
+        const expiresRaw = cred.expires;
+        const access = typeof accessRaw === "string" ? accessRaw.trim() : "";
+        const refresh = typeof refreshRaw === "string" ? refreshRaw.trim() : "";
+        const expires = typeof expiresRaw === "number" ? expiresRaw : Number.NaN;
+        if (!access || !refresh || !Number.isFinite(expires) || expires <= 0) {
+            return null;
+        }
+        return { type: "oauth", access, refresh, expires };
+    }
+    return null;
+}
+/**
+ * Check if two auth.json credentials are equivalent.
+ */
+function credentialsEqual(a, b) {
+    if (!a || typeof a !== "object") {
+        return false;
+    }
+    if (a.type !== b.type) {
+        return false;
+    }
+    if (a.type === "api_key" && b.type === "api_key") {
+        return a.key === b.key;
+    }
+    if (a.type === "oauth" && b.type === "oauth") {
+        return a.access === b.access && a.refresh === b.refresh && a.expires === b.expires;
+    }
+    return false;
+}
+/**
+ * pi-coding-agent's ModelRegistry/AuthStorage expects credentials in auth.json.
+ *
+ * OpenClaw stores credentials in auth-profiles.json instead. This helper
+ * bridges all credentials into agentDir/auth.json so pi-coding-agent can
+ * (a) consider providers authenticated and (b) include built-in models in its
+ * registry/catalog output.
+ *
+ * Syncs all credential types: api_key, token (as api_key), and oauth.
+ */
+export async function ensurePiAuthJsonFromAuthProfiles(agentDir) {
+    const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
+    const authPath = path.join(agentDir, "auth.json");
+    // Group profiles by provider, taking the first valid profile for each
+    const providerCredentials = new Map();
+    for (const [, cred] of Object.entries(store.profiles)) {
+        const provider = normalizeProviderId(String(cred.provider ?? "")).trim();
+        if (!provider || providerCredentials.has(provider)) {
+            continue;
+        }
+        const converted = convertCredential(cred);
+        if (converted) {
+            providerCredentials.set(provider, converted);
+        }
+    }
+    if (providerCredentials.size === 0) {
+        return { wrote: false, authPath };
+    }
+    const existing = await readAuthJson(authPath);
+    let changed = false;
+    for (const [provider, cred] of providerCredentials) {
+        if (!credentialsEqual(existing[provider], cred)) {
+            existing[provider] = cred;
+            changed = true;
+        }
+    }
+    if (!changed) {
+        return { wrote: false, authPath };
+    }
+    await fs.mkdir(agentDir, { recursive: true, mode: 0o700 });
+    await fs.writeFile(authPath, `${JSON.stringify(existing, null, 2)}\n`, { mode: 0o600 });
+    return { wrote: true, authPath };
+}

package/dist/agents/pi-embedded-runner/run.overflow-compaction.mocks.shared.js

@@ -0,0 +1,147 @@
+import { vi } from "vitest";
+vi.mock("../auth-profiles.js", () => ({
+    isProfileInCooldown: vi.fn(() => false),
+    markAuthProfileFailure: vi.fn(async () => { }),
+    markAuthProfileGood: vi.fn(async () => { }),
+    markAuthProfileUsed: vi.fn(async () => { }),
+}));
+vi.mock("../usage.js", () => ({
+    normalizeUsage: vi.fn((usage) => usage && typeof usage === "object" ? usage : undefined),
+    derivePromptTokens: vi.fn((usage) => {
+        if (!usage) {
+            return undefined;
+        }
+        const input = usage.input ?? 0;
+        const cacheRead = usage.cacheRead ?? 0;
+        const cacheWrite = usage.cacheWrite ?? 0;
+        const sum = input + cacheRead + cacheWrite;
+        return sum > 0 ? sum : undefined;
+    }),
+    hasNonzeroUsage: vi.fn(() => false),
+}));
+vi.mock("../workspace-run.js", () => ({
+    resolveRunWorkspaceDir: vi.fn((params) => ({
+        workspaceDir: params.workspaceDir,
+        usedFallback: false,
+        fallbackReason: undefined,
+        agentId: "main",
+    })),
+    redactRunIdentifier: vi.fn((value) => value ?? ""),
+}));
+vi.mock("../pi-embedded-helpers.js", () => ({
+    formatBillingErrorMessage: vi.fn(() => ""),
+    classifyFailoverReason: vi.fn(() => null),
+    formatAssistantErrorText: vi.fn(() => ""),
+    isAuthAssistantError: vi.fn(() => false),
+    isBillingAssistantError: vi.fn(() => false),
+    isCompactionFailureError: vi.fn(() => false),
+    isLikelyContextOverflowError: vi.fn((msg) => {
+        const lower = (msg ?? "").toLowerCase();
+        return lower.includes("request_too_large") || lower.includes("context window exceeded");
+    }),
+    isFailoverAssistantError: vi.fn(() => false),
+    isFailoverErrorMessage: vi.fn(() => false),
+    parseImageSizeError: vi.fn(() => null),
+    parseImageDimensionError: vi.fn(() => null),
+    isRateLimitAssistantError: vi.fn(() => false),
+    isTimeoutErrorMessage: vi.fn(() => false),
+    pickFallbackThinkingLevel: vi.fn(() => null),
+}));
+vi.mock("./run/attempt.js", () => ({
+    runEmbeddedAttempt: vi.fn(),
+}));
+vi.mock("./compact.js", () => ({
+    compactEmbeddedPiSessionDirect: vi.fn(),
+}));
+vi.mock("./model.js", () => ({
+    resolveModel: vi.fn(() => ({
+        model: {
+            id: "test-model",
+            provider: "anthropic",
+            contextWindow: 200000,
+            api: "messages",
+        },
+        error: null,
+        authStorage: {
+            setRuntimeApiKey: vi.fn(),
+        },
+        modelRegistry: {},
+    })),
+}));
+vi.mock("../model-auth.js", () => ({
+    ensureAuthProfileStore: vi.fn(() => ({})),
+    getApiKeyForModel: vi.fn(async () => ({
+        apiKey: "test-key",
+        profileId: "test-profile",
+        source: "test",
+    })),
+    resolveAuthProfileOrder: vi.fn(() => []),
+}));
+vi.mock("../models-config.js", () => ({
+    ensureOpenClawModelsJson: vi.fn(async () => { }),
+}));
+vi.mock("../context-window-guard.js", () => ({
+    CONTEXT_WINDOW_HARD_MIN_TOKENS: 1000,
+    CONTEXT_WINDOW_WARN_BELOW_TOKENS: 5000,
+    evaluateContextWindowGuard: vi.fn(() => ({
+        shouldWarn: false,
+        shouldBlock: false,
+        tokens: 200000,
+        source: "model",
+    })),
+    resolveContextWindowInfo: vi.fn(() => ({
+        tokens: 200000,
+        source: "model",
+    })),
+}));
+vi.mock("../../process/command-queue.js", () => ({
+    enqueueCommandInLane: vi.fn((_lane, task) => task()),
+}));
+vi.mock("../../utils/message-channel.js", () => ({
+    isMarkdownCapableMessageChannel: vi.fn(() => true),
+}));
+vi.mock("../agent-paths.js", () => ({
+    resolveOpenClawAgentDir: vi.fn(() => "/tmp/agent-dir"),
+}));
+vi.mock("../defaults.js", () => ({
+    DEFAULT_CONTEXT_TOKENS: 200000,
+    DEFAULT_MODEL: "test-model",
+    DEFAULT_PROVIDER: "anthropic",
+}));
+vi.mock("../failover-error.js", () => ({
+    FailoverError: class extends Error {
+    },
+    resolveFailoverStatus: vi.fn(),
+}));
+vi.mock("./lanes.js", () => ({
+    resolveSessionLane: vi.fn(() => "session-lane"),
+    resolveGlobalLane: vi.fn(() => "global-lane"),
+}));
+vi.mock("./logger.js", () => ({
+    log: {
+        debug: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        isEnabled: vi.fn(() => false),
+    },
+}));
+vi.mock("./run/payloads.js", () => ({
+    buildEmbeddedRunPayloads: vi.fn(() => []),
+}));
+vi.mock("./tool-result-truncation.js", () => ({
+    truncateOversizedToolResultsInSession: vi.fn(async () => ({
+        truncated: false,
+        truncatedCount: 0,
+        reason: "no oversized tool results",
+    })),
+    sessionLikelyHasOversizedToolResults: vi.fn(() => false),
+}));
+vi.mock("./utils.js", () => ({
+    describeUnknownError: vi.fn((err) => {
+        if (err instanceof Error) {
+            return err.message;
+        }
+        return String(err);
+    }),
+}));

package/dist/agents/pi-embedded-subscribe.e2e-harness.js

@@ -0,0 +1,90 @@
+import { expect } from "vitest";
+import { subscribeEmbeddedPiSession } from "./pi-embedded-subscribe.js";
+export function createStubSessionHarness() {
+    let handler;
+    const session = {
+        subscribe: (fn) => {
+            handler = fn;
+            return () => { };
+        },
+    };
+    return { session, emit: (evt) => handler?.(evt) };
+}
+export function createSubscribedSessionHarness(params) {
+    const { sessionExtras, ...subscribeParams } = params;
+    const { session, emit } = createStubSessionHarness();
+    const mergedSession = Object.assign(session, sessionExtras ?? {});
+    const subscription = subscribeEmbeddedPiSession({
+        ...subscribeParams,
+        session: mergedSession,
+    });
+    return { emit, session: mergedSession, subscription };
+}
+export function createParagraphChunkedBlockReplyHarness(params) {
+    const onBlockReply = params.onBlockReply ?? (() => { });
+    const { emit, subscription } = createSubscribedSessionHarness({
+        runId: params.runId ?? "run",
+        onBlockReply,
+        blockReplyBreak: "message_end",
+        blockReplyChunking: {
+            ...params.chunking,
+            breakPreference: "paragraph",
+        },
+    });
+    return { emit, onBlockReply, subscription };
+}
+export function extractAgentEventPayloads(calls) {
+    return calls
+        .map((call) => {
+        const first = call?.[0];
+        const data = first?.data;
+        return data && typeof data === "object" ? data : undefined;
+    })
+        .filter((value) => Boolean(value));
+}
+export function extractTextPayloads(calls) {
+    return calls
+        .map((call) => {
+        const payload = call?.[0];
+        return typeof payload?.text === "string" ? payload.text : undefined;
+    })
+        .filter((text) => Boolean(text));
+}
+export function emitMessageStartAndEndForAssistantText(params) {
+    const assistantMessage = {
+        role: "assistant",
+        content: [{ type: "text", text: params.text }],
+    };
+    params.emit({ type: "message_start", message: assistantMessage });
+    params.emit({ type: "message_end", message: assistantMessage });
+}
+export function emitAssistantTextDeltaAndEnd(params) {
+    params.emit({
+        type: "message_update",
+        message: { role: "assistant" },
+        assistantMessageEvent: {
+            type: "text_delta",
+            delta: params.text,
+        },
+    });
+    const assistantMessage = {
+        role: "assistant",
+        content: [{ type: "text", text: params.text }],
+    };
+    params.emit({ type: "message_end", message: assistantMessage });
+}
+export function expectFencedChunks(calls, expectedPrefix) {
+    expect(calls.length).toBeGreaterThan(1);
+    for (const call of calls) {
+        const chunk = call[0]?.text;
+        expect(typeof chunk === "string" && chunk.startsWith(expectedPrefix)).toBe(true);
+        const fenceCount = typeof chunk === "string" ? (chunk.match(/```/g)?.length ?? 0) : 0;
+        expect(fenceCount).toBeGreaterThanOrEqual(2);
+    }
+}
+export function expectSingleAgentEventText(calls, text) {
+    const payloads = extractAgentEventPayloads(calls);
+    expect(payloads).toHaveLength(1);
+    expect(payloads[0]?.text).toBe(text);
+    expect(payloads[0]?.delta).toBe(text);
+}

package/dist/agents/pi-embedded-subscribe.handlers.compaction.js

@@ -0,0 +1,63 @@
+import { emitAgentEvent } from "../infra/agent-events.js";
+import { getGlobalHookRunner } from "../plugins/hook-runner-global.js";
+export function handleAutoCompactionStart(ctx) {
+    ctx.state.compactionInFlight = true;
+    ctx.incrementCompactionCount();
+    ctx.ensureCompactionPromise();
+    ctx.log.debug(`embedded run compaction start: runId=${ctx.params.runId}`);
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "compaction",
+        data: { phase: "start" },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "compaction",
+        data: { phase: "start" },
+    });
+    // Run before_compaction plugin hook (fire-and-forget)
+    const hookRunner = getGlobalHookRunner();
+    if (hookRunner?.hasHooks("before_compaction")) {
+        void hookRunner
+            .runBeforeCompaction({
+            messageCount: ctx.params.session.messages?.length ?? 0,
+        }, {})
+            .catch((err) => {
+            ctx.log.warn(`before_compaction hook failed: ${String(err)}`);
+        });
+    }
+}
+export function handleAutoCompactionEnd(ctx, evt) {
+    ctx.state.compactionInFlight = false;
+    const willRetry = Boolean(evt.willRetry);
+    if (willRetry) {
+        ctx.noteCompactionRetry();
+        ctx.resetForCompactionRetry();
+        ctx.log.debug(`embedded run compaction retry: runId=${ctx.params.runId}`);
+    }
+    else {
+        ctx.maybeResolveCompactionWait();
+    }
+    emitAgentEvent({
+        runId: ctx.params.runId,
+        stream: "compaction",
+        data: { phase: "end", willRetry },
+    });
+    void ctx.params.onAgentEvent?.({
+        stream: "compaction",
+        data: { phase: "end", willRetry },
+    });
+    // Run after_compaction plugin hook (fire-and-forget)
+    if (!willRetry) {
+        const hookRunnerEnd = getGlobalHookRunner();
+        if (hookRunnerEnd?.hasHooks("after_compaction")) {
+            void hookRunnerEnd
+                .runAfterCompaction({
+                messageCount: ctx.params.session.messages?.length ?? 0,
+                compactedCount: ctx.getCompactionCount(),
+            }, {})
+                .catch((err) => {
+                ctx.log.warn(`after_compaction hook failed: ${String(err)}`);
+            });
+        }
+    }
+}

package/dist/agents/pi-embedded-subscribe.handlers.tools.media.test-helpers.js

@@ -0,0 +1,30 @@
+import { handleToolExecutionEnd, handleToolExecutionStart, } from "./pi-embedded-subscribe.handlers.tools.js";
+/** Type-safe bridge: narrows parameter type so callers avoid assertions. */
+function asFullContext(ctx) {
+    return ctx;
+}
+/** Typed wrapper around {@link handleToolExecutionStart}. */
+export function callToolExecutionStart(ctx, evt) {
+    return handleToolExecutionStart(asFullContext(ctx), evt);
+}
+/** Typed wrapper around {@link handleToolExecutionEnd}. */
+export async function callToolExecutionEnd(ctx, evt) {
+    return handleToolExecutionEnd(asFullContext(ctx), evt);
+}
+/**
+ * Check whether a mock-call argument is an object containing `mediaUrls`
+ * but NOT `text` (i.e. a "direct media" emission).
+ */
+export function isDirectMediaCall(call) {
+    const arg = call[0];
+    if (!arg || typeof arg !== "object") {
+        return false;
+    }
+    return "mediaUrls" in arg && !("text" in arg);
+}
+/**
+ * Filter a vi.fn() mock's call log to only direct-media emissions.
+ */
+export function filterDirectMediaCalls(mock) {
+    return mock.mock.calls.filter(isDirectMediaCall);
+}

package/dist/agents/pi-extensions/session-manager-runtime-registry.js

@@ -0,0 +1,23 @@
+export function createSessionManagerRuntimeRegistry() {
+    // Session-scoped runtime registry keyed by object identity.
+    // The SessionManager instance must stay stable across set/get calls.
+    const registry = new WeakMap();
+    const set = (sessionManager, value) => {
+        if (!sessionManager || typeof sessionManager !== "object") {
+            return;
+        }
+        const key = sessionManager;
+        if (value === null) {
+            registry.delete(key);
+            return;
+        }
+        registry.set(key, value);
+    };
+    const get = (sessionManager) => {
+        if (!sessionManager || typeof sessionManager !== "object") {
+            return null;
+        }
+        return registry.get(sessionManager) ?? null;
+    };
+    return { set, get };
+}

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

@@ -3,13 +3,108 @@ 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 };
     }
-    const toolName = normalizeToolName(args.toolName || "tool");
-    const params = args.params;
     try {
         const normalizedParams = isPlainObject(params) ? params : {};
         const hookResult = await hookRunner.runBeforeToolCall({
@@ -45,7 +140,7 @@ export function wrapToolWithBeforeToolCallHook(tool, ctx) {
         return tool;
     }
     const toolName = tool.name || "tool";
-    return {
+    const wrappedTool = {
         ...tool,
         execute: async (toolCallId, params, signal, onUpdate) => {
             const outcome = await runBeforeToolCallHook({
@@ -57,11 +152,57 @@ export function wrapToolWithBeforeToolCallHook(tool, ctx) {
             if (outcome.blocked) {
                 throw new Error(outcome.reason);
             }
-            return await execute(toolCallId, outcome.params, signal, onUpdate);
+            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: false,
+    });
+    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,
 };