@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/agents/subagent-registry.js

@@ -1,6 +1,7 @@
 import { loadConfig } from "../config/config.js";
 import { callGateway } from "../gateway/call.js";
 import { onAgentEvent } from "../infra/agent-events.js";
+import { defaultRuntime } from "../runtime.js";
 import { normalizeDeliveryContext } from "../utils/delivery-context.js";
 import { resetAnnounceQueuesForTests } from "./subagent-announce-queue.js";
 import { runSubagentAnnounceFlow } from "./subagent-announce.js";
@@ -13,6 +14,8 @@ let listenerStop = null;
 // Use var to avoid TDZ when init runs across circular imports during bootstrap.
 var restoreAttempted = false;
 const SUBAGENT_ANNOUNCE_TIMEOUT_MS = 120_000;
+const MIN_ANNOUNCE_RETRY_DELAY_MS = 1_000;
+const MAX_ANNOUNCE_RETRY_DELAY_MS = 8_000;
 /**
  * Maximum number of announce delivery attempts before giving up.
  * Prevents infinite retry loops when `runSubagentAnnounceFlow` repeatedly
@@ -24,7 +27,19 @@ const MAX_ANNOUNCE_RETRY_COUNT = 3;
  * succeeded. Guards against stale registry entries surviving gateway restarts.
  */
 const ANNOUNCE_EXPIRY_MS = 5 * 60_000; // 5 minutes
