@poolzin/pool-bot 2026.2.17 → 2026.2.18

package/dist/agents/model-alias-lines.js

@@ -0,0 +1,18 @@
+export function buildModelAliasLines(cfg) {
+    const models = cfg?.agents?.defaults?.models ?? {};
+    const entries = [];
+    for (const [keyRaw, entryRaw] of Object.entries(models)) {
+        const model = String(keyRaw ?? "").trim();
+        if (!model) {
+            continue;
+        }
+        const alias = String(entryRaw?.alias ?? "").trim();
+        if (!alias) {
+            continue;
+        }
+        entries.push({ alias, model });
+    }
+    return entries
+        .toSorted((a, b) => a.alias.localeCompare(b.alias))
+        .map((entry) => `- ${entry.alias}: ${entry.model}`);
+}

package/dist/agents/model-auth-label.js

@@ -0,0 +1,61 @@
+import { ensureAuthProfileStore, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "./auth-profiles.js";
+import { getCustomProviderApiKey, resolveEnvApiKey } from "./model-auth.js";
+import { normalizeProviderId } from "./model-selection.js";
+function formatApiKeySnippet(apiKey) {
+    const compact = apiKey.replace(/\s+/g, "");
+    if (!compact) {
+        return "unknown";
+    }
+    const edge = compact.length >= 12 ? 6 : 4;
+    const head = compact.slice(0, edge);
+    const tail = compact.slice(-edge);
+    return `${head}…${tail}`;
+}
+export function resolveModelAuthLabel(params) {
+    const resolvedProvider = params.provider?.trim();
+    if (!resolvedProvider) {
+        return undefined;
+    }
+    const providerKey = normalizeProviderId(resolvedProvider);
+    const store = ensureAuthProfileStore(params.agentDir, {
+        allowKeychainPrompt: false,
+    });
+    const profileOverride = params.sessionEntry?.authProfileOverride?.trim();
+    const order = resolveAuthProfileOrder({
+        cfg: params.cfg,
+        store,
+        provider: providerKey,
+        preferredProfile: profileOverride,
+    });
+    const candidates = [profileOverride, ...order].filter(Boolean);
+    for (const profileId of candidates) {
+        const profile = store.profiles[profileId];
+        if (!profile || normalizeProviderId(profile.provider) !== providerKey) {
+            continue;
+        }
+        const label = resolveAuthProfileDisplayLabel({
+            cfg: params.cfg,
+            store,
+            profileId,
+        });
+        if (profile.type === "oauth") {
+            return `oauth${label ? ` (${label})` : ""}`;
+        }
+        if (profile.type === "token") {
+            return `token ${formatApiKeySnippet(profile.token)}${label ? ` (${label})` : ""}`;
+        }
+        return `api-key ${formatApiKeySnippet(profile.key ?? "")}${label ? ` (${label})` : ""}`;
+    }
+    const envKey = resolveEnvApiKey(providerKey);
+    if (envKey?.apiKey) {
+        if (envKey.source.includes("OAUTH_TOKEN")) {
+            return `oauth (${envKey.source})`;
+        }
+        return `api-key ${formatApiKeySnippet(envKey.apiKey)} (${envKey.source})`;
+    }
+    const customKey = getCustomProviderApiKey(params.cfg, providerKey);
+    if (customKey) {
+        return `api-key ${formatApiKeySnippet(customKey)} (models.json)`;
+    }
+    return "unknown";
+}

package/dist/agents/models-config.e2e-harness.js

@@ -0,0 +1,115 @@
+import { withTempHome as withTempHomeBase } from "../../test/helpers/temp-home.js";
+import { afterEach, beforeEach, vi } from "vitest";
+export async function withModelsTempHome(fn) {
+    return withTempHomeBase(fn, { prefix: "openclaw-models-" });
+}
+export function installModelsConfigTestHooks(opts) {
+    let previousHome;
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        previousHome = process.env.HOME;
+    });
+    afterEach(() => {
+        process.env.HOME = previousHome;
+        if (opts?.restoreFetch && originalFetch) {
+            globalThis.fetch = originalFetch;
+        }
+    });
+}
+export async function withTempEnv(vars, fn) {
+    const previous = {};
+    for (const envVar of vars) {
+        previous[envVar] = process.env[envVar];
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        for (const envVar of vars) {
+            const value = previous[envVar];
+            if (value === undefined) {
+                delete process.env[envVar];
+            }
+            else {
+                process.env[envVar] = value;
+            }
+        }
+    }
+}
+export function unsetEnv(vars) {
+    for (const envVar of vars) {
+        delete process.env[envVar];
+    }
+}
+export const COPILOT_TOKEN_ENV_VARS = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
+export async function withUnsetCopilotTokenEnv(fn) {
+    return withTempEnv(COPILOT_TOKEN_ENV_VARS, async () => {
+        unsetEnv(COPILOT_TOKEN_ENV_VARS);
+        return fn();
+    });
+}
+export function mockCopilotTokenExchangeSuccess() {
+    const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        json: async () => ({
+            token: "copilot-token;proxy-ep=proxy.copilot.example",
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+        }),
+    });
+    globalThis.fetch = fetchMock;
+    return fetchMock;
+}
+export const MODELS_CONFIG_IMPLICIT_ENV_VARS = [
+    "CLOUDFLARE_AI_GATEWAY_API_KEY",
+    "COPILOT_GITHUB_TOKEN",
+    "GH_TOKEN",
+    "GITHUB_TOKEN",
+    "HF_TOKEN",
+    "HUGGINGFACE_HUB_TOKEN",
+    "MINIMAX_API_KEY",
+    "MOONSHOT_API_KEY",
+    "NVIDIA_API_KEY",
+    "OLLAMA_API_KEY",
+    "POOLBOT_AGENT_DIR",
+    "PI_CODING_AGENT_DIR",
+    "QIANFAN_API_KEY",
+    "SYNTHETIC_API_KEY",
+    "TOGETHER_API_KEY",
+    "VENICE_API_KEY",
+    "VLLM_API_KEY",
+    "XIAOMI_API_KEY",
+    // Avoid ambient AWS creds unintentionally enabling Bedrock discovery.
+    "AWS_ACCESS_KEY_ID",
+    "AWS_CONFIG_FILE",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "AWS_DEFAULT_REGION",
+    "AWS_PROFILE",
+    "AWS_REGION",
+    "AWS_SESSION_TOKEN",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SHARED_CREDENTIALS_FILE",
+];
+export const CUSTOM_PROXY_MODELS_CONFIG = {
+    models: {
+        providers: {
+            "custom-proxy": {
+                baseUrl: "http://localhost:4000/v1",
+                apiKey: "TEST_KEY",
+                api: "openai-completions",
+                models: [
+                    {
+                        id: "llama-3.1-8b",
+                        name: "Llama 3.1 8B (Proxy)",
+                        api: "openai-completions",
+                        reasoning: false,
+                        input: ["text"],
+                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                        contextWindow: 128000,
+                        maxTokens: 32000,
+                    },
+                ],
+            },
+        },
+    },
+};

