@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/agents/tools/nodes-utils.js

@@ -1,3 +1,4 @@
+import { resolveNodeIdFromCandidates } from "../../shared/node-match.js";
 import { callGatewayTool } from "./gateway.js";
 function parseNodeList(value) {
     const obj = typeof value === "object" && value !== null ? value : {};
@@ -9,20 +10,13 @@ function parsePairingList(value) {
     const paired = Array.isArray(obj.paired) ? obj.paired : [];
     return { pending, paired };
 }
-function normalizeNodeKey(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "");
-}
 async function loadNodes(opts) {
     try {
-        const res = (await callGatewayTool("node.list", opts, {}));
+        const res = await callGatewayTool("node.list", opts, {});
         return parseNodeList(res);
     }
     catch {
-        const res = (await callGatewayTool("node.pair.list", opts, {}));
+        const res = await callGatewayTool("node.pair.list", opts, {});
         const { paired } = parsePairingList(res);
         return paired.map((n) => ({
             nodeId: n.nodeId,
@@ -34,17 +28,20 @@ async function loadNodes(opts) {
 }
 function pickDefaultNode(nodes) {
     const withCanvas = nodes.filter((n) => Array.isArray(n.caps) ? n.caps.includes("canvas") : true);
-    if (withCanvas.length === 0)
+    if (withCanvas.length === 0) {
         return null;
+    }
     const connected = withCanvas.filter((n) => n.connected);
     const candidates = connected.length > 0 ? connected : withCanvas;
-    if (candidates.length === 1)
+    if (candidates.length === 1) {
         return candidates[0];
+    }
     const local = candidates.filter((n) => n.platform?.toLowerCase().startsWith("mac") &&
         typeof n.nodeId === "string" &&
         n.nodeId.startsWith("mac-"));
-    if (local.length === 1)
+    if (local.length === 1) {
         return local[0];
+    }
     return null;
 }
 export async function listNodes(opts) {
@@ -55,36 +52,13 @@ export function resolveNodeIdFromList(nodes, query, allowDefault = false) {
     if (!q) {
         if (allowDefault) {
             const picked = pickDefaultNode(nodes);
-            if (picked)
+            if (picked) {
                 return picked.nodeId;
+            }
         }
         throw new Error("node required");
     }
-    const qNorm = normalizeNodeKey(q);
-    const matches = nodes.filter((n) => {
-        if (n.nodeId === q)
-            return true;
-        if (typeof n.remoteIp === "string" && n.remoteIp === q)
-            return true;
-        const name = typeof n.displayName === "string" ? n.displayName : "";
-        if (name && normalizeNodeKey(name) === qNorm)
-            return true;
-        if (q.length >= 6 && n.nodeId.startsWith(q))
-            return true;
-        return false;
-    });
-    if (matches.length === 1)
-        return matches[0].nodeId;
-    if (matches.length === 0) {
-        const known = nodes
-            .map((n) => n.displayName || n.remoteIp || n.nodeId)
-            .filter(Boolean)
-            .join(", ");
-        throw new Error(`unknown node: ${q}${known ? ` (known: ${known})` : ""}`);
-    }
-    throw new Error(`ambiguous node: ${q} (matches: ${matches
-        .map((n) => n.displayName || n.remoteIp || n.nodeId)
-        .join(", ")})`);
+    return resolveNodeIdFromCandidates(nodes, q);
 }
 export async function resolveNodeId(opts, query, allowDefault = false) {
     const nodes = await loadNodes(opts);

package/dist/agents/tools/session-status-tool.js

@@ -1,85 +1,29 @@
 import { Type } from "@sinclair/typebox";
-import { resolveAgentDir } from "../../agents/agent-scope.js";
-import { ensureAuthProfileStore, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "../../agents/auth-profiles.js";
-import { getCustomProviderApiKey, resolveEnvApiKey } from "../../agents/model-auth.js";
-import { loadModelCatalog } from "../../agents/model-catalog.js";
-import { buildAllowedModelSet, buildModelAliasIndex, modelKey, normalizeProviderId, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../../agents/model-selection.js";
-import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
 import { normalizeGroupActivation } from "../../auto-reply/group-activation.js";
 import { getFollowupQueueDepth, resolveQueueSettings } from "../../auto-reply/reply/queue.js";
 import { buildStatusMessage } from "../../auto-reply/status.js";
 import { loadConfig } from "../../config/config.js";
 import { loadSessionStore, resolveStorePath, updateSessionStore, } from "../../config/sessions.js";
+import { loadCombinedSessionStoreForGateway } from "../../gateway/session-utils.js";
 import { formatUsageWindowSummary, loadProviderUsageSummary, resolveUsageProviderId, } from "../../infra/provider-usage.js";
 import { buildAgentMainSessionKey, DEFAULT_AGENT_ID, resolveAgentIdFromSessionKey, } from "../../routing/session-key.js";
 import { applyModelOverrideToSessionEntry } from "../../sessions/model-overrides.js";
+import { resolveAgentDir } from "../agent-scope.js";
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
+import { resolveModelAuthLabel } from "../model-auth-label.js";
+import { loadModelCatalog } from "../model-catalog.js";
+import { buildAllowedModelSet, buildModelAliasIndex, modelKey, resolveDefaultModelForAgent, resolveModelRefFromString, } from "../model-selection.js";
 import { readStringParam } from "./common.js";
 import { shouldResolveSessionIdInput, resolveInternalSessionKey, resolveMainSessionAlias, createAgentToAgentPolicy, } from "./sessions-helpers.js";
-import { loadCombinedSessionStoreForGateway } from "../../gateway/session-utils.js";
 const SessionStatusToolSchema = Type.Object({
     sessionKey: Type.Optional(Type.String()),
     model: Type.Optional(Type.String()),
 });
-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}`;
-}
-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";
-}
 function resolveSessionEntry(params) {
     const keyRaw = params.keyRaw.trim();
-    if (!keyRaw)
+    if (!keyRaw) {
         return null;
+    }
     const internal = resolveInternalSessionKey({
         key: keyRaw,
         alias: params.alias,
@@ -98,31 +42,37 @@ function resolveSessionEntry(params) {
     }
     for (const key of candidates) {
         const entry = params.store[key];
-        if (entry)
+        if (entry) {
             return { key, entry };
+        }
     }
     return null;
 }
 function resolveSessionKeyFromSessionId(params) {
     const trimmed = params.sessionId.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     const { store } = loadCombinedSessionStoreForGateway(params.cfg);
     const match = Object.entries(store).find(([key, entry]) => {
-        if (entry?.sessionId !== trimmed)
+        if (entry?.sessionId !== trimmed) {
             return false;
-        if (!params.agentId)
+        }
+        if (!params.agentId) {
             return true;
+        }
         return resolveAgentIdFromSessionKey(key) === params.agentId;
     });
     return match?.[0] ?? null;
 }
 async function resolveModelOverride(params) {
     const raw = params.raw.trim();
-    if (!raw)
+    if (!raw) {
         return { kind: "reset" };
-    if (raw.toLowerCase() === "default")
+    }
+    if (raw.toLowerCase() === "default") {
         return { kind: "reset" };
+    }
     const configDefault = resolveDefaultModelForAgent({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -178,8 +128,9 @@ export function createSessionStatusTool(opts) {
             }
             const requesterAgentId = resolveAgentIdFromSessionKey(opts?.agentSessionKey ?? requestedKeyRaw);
             const ensureAgentAccess = (targetAgentId) => {
-                if (targetAgentId === requesterAgentId)
+                if (targetAgentId === requesterAgentId) {
                     return;
+                }
                 // Gate cross-agent access behind tools.agentToAgent settings.
                 if (!a2aPolicy.enabled) {
                     throw new Error("Agent-to-agent status is disabled. Set tools.agentToAgent.enabled=true to allow cross-agent access.");
@@ -322,8 +273,10 @@ export function createSessionStatusTool(opts) {
                     ...agentDefaults,
                     model: agentModel,
                 },
+                agentId,
                 sessionEntry: resolved.entry,
                 sessionKey: resolved.key,
+                sessionStorePath: storePath,
                 groupActivation,
                 modelAuth: resolveModelAuthLabel({
                     provider: providerForCard,

package/dist/agents/tools/sessions-helpers.js

@@ -1,216 +1,46 @@
-import { callGateway } from "../../gateway/call.js";
+export { createAgentToAgentPolicy, createSessionVisibilityGuard, resolveEffectiveSessionToolsVisibility, resolveSandboxSessionToolsVisibility, resolveSandboxedSessionToolContext, resolveSessionToolsVisibility, } from "./sessions-access.js";
+export { isRequesterSpawnedSessionVisible, listSpawnedSessionKeys, looksLikeSessionId, looksLikeSessionKey, resolveDisplaySessionKey, resolveInternalSessionKey, resolveMainSessionAlias, resolveSessionReference, shouldResolveSessionIdInput, } from "./sessions-resolution.js";
+import { extractTextFromChatContent } from "../../shared/chat-content.js";
 import { sanitizeUserFacingText } from "../pi-embedded-helpers.js";
 import { stripDowngradedToolCallText, stripMinimaxToolCallXml, stripThinkingTagsFromText, } from "../pi-embedded-utils.js";
-import { isAcpSessionKey, normalizeMainKey } from "../../routing/session-key.js";
 function normalizeKey(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
 }
-export function resolveMainSessionAlias(cfg) {
-    const mainKey = normalizeMainKey(cfg.session?.mainKey);
-    const scope = cfg.session?.scope ?? "per-sender";
-    const alias = scope === "global" ? "global" : mainKey;
-    return { mainKey, alias, scope };
-}
-export function resolveDisplaySessionKey(params) {
-    if (params.key === params.alias)
-        return "main";
-    if (params.key === params.mainKey)
-        return "main";
-    return params.key;
-}
-export function resolveInternalSessionKey(params) {
-    if (params.key === "main")
-        return params.alias;
-    return params.key;
-}
-export function createAgentToAgentPolicy(cfg) {
-    const routingA2A = cfg.tools?.agentToAgent;
-    const enabled = routingA2A?.enabled === true;
-    const allowPatterns = Array.isArray(routingA2A?.allow) ? routingA2A.allow : [];
-    const matchesAllow = (agentId) => {
-        if (allowPatterns.length === 0)
-            return true;
-        return allowPatterns.some((pattern) => {
-            const raw = String(pattern ?? "").trim();
-            if (!raw)
-                return false;
-            if (raw === "*")
-                return true;
-            if (!raw.includes("*"))
-                return raw === agentId;
-            const escaped = raw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const re = new RegExp(`^${escaped.replaceAll("\\*", ".*")}$`, "i");
-            return re.test(agentId);
-        });
-    };
-    const isAllowed = (requesterAgentId, targetAgentId) => {
-        if (requesterAgentId === targetAgentId)
-            return true;
-        if (!enabled)
-            return false;
-        return matchesAllow(requesterAgentId) && matchesAllow(targetAgentId);
-    };
-    return { enabled, matchesAllow, isAllowed };
-}
-const SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-export function looksLikeSessionId(value) {
-    return SESSION_ID_RE.test(value.trim());
-}
-export function looksLikeSessionKey(value) {
-    const raw = value.trim();
-    if (!raw)
-        return false;
-    // These are canonical key shapes that should never be treated as sessionIds.
-    if (raw === "main" || raw === "global" || raw === "unknown")
-        return true;
-    if (isAcpSessionKey(raw))
-        return true;
-    if (raw.startsWith("agent:"))
-        return true;
-    if (raw.startsWith("cron:") || raw.startsWith("hook:"))
-        return true;
-    if (raw.startsWith("node-") || raw.startsWith("node:"))
-        return true;
-    if (raw.includes(":group:") || raw.includes(":channel:"))
-        return true;
-    return false;
-}
-export function shouldResolveSessionIdInput(value) {
-    // Treat anything that doesn't look like a well-formed key as a sessionId candidate.
-    return looksLikeSessionId(value) || !looksLikeSessionKey(value);
-}
-async function resolveSessionKeyFromSessionId(params) {
-    try {
-        // Resolve via gateway so we respect store routing and visibility rules.
-        const result = (await callGateway({
-            method: "sessions.resolve",
-            params: {
-                sessionId: params.sessionId,
-                spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : undefined,
-                includeGlobal: !params.restrictToSpawned,
-                includeUnknown: !params.restrictToSpawned,
-            },
-        }));
-        const key = typeof result?.key === "string" ? result.key.trim() : "";
-        if (!key) {
-            throw new Error(`Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`);
-        }
-        return {
-            ok: true,
-            key,
-            displayKey: resolveDisplaySessionKey({
-                key,
-                alias: params.alias,
-                mainKey: params.mainKey,
-            }),
-            resolvedViaSessionId: true,
-        };
-    }
-    catch (err) {
-        if (params.restrictToSpawned) {
-            return {
-                ok: false,
-                status: "forbidden",
-                error: `Session not visible from this sandboxed agent session: ${params.sessionId}`,
-            };
-        }
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            ok: false,
-            status: "error",
-            error: message ||
-                `Session not found: ${params.sessionId} (use the full sessionKey from sessions_list)`,
-        };
-    }
-}
-async function resolveSessionKeyFromKey(params) {
-    try {
-        // Try key-based resolution first so non-standard keys keep working.
-        const result = (await callGateway({
-            method: "sessions.resolve",
-            params: {
-                key: params.key,
-                spawnedBy: params.restrictToSpawned ? params.requesterInternalKey : undefined,
-            },
-        }));
-        const key = typeof result?.key === "string" ? result.key.trim() : "";
-        if (!key)
-            return null;
-        return {
-            ok: true,
-            key,
-            displayKey: resolveDisplaySessionKey({
-                key,
-                alias: params.alias,
-                mainKey: params.mainKey,
-            }),
-            resolvedViaSessionId: false,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-export async function resolveSessionReference(params) {
-    const raw = params.sessionKey.trim();
-    if (shouldResolveSessionIdInput(raw)) {
-        // Prefer key resolution to avoid misclassifying custom keys as sessionIds.
-        const resolvedByKey = await resolveSessionKeyFromKey({
-            key: raw,
-            alias: params.alias,
-            mainKey: params.mainKey,
-            requesterInternalKey: params.requesterInternalKey,
-            restrictToSpawned: params.restrictToSpawned,
-        });
-        if (resolvedByKey)
-            return resolvedByKey;
-        return await resolveSessionKeyFromSessionId({
-            sessionId: raw,
-            alias: params.alias,
-            mainKey: params.mainKey,
-            requesterInternalKey: params.requesterInternalKey,
-            restrictToSpawned: params.restrictToSpawned,
-        });
-    }
-    const resolvedKey = resolveInternalSessionKey({
-        key: raw,
-        alias: params.alias,
-        mainKey: params.mainKey,
-    });
-    const displayKey = resolveDisplaySessionKey({
-        key: resolvedKey,
-        alias: params.alias,
-        mainKey: params.mainKey,
-    });
-    return { ok: true, key: resolvedKey, displayKey, resolvedViaSessionId: false };
-}
 export function classifySessionKind(params) {
     const key = params.key;
-    if (key === params.alias || key === params.mainKey)
+    if (key === params.alias || key === params.mainKey) {
         return "main";
-    if (key.startsWith("cron:"))
+    }
+    if (key.startsWith("cron:")) {
         return "cron";
-    if (key.startsWith("hook:"))
+    }
+    if (key.startsWith("hook:")) {
         return "hook";
-    if (key.startsWith("node-") || key.startsWith("node:"))
+    }
+    if (key.startsWith("node-") || key.startsWith("node:")) {
         return "node";
-    if (params.gatewayKind === "group")
+    }
+    if (params.gatewayKind === "group") {
         return "group";
+    }
     if (key.includes(":group:") || key.includes(":channel:")) {
         return "group";
     }
     return "other";
 }
 export function deriveChannel(params) {
-    if (params.kind === "cron" || params.kind === "hook" || params.kind === "node")
+    if (params.kind === "cron" || params.kind === "hook" || params.kind === "node") {
         return "internal";
+    }
     const channel = normalizeKey(params.channel ?? undefined);
-    if (channel)
+    if (channel) {
         return channel;
+    }
     const lastChannel = normalizeKey(params.lastChannel ?? undefined);
-    if (lastChannel)
+    if (lastChannel) {
         return lastChannel;
+    }
     const parts = params.key.split(":").filter(Boolean);
     if (parts.length >= 3 && (parts[1] === "group" || parts[1] === "channel")) {
         return parts[0];
@@ -219,10 +49,11 @@ export function deriveChannel(params) {
 }
 export function stripToolMessages(messages) {
     return messages.filter((msg) => {
-        if (!msg || typeof msg !== "object")
+        if (!msg || typeof msg !== "object") {
             return true;
+        }
         const role = msg.role;
-        return role !== "toolResult";
+        return role !== "toolResult" && role !== "tool";
     });
 }
 /**
@@ -230,32 +61,29 @@ export function stripToolMessages(messages) {
  * This ensures user-facing text doesn't leak internal tool representations.
  */
 export function sanitizeTextContent(text) {
-    if (!text)
+    if (!text) {
         return text;
+    }
     return stripThinkingTagsFromText(stripDowngradedToolCallText(stripMinimaxToolCallXml(text)));
 }
 export function extractAssistantText(message) {
-    if (!message || typeof message !== "object")
+    if (!message || typeof message !== "object") {
         return undefined;
-    if (message.role !== "assistant")
+    }
+    if (message.role !== "assistant") {
         return undefined;
+    }
     const content = message.content;
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return undefined;
-    const chunks = [];
-    for (const block of content) {
-        if (!block || typeof block !== "object")
-            continue;
-        if (block.type !== "text")
-            continue;
-        const text = block.text;
-        if (typeof text === "string") {
-            const sanitized = sanitizeTextContent(text);
-            if (sanitized.trim()) {
-                chunks.push(sanitized);
-            }
-        }
     }
-    const joined = chunks.join("").trim();
-    return joined ? sanitizeUserFacingText(joined) : undefined;
+    const joined = extractTextFromChatContent(content, {
+        sanitizeText: sanitizeTextContent,
+        joinWith: "",
+        normalizeText: (text) => text.trim(),
+    }) ?? "";
+    const stopReason = message.stopReason;
+    const errorMessage = message.errorMessage;
+    const errorContext = stopReason === "error" || (typeof errorMessage === "string" && Boolean(errorMessage.trim()));
+    return joined ? sanitizeUserFacingText(joined, { errorContext }) : undefined;
 }