-// (Backoff constant removed — max-retry + expiry guards are sufficient.)
+function resolveAnnounceRetryDelayMs(retryCount) {
+    const boundedRetryCount = Math.max(0, Math.min(retryCount, 10));
+    // retryCount is "attempts already made", so retry #1 waits 1s, then 2s, 4s...
+    const backoffExponent = Math.max(0, boundedRetryCount - 1);
+    const baseDelay = MIN_ANNOUNCE_RETRY_DELAY_MS * 2 ** backoffExponent;
+    return Math.min(baseDelay, MAX_ANNOUNCE_RETRY_DELAY_MS);
+}
+function logAnnounceGiveUp(entry, reason) {
+    const retryCount = entry.announceRetryCount ?? 0;
+    const endedAgoMs = typeof entry.endedAt === "number" ? Math.max(0, Date.now() - entry.endedAt) : undefined;
+    const endedAgoLabel = endedAgoMs != null ? `${Math.round(endedAgoMs / 1000)}s` : "n/a";
+    defaultRuntime.log(`[warn] Subagent announce give up (${reason}) run=${entry.runId} child=${entry.childSessionKey} requester=${entry.requesterSessionKey} retries=${retryCount} endedAgo=${endedAgoLabel}`);
+}
 function persistSubagentRuns() {
     try {
         saveSubagentRegistryToDisk(subagentRuns);
@@ -49,6 +64,7 @@ function startSubagentAnnounceCleanupFlow(runId, entry) {
         requesterOrigin,
         requesterDisplayKey: entry.requesterDisplayKey,
         task: entry.task,
+        expectsCompletionMessage: entry.expectsCompletionMessage,
         timeoutMs: SUBAGENT_ANNOUNCE_TIMEOUT_MS,
         cleanup: entry.cleanup,
         waitForCompletion: false,
@@ -74,15 +90,30 @@ function resumeSubagentRun(runId) {
     }
     // Skip entries that have exhausted their retry budget or expired (#18264).
     if ((entry.announceRetryCount ?? 0) >= MAX_ANNOUNCE_RETRY_COUNT) {
+        logAnnounceGiveUp(entry, "retry-limit");
         entry.cleanupCompletedAt = Date.now();
         persistSubagentRuns();
         return;
     }
     if (typeof entry.endedAt === "number" && Date.now() - entry.endedAt > ANNOUNCE_EXPIRY_MS) {
+        logAnnounceGiveUp(entry, "expiry");
         entry.cleanupCompletedAt = Date.now();
         persistSubagentRuns();
         return;
     }
+    const now = Date.now();
+    const delayMs = resolveAnnounceRetryDelayMs(entry.announceRetryCount ?? 0);
+    const earliestRetryAt = (entry.lastAnnounceRetryAt ?? 0) + delayMs;
+    if (entry.expectsCompletionMessage === true &&
+        entry.lastAnnounceRetryAt &&
+        now < earliestRetryAt) {
+        const waitMs = Math.max(1, earliestRetryAt - now);
+        setTimeout(() => {
+            resumeSubagentRun(runId);
+        }, waitMs).unref?.();
+        resumedRuns.add(runId);
+        return;
+    }
     if (typeof entry.endedAt === "number" && entry.endedAt > 0) {
         if (suppressAnnounceForSteerRestart(entry)) {
             resumedRuns.add(runId);
@@ -238,14 +269,16 @@ function finalizeSubagentCleanup(runId, cleanup, didAnnounce) {
         return;
     }
     if (!didAnnounce) {
+        const now = Date.now();
         const retryCount = (entry.announceRetryCount ?? 0) + 1;
         entry.announceRetryCount = retryCount;
-        entry.lastAnnounceRetryAt = Date.now();
+        entry.lastAnnounceRetryAt = now;
         // Check if the announce has exceeded retry limits or expired (#18264).
-        const endedAgo = typeof entry.endedAt === "number" ? Date.now() - entry.endedAt : 0;
+        const endedAgo = typeof entry.endedAt === "number" ? now - entry.endedAt : 0;
         if (retryCount >= MAX_ANNOUNCE_RETRY_COUNT || endedAgo > ANNOUNCE_EXPIRY_MS) {
             // Give up: mark as completed to break the infinite retry loop.
-            entry.cleanupCompletedAt = Date.now();
+            logAnnounceGiveUp(entry, retryCount >= MAX_ANNOUNCE_RETRY_COUNT ? "retry-limit" : "expiry");
+            entry.cleanupCompletedAt = now;
             persistSubagentRuns();
             retryDeferredCompletedAnnounces(runId);
             return;
@@ -254,6 +287,12 @@ function finalizeSubagentCleanup(runId, cleanup, didAnnounce) {
         entry.cleanupHandled = false;
         resumedRuns.delete(runId);
         persistSubagentRuns();
+        if (entry.expectsCompletionMessage !== true) {
+            return;
+        }
+        setTimeout(() => {
+            resumeSubagentRun(runId);
+        }, resolveAnnounceRetryDelayMs(entry.announceRetryCount ?? 0)).unref?.();
         return;
     }
     if (cleanup === "delete") {
@@ -284,6 +323,7 @@ function retryDeferredCompletedAnnounces(excludeRunId) {
         // Force-expire announces that have been pending too long (#18264).
         const endedAgo = now - (entry.endedAt ?? now);
         if (endedAgo > ANNOUNCE_EXPIRY_MS) {
+            logAnnounceGiveUp(entry, "expiry");
             entry.cleanupCompletedAt = now;
             persistSubagentRuns();
             continue;
@@ -405,6 +445,7 @@ export function registerSubagentRun(params) {
         requesterDisplayKey: params.requesterDisplayKey,
         task: params.task,
         cleanup: params.cleanup,
+        expectsCompletionMessage: params.expectsCompletionMessage,
         label: params.label,
         model: params.model,
         runTimeoutSeconds,

package/dist/agents/subagent-spawn.js

@@ -6,12 +6,13 @@ import { normalizeAgentId, parseAgentSessionKey } from "../routing/session-key.j
 import { normalizeDeliveryContext } from "../utils/delivery-context.js";
 import { resolveAgentConfig } from "./agent-scope.js";
 import { AGENT_LANE_SUBAGENT } from "./lanes.js";
-import { resolveDefaultModelForAgent } from "./model-selection.js";
+import { resolveSubagentSpawnModelSelection } from "./model-selection.js";
 import { buildSubagentSystemPrompt } from "./subagent-announce.js";
 import { getSubagentDepthFromSessionStore } from "./subagent-depth.js";
 import { countActiveRunsForSession, registerSubagentRun } from "./subagent-registry.js";
 import { readStringParam } from "./tools/common.js";
 import { resolveDisplaySessionKey, resolveInternalSessionKey, resolveMainSessionAlias, } from "./tools/sessions-helpers.js";
+export const SUBAGENT_SPAWN_ACCEPTED_NOTE = "auto-announces on completion, do not poll/sleep. The response will be sent back as an agent message.";
 export function splitModelRef(ref) {
     if (!ref) {
         return { provider: undefined, model: undefined };
@@ -26,20 +27,6 @@ export function splitModelRef(ref) {
     }
     return { provider: undefined, model: trimmed };
 }
-export function normalizeModelSelection(value) {
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        return trimmed || undefined;
-    }
-    if (!value || typeof value !== "object") {
-        return undefined;
-    }
-    const primary = value.primary;
-    if (typeof primary === "string" && primary.trim()) {
-        return primary.trim();
-    }
-    return undefined;
-}
 export async function spawnSubagentDirect(params, ctx) {
     const task = params.task;
     const label = params.label?.trim() || "";
@@ -56,7 +43,6 @@ export async function spawnSubagentDirect(params, ctx) {
     const runTimeoutSeconds = typeof params.runTimeoutSeconds === "number" && Number.isFinite(params.runTimeoutSeconds)
         ? Math.max(0, Math.floor(params.runTimeoutSeconds))
         : 0;
-    let modelWarning;
     let modelApplied = false;
     const cfg = loadConfig();
     const { mainKey, alias } = resolveMainSessionAlias(cfg);
@@ -110,15 +96,11 @@ export async function spawnSubagentDirect(params, ctx) {
     const childDepth = callerDepth + 1;
     const spawnedByKey = requesterInternalKey;
     const targetAgentConfig = resolveAgentConfig(cfg, targetAgentId);
-    const runtimeDefaultModel = resolveDefaultModelForAgent({
+    const resolvedModel = resolveSubagentSpawnModelSelection({
         cfg,
         agentId: targetAgentId,
+        modelOverride,
     });
-    const resolvedModel = normalizeModelSelection(modelOverride) ??
-        normalizeModelSelection(targetAgentConfig?.subagents?.model) ??
-        normalizeModelSelection(cfg.agents?.defaults?.subagents?.model) ??
-        normalizeModelSelection(cfg.agents?.defaults?.model?.primary) ??
-        normalizeModelSelection(`${runtimeDefaultModel.provider}/${runtimeDefaultModel.model}`);
     const resolvedThinkingDefaultRaw = readStringParam(targetAgentConfig?.subagents ?? {}, "thinking") ??
         readStringParam(cfg.agents?.defaults?.subagents ?? {}, "thinking");
     let thinkingOverride;
@@ -161,15 +143,11 @@ export async function spawnSubagentDirect(params, ctx) {
         }
         catch (err) {
             const messageText = err instanceof Error ? err.message : typeof err === "string" ? err : "error";
-            const recoverable = messageText.includes("invalid model") || messageText.includes("model not allowed");
-            if (!recoverable) {
-                return {
-                    status: "error",
-                    error: messageText,
-                    childSessionKey,
-                };
-            }
-            modelWarning = messageText;
+            return {
+                status: "error",
+                error: messageText,
+                childSessionKey,
+            };
         }
     }
     if (thinkingOverride !== undefined) {
@@ -201,13 +179,17 @@ export async function spawnSubagentDirect(params, ctx) {
         childDepth,
         maxSpawnDepth,
     });
+    const childTaskMessage = [
+        `[Subagent Context] You are running as a subagent (depth ${childDepth}/${maxSpawnDepth}). Results auto-announce to your requester; do not busy-poll for status.`,
+        `[Subagent Task]: ${task}`,
+    ].join("\n\n");
     const childIdem = crypto.randomUUID();
     let childRunId = childIdem;
     try {
         const response = await callGateway({
             method: "agent",
             params: {
-                message: task,
+                message: childTaskMessage,
                 sessionKey: childSessionKey,
                 channel: requesterOrigin?.channel,
                 to: requesterOrigin?.to ?? undefined,
@@ -251,12 +233,13 @@ export async function spawnSubagentDirect(params, ctx) {
         label: label || undefined,
         model: resolvedModel,
         runTimeoutSeconds,
+        expectsCompletionMessage: params.expectsCompletionMessage === true,
     });
     return {
         status: "accepted",
         childSessionKey,
         runId: childRunId,
+        note: SUBAGENT_SPAWN_ACCEPTED_NOTE,
         modelApplied: resolvedModel ? modelApplied : undefined,
-        warning: modelWarning,
     };
 }

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

@@ -1,16 +1,20 @@
+import path from "node:path";
 function extractBetween(input, startMarker, endMarker) {
     const start = input.indexOf(startMarker);
-    if (start === -1)
+    if (start === -1) {
         return { text: "", found: false };
+    }
     const end = input.indexOf(endMarker, start + startMarker.length);
-    if (end === -1)
+    if (end === -1) {
         return { text: input.slice(start), found: true };
+    }
     return { text: input.slice(start, end), found: true };
 }
 function parseSkillBlocks(skillsPrompt) {
     const prompt = skillsPrompt.trim();
-    if (!prompt)
+    if (!prompt) {
         return [];
+    }
     const blocks = Array.from(prompt.matchAll(/<skill>[\s\S]*?<\/skill>/gi)).map((match) => match[0] ?? "");
     return blocks
         .map((block) => {
@@ -20,12 +24,22 @@ function parseSkillBlocks(skillsPrompt) {
         .filter((b) => b.blockChars > 0);
 }
 function buildInjectedWorkspaceFiles(params) {
-    const injectedByName = new Map(params.injectedFiles.map((f) => [f.path, f.content]));
+    const injectedByPath = new Map(params.injectedFiles.map((f) => [f.path, f.content]));
+    const injectedByBaseName = new Map();
+    for (const file of params.injectedFiles) {
+        const normalizedPath = file.path.replace(/\\/g, "/");
+        const baseName = path.posix.basename(normalizedPath);
+        if (!injectedByBaseName.has(baseName)) {
+            injectedByBaseName.set(baseName, file.content);
+        }
+    }
     return params.bootstrapFiles.map((file) => {
         const rawChars = file.missing ? 0 : (file.content ?? "").trimEnd().length;
-        const injected = injectedByName.get(file.name);
+        const injected = injectedByPath.get(file.path) ??
+            injectedByPath.get(file.name) ??
+            injectedByBaseName.get(file.name);
         const injectedChars = injected ? injected.length : 0;
-        const truncated = !file.missing && rawChars > params.bootstrapMaxChars;
+        const truncated = !file.missing && injectedChars < rawChars;
         return {
             name: file.name,
             path: file.path,
@@ -42,8 +56,9 @@ function buildToolsEntries(tools) {
         const summary = tool.description?.trim() || tool.label?.trim() || "";
         const summaryChars = summary.length;
         const schemaChars = (() => {
-            if (!tool.parameters || typeof tool.parameters !== "object")
+            if (!tool.parameters || typeof tool.parameters !== "object") {
                 return 0;
+            }
             try {
                 return JSON.stringify(tool.parameters).length;
             }
@@ -56,8 +71,9 @@ function buildToolsEntries(tools) {
                 ? tool.parameters
                 : null;
             const props = schema && typeof schema.properties === "object" ? schema.properties : null;
-            if (!props || typeof props !== "object")
+            if (!props || typeof props !== "object") {
                 return null;
+            }
             return Object.keys(props).length;
         })();
         return { name, summaryChars, schemaChars, propertiesCount };
@@ -67,8 +83,9 @@ function extractToolListText(systemPrompt) {
     const markerA = "Tool names are case-sensitive. Call tools exactly as listed.\n";
     const markerB = "\nTOOLS.md does not control tool availability; it is user guidance for how to use external tools.";
     const extracted = extractBetween(systemPrompt, markerA, markerB);
-    if (!extracted.found)
+    if (!extracted.found) {
         return "";
+    }
     return extracted.text.replace(markerA, "").trim();
 }
 export function buildSystemPromptReport(params) {
@@ -89,6 +106,7 @@ export function buildSystemPromptReport(params) {
         model: params.model,
         workspaceDir: params.workspaceDir,
         bootstrapMaxChars: params.bootstrapMaxChars,
+        bootstrapTotalMaxChars: params.bootstrapTotalMaxChars,
         sandbox: params.sandbox,
         systemPrompt: {
             chars: systemPrompt.length,
@@ -98,7 +116,6 @@ export function buildSystemPromptReport(params) {
         injectedWorkspaceFiles: buildInjectedWorkspaceFiles({
             bootstrapFiles: params.bootstrapFiles,
             injectedFiles: params.injectedFiles,
-            bootstrapMaxChars: params.bootstrapMaxChars,
         }),
         skills: {
             promptChars: params.skillsPrompt.length,

package/dist/agents/system-prompt.js

@@ -2,11 +2,13 @@ import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";
 import { listDeliverableMessageChannels } from "../utils/message-channel.js";
 import { sanitizeForPromptLiteral } from "./sanitize-for-prompt.js";
 function buildSkillsSection(params) {
-    if (params.isMinimal)
+    if (params.isMinimal) {
         return [];
+    }
     const trimmed = params.skillsPrompt?.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return [];
+    }
     return [
         "## Skills (mandatory)",
         "Before replying: scan <available_skills> <description> entries.",
@@ -19,8 +21,9 @@ function buildSkillsSection(params) {
     ];
 }
 function buildMemorySection(params) {
-    if (params.isMinimal)
+    if (params.isMinimal) {
         return [];
+    }
     if (!params.availableTools.has("memory_search") && !params.availableTools.has("memory_get")) {
         return [];
     }
@@ -38,21 +41,25 @@ function buildMemorySection(params) {
     return lines;
 }
 function buildUserIdentitySection(ownerLine, isMinimal) {
-    if (!ownerLine || isMinimal)
+    if (!ownerLine || isMinimal) {
         return [];
+    }
     return ["## User Identity", ownerLine, ""];
 }
 function buildTimeSection(params) {
-    if (!params.userTimezone)
+    if (!params.userTimezone) {
         return [];
+    }
     return ["## Current Date & Time", `Time zone: ${params.userTimezone}`, ""];
 }
 function buildReplyTagsSection(isMinimal) {
-    if (isMinimal)
+    if (isMinimal) {
         return [];
+    }
     return [
         "## Reply Tags",
         "To request a native reply/quote on supported surfaces, include one tag in your reply:",
+        "- Reply tags must be the very first token in the message (no leading text/newlines): [[reply_to_current]] your reply.",
         "- [[reply_to_current]] replies to the triggering message.",
         "- Prefer [[reply_to_current]]. Use [[reply_to:<id>]] only when an id was explicitly provided (e.g. by the user or a tool).",
         "Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).",
@@ -61,8 +68,9 @@ function buildReplyTagsSection(isMinimal) {
     ];
 }
 function buildMessagingSection(params) {
-    if (params.isMinimal)
+    if (params.isMinimal) {
         return [];
+    }
     return [
         "## Messaging",
         "- Reply in current session → automatically routes to the source channel (Signal, Telegram, etc.)",
@@ -93,40 +101,27 @@ function buildMessagingSection(params) {
     ];
 }
 function buildVoiceSection(params) {
-    if (params.isMinimal)
-        return [];
-    const hint = params.ttsHint?.trim();
-    if (!hint)
-        return [];
-    return ["## Voice (TTS)", hint, ""];
-}
-function buildLlmsTxtSection(params) {
     if (params.isMinimal) {
         return [];
     }
-    if (!params.availableTools.has("web_fetch")) {
+    const hint = params.ttsHint?.trim();
+    if (!hint) {
         return [];
     }
-    return [
-        "## llms.txt Discovery",
-        "When exploring a new domain or website (via web_fetch or browser), check for an llms.txt file that describes how AI agents should interact with the site:",
-        "- Try `/llms.txt` or `/.well-known/llms.txt` at the domain root",
-        "- If found, follow its guidance for interacting with that site's content and APIs",
-        "- llms.txt is an emerging standard (like robots.txt for AI) — not all sites have one, so don't warn if missing",
-        "",
-    ];
+    return ["## Voice (TTS)", hint, ""];
 }
 function buildDocsSection(params) {
     const docsPath = params.docsPath?.trim();
-    if (!docsPath || params.isMinimal)
+    if (!docsPath || params.isMinimal) {
         return [];
+    }
     return [
         "## Documentation",
         `Pool Bot docs: ${docsPath}`,
         "Mirror: https://docs.poolbot.dev",
-        "Source: https://github.com/poolzin/pool-bot",
-        "Community: https://discord.com/discord.gg/poolbot",
-        "Find new skills: https://poolhub.com",
+        "Source: https://github.com/poolbot/poolbot",
+        "Community: https://discord.com/invite/clawd",
+        "Find new skills: https://clawhub.com",
         "For Pool Bot behavior, commands, config, or architecture: consult local docs first.",
         "When diagnosing issues, run `poolbot status` yourself when possible; only ask the user if you lack access (e.g., sandboxed).",
         "",
@@ -183,7 +178,6 @@ export function buildAgentSystemPrompt(params) {
         "sessions_list",
         "sessions_history",
         "sessions_send",
-        "sessions_spawn",
         "subagents",
         "session_status",
         "image",
@@ -204,8 +198,9 @@ export function buildAgentSystemPrompt(params) {
     const externalToolSummaries = new Map();
     for (const [key, value] of Object.entries(params.toolSummaries ?? {})) {
         const normalized = key.trim().toLowerCase();
-        if (!normalized || !value?.trim())
+        if (!normalized || !value?.trim()) {
             continue;
+        }
         externalToolSummaries.set(normalized, value.trim());
     }
     const extraTools = Array.from(new Set(normalizedTools.filter((tool) => !toolOrder.includes(tool))));
@@ -215,7 +210,7 @@ export function buildAgentSystemPrompt(params) {
         const name = resolveToolName(tool);
         return summary ? `- ${name}: ${summary}` : `- ${name}`;
     });
-    for (const tool of extraTools.sort()) {
+    for (const tool of extraTools.toSorted()) {
         const summary = coreToolSummaries[tool] ?? externalToolSummaries.get(tool);
         const name = resolveToolName(tool);
         toolLines.push(summary ? `- ${name}: ${summary}` : `- ${name}`);
@@ -437,7 +432,6 @@ export function buildAgentSystemPrompt(params) {
             messageToolHints: params.messageToolHints,
         }),
         ...buildVoiceSection({ isMinimal, ttsHint: params.ttsHint }),
-        ...buildLlmsTxtSection({ isMinimal, availableTools }),
     ];
     if (extraSystemPrompt) {
         // Use "Subagent Context" header for minimal mode (subagents), otherwise "Group Chat Context"

package/dist/agents/tool-call-id.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 const STRICT9_LEN = 9;
+const TOOL_CALL_TYPES = new Set(["toolCall", "toolUse", "functionCall"]);
 /**
  * Sanitize a tool call ID to be compatible with various providers.
  *
@@ -8,25 +9,63 @@ const STRICT9_LEN = 9;
  */
 export function sanitizeToolCallId(id, mode = "strict") {
     if (!id || typeof id !== "string") {
-        if (mode === "strict9")
+        if (mode === "strict9") {
             return "defaultid";
+        }
         return "defaulttoolid";
     }
     if (mode === "strict9") {
         const alphanumericOnly = id.replace(/[^a-zA-Z0-9]/g, "");
-        if (alphanumericOnly.length >= STRICT9_LEN)
+        if (alphanumericOnly.length >= STRICT9_LEN) {
             return alphanumericOnly.slice(0, STRICT9_LEN);
-        if (alphanumericOnly.length > 0)
+        }
+        if (alphanumericOnly.length > 0) {
             return shortHash(alphanumericOnly, STRICT9_LEN);
+        }
         return shortHash("sanitized", STRICT9_LEN);
     }
     // Some providers require strictly alphanumeric tool call IDs.
     const alphanumericOnly = id.replace(/[^a-zA-Z0-9]/g, "");
     return alphanumericOnly.length > 0 ? alphanumericOnly : "sanitizedtoolid";
 }
+export function extractToolCallsFromAssistant(msg) {
+    const content = msg.content;
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const toolCalls = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            continue;
+        }
+        const rec = block;
+        if (typeof rec.id !== "string" || !rec.id) {
+            continue;
+        }
+        if (typeof rec.type === "string" && TOOL_CALL_TYPES.has(rec.type)) {
+            toolCalls.push({
+                id: rec.id,
+                name: typeof rec.name === "string" ? rec.name : undefined,
+            });
+        }
+    }
+    return toolCalls;
+}
+export function extractToolResultId(msg) {
+    const toolCallId = msg.toolCallId;
+    if (typeof toolCallId === "string" && toolCallId) {
+        return toolCallId;
+    }
+    const toolUseId = msg.toolUseId;
+    if (typeof toolUseId === "string" && toolUseId) {
+        return toolUseId;
+    }
+    return null;
+}
 export function isValidCloudCodeAssistToolId(id, mode = "strict") {
-    if (!id || typeof id !== "string")
+    if (!id || typeof id !== "string") {
         return false;
+    }
     if (mode === "strict9") {
         return /^[a-zA-Z0-9]{9}$/.test(id);
     }
@@ -40,44 +79,51 @@ function makeUniqueToolId(params) {
     if (params.mode === "strict9") {
         const base = sanitizeToolCallId(params.id, params.mode);
         const candidate = base.length >= STRICT9_LEN ? base.slice(0, STRICT9_LEN) : "";
-        if (candidate && !params.used.has(candidate))
+        if (candidate && !params.used.has(candidate)) {
             return candidate;
+        }
         for (let i = 0; i < 1000; i += 1) {
             const hashed = shortHash(`${params.id}:${i}`, STRICT9_LEN);
-            if (!params.used.has(hashed))
+            if (!params.used.has(hashed)) {
                 return hashed;
+            }
         }
         return shortHash(`${params.id}:${Date.now()}`, STRICT9_LEN);
     }
     const MAX_LEN = 40;
     const base = sanitizeToolCallId(params.id, params.mode).slice(0, MAX_LEN);
-    if (!params.used.has(base))
+    if (!params.used.has(base)) {
         return base;
+    }
     const hash = shortHash(params.id);
     // Use separator based on mode: none for strict, underscore for non-strict variants
     const separator = params.mode === "strict" ? "" : "_";
     const maxBaseLen = MAX_LEN - separator.length - hash.length;
     const clippedBase = base.length > maxBaseLen ? base.slice(0, maxBaseLen) : base;
     const candidate = `${clippedBase}${separator}${hash}`;
-    if (!params.used.has(candidate))
+    if (!params.used.has(candidate)) {
         return candidate;
+    }
     for (let i = 2; i < 1000; i += 1) {
         const suffix = params.mode === "strict" ? `x${i}` : `_${i}`;
         const next = `${candidate.slice(0, MAX_LEN - suffix.length)}${suffix}`;
-        if (!params.used.has(next))
+        if (!params.used.has(next)) {
             return next;
+        }
     }
     const ts = params.mode === "strict" ? `t${Date.now()}` : `_${Date.now()}`;
     return `${candidate.slice(0, MAX_LEN - ts.length)}${ts}`;
 }
 function rewriteAssistantToolCallIds(params) {
     const content = params.message.content;
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return params.message;
+    }
     let changed = false;
     const next = content.map((block) => {
-        if (!block || typeof block !== "object")
+        if (!block || typeof block !== "object") {
             return block;
+        }
         const rec = block;
         const type = rec.type;
         const id = rec.id;
@@ -87,13 +133,15 @@ function rewriteAssistantToolCallIds(params) {
             return block;
         }
         const nextId = params.resolve(id);
-        if (nextId === id)
+        if (nextId === id) {
             return block;
+        }
         changed = true;
         return { ...block, id: nextId };
     });
-    if (!changed)
+    if (!changed) {
         return params.message;
+    }
     return { ...params.message, content: next };
 }
 function rewriteToolResultIds(params) {
@@ -128,8 +176,9 @@ export function sanitizeToolCallIdsForCloudCodeAssist(messages, mode = "strict")
     const used = new Set();
     const resolve = (id) => {
         const existing = map.get(id);
-        if (existing)
+        if (existing) {
             return existing;
+        }
         const next = makeUniqueToolId({ id, used, mode });
         map.set(id, next);
         used.add(next);
@@ -137,16 +186,18 @@ export function sanitizeToolCallIdsForCloudCodeAssist(messages, mode = "strict")
     };
     let changed = false;
     const out = messages.map((msg) => {
-        if (!msg || typeof msg !== "object")
+        if (!msg || typeof msg !== "object") {
             return msg;
+        }
         const role = msg.role;
         if (role === "assistant") {
             const next = rewriteAssistantToolCallIds({
                 message: msg,
                 resolve,
             });
-            if (next !== msg)
+            if (next !== msg) {
                 changed = true;
+            }
             return next;
         }
         if (role === "toolResult") {
@@ -154,8 +205,9 @@ export function sanitizeToolCallIdsForCloudCodeAssist(messages, mode = "strict")
                 message: msg,
                 resolve,
             });
-            if (next !== msg)
+            if (next !== msg) {
                 changed = true;
+            }
             return next;
         }
         return msg;