package/dist/agents/ollama-stream.js

@@ -1,5 +1,5 @@
-import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
 import { randomUUID } from "node:crypto";
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
 export const OLLAMA_NATIVE_BASE_URL = "http://127.0.0.1:11434";
 function extractTextContent(content) {
     if (typeof content === "string") {
@@ -102,8 +102,12 @@ function extractOllamaTools(tools) {
 // ── Response conversion ─────────────────────────────────────────────────────
 export function buildAssistantMessage(response, modelInfo) {
     const content = [];
-    if (response.message.content) {
-        content.push({ type: "text", text: response.message.content });
+    // Qwen 3 (and potentially other reasoning models) may return their final
+    // answer in a `reasoning` field with an empty `content`. Fall back to
+    // `reasoning` so the response isn't silently dropped.
+    const text = response.message.content || response.message.reasoning || "";
+    if (text) {
+        content.push({ type: "text", text });
     }
     const toolCalls = response.message.tool_calls;
     if (toolCalls && toolCalls.length > 0) {
@@ -230,6 +234,10 @@ export function createOllamaStreamFn(baseUrl) {
                     if (chunk.message?.content) {
                         accumulatedContent += chunk.message.content;
                     }
+                    else if (chunk.message?.reasoning) {
+                        // Qwen 3 reasoning mode: content may be empty, output in reasoning
+                        accumulatedContent += chunk.message.reasoning;
+                    }
                     // Ollama sends tool_calls in intermediate (done:false) chunks,
                     // NOT in the final done:true chunk. Collect from all chunks.
                     if (chunk.message?.tool_calls) {

package/dist/agents/openclaw-tools.js

@@ -0,0 +1,135 @@
+import { resolvePluginTools } from "../plugins/tools.js";
+import { resolveSessionAgentId } from "./agent-scope.js";
+import { createAgentsListTool } from "./tools/agents-list-tool.js";
+import { createBrowserTool } from "./tools/browser-tool.js";
+import { createCanvasTool } from "./tools/canvas-tool.js";
+import { createCronTool } from "./tools/cron-tool.js";
+import { createGatewayTool } from "./tools/gateway-tool.js";
+import { createImageTool } from "./tools/image-tool.js";
+import { createMessageTool } from "./tools/message-tool.js";
+import { createNodesTool } from "./tools/nodes-tool.js";
+import { createSessionStatusTool } from "./tools/session-status-tool.js";
+import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
+import { createSessionsListTool } from "./tools/sessions-list-tool.js";
+import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
+import { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
+import { createSubagentsTool } from "./tools/subagents-tool.js";
+import { createTtsTool } from "./tools/tts-tool.js";
+import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
+import { resolveWorkspaceRoot } from "./workspace-dir.js";
+export function createOpenClawTools(options) {
+    const workspaceDir = resolveWorkspaceRoot(options?.workspaceDir);
+    const imageTool = options?.agentDir?.trim()
+        ? createImageTool({
+            config: options?.config,
+            agentDir: options.agentDir,
+            workspaceDir,
+            sandbox: options?.sandboxRoot && options?.sandboxFsBridge
+                ? { root: options.sandboxRoot, bridge: options.sandboxFsBridge }
+                : undefined,
+            modelHasVision: options?.modelHasVision,
+        })
+        : null;
+    const webSearchTool = createWebSearchTool({
+        config: options?.config,
+        sandboxed: options?.sandboxed,
+    });
+    const webFetchTool = createWebFetchTool({
+        config: options?.config,
+        sandboxed: options?.sandboxed,
+    });
+    const messageTool = options?.disableMessageTool
+        ? null
+        : createMessageTool({
+            agentAccountId: options?.agentAccountId,
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+            currentChannelId: options?.currentChannelId,
+            currentChannelProvider: options?.agentChannel,
+            currentThreadTs: options?.currentThreadTs,
+            replyToMode: options?.replyToMode,
+            hasRepliedRef: options?.hasRepliedRef,
+            sandboxRoot: options?.sandboxRoot,
+            requireExplicitTarget: options?.requireExplicitMessageTarget,
+        });
+    const tools = [
+        createBrowserTool({
+            sandboxBridgeUrl: options?.sandboxBrowserBridgeUrl,
+            allowHostControl: options?.allowHostBrowserControl,
+        }),
+        createCanvasTool(),
+        createNodesTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        createCronTool({
+            agentSessionKey: options?.agentSessionKey,
+        }),
+        ...(messageTool ? [messageTool] : []),
+        createTtsTool({
+            agentChannel: options?.agentChannel,
+            config: options?.config,
+        }),
+        createGatewayTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        createAgentsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            requesterAgentIdOverride: options?.requesterAgentIdOverride,
+        }),
+        createSessionsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsHistoryTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSpawnTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            agentAccountId: options?.agentAccountId,
+            agentTo: options?.agentTo,
+            agentThreadId: options?.agentThreadId,
+            agentGroupId: options?.agentGroupId,
+            agentGroupChannel: options?.agentGroupChannel,
+            agentGroupSpace: options?.agentGroupSpace,
+            sandboxed: options?.sandboxed,
+            requesterAgentIdOverride: options?.requesterAgentIdOverride,
+        }),
+        createSubagentsTool({
+            agentSessionKey: options?.agentSessionKey,
+        }),
+        createSessionStatusTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        ...(webSearchTool ? [webSearchTool] : []),
+        ...(webFetchTool ? [webFetchTool] : []),
+        ...(imageTool ? [imageTool] : []),
+    ];
+    const pluginTools = resolvePluginTools({
+        context: {
+            config: options?.config,
+            workspaceDir,
+            agentDir: options?.agentDir,
+            agentId: resolveSessionAgentId({
+                sessionKey: options?.agentSessionKey,
+                config: options?.config,
+            }),
+            sessionKey: options?.agentSessionKey,
+            messageChannel: options?.agentChannel,
+            agentAccountId: options?.agentAccountId,
+            sandboxed: options?.sandboxed,
+        },
+        existingToolNames: new Set(tools.map((tool) => tool.name)),
+        toolAllowlist: options?.pluginToolAllowlist,
+    });
+    return [...tools, ...pluginTools];
+}

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);
+    }),
+}));