@poolzin/pool-bot 2026.2.23 → 2026.2.25

package/dist/agents/tools/sessions-history-tool.js

@@ -2,44 +2,102 @@ import { Type } from "@sinclair/typebox";
 import { loadConfig } from "../../config/config.js";
 import { callGateway } from "../../gateway/call.js";
 import { capArrayByJsonBytes } from "../../gateway/session-utils.fs.js";
-import { isSubagentSessionKey, resolveAgentIdFromSessionKey } from "../../routing/session-key.js";
 import { truncateUtf16Safe } from "../../utils.js";
 import { jsonResult, readStringParam } from "./common.js";
-import { createAgentToAgentPolicy, resolveSessionReference, resolveMainSessionAlias, resolveInternalSessionKey, stripToolMessages, } from "./sessions-helpers.js";
+import { createSessionVisibilityGuard, createAgentToAgentPolicy, isRequesterSpawnedSessionVisible, resolveEffectiveSessionToolsVisibility, resolveSessionReference, resolveSandboxedSessionToolContext, stripToolMessages, } from "./sessions-helpers.js";
 const SessionsHistoryToolSchema = Type.Object({
     sessionKey: Type.String(),
     limit: Type.Optional(Type.Number({ minimum: 1 })),
     includeTools: Type.Optional(Type.Boolean()),
 });
-/** Hard cap on the serialized JSON size of the returned messages array. */
-const SESSIONS_HISTORY_MAX_BYTES = 512 * 1024;
-/** Per-block text truncation limit (in UTF-16 chars). */
-const SESSIONS_HISTORY_TEXT_MAX_CHARS = 32_000;
-function truncateHistoryText(text, maxChars) {
-    if (text.length <= maxChars)
-        return text;
-    return `${truncateUtf16Safe(text, maxChars)}…(truncated)`;
+const SESSIONS_HISTORY_MAX_BYTES = 80 * 1024;
+const SESSIONS_HISTORY_TEXT_MAX_CHARS = 4000;
+// sandbox policy handling is shared with sessions-list-tool via sessions-helpers.ts
+function truncateHistoryText(text) {
+    if (text.length <= SESSIONS_HISTORY_TEXT_MAX_CHARS) {
+        return { text, truncated: false };
+    }
+    const cut = truncateUtf16Safe(text, SESSIONS_HISTORY_TEXT_MAX_CHARS);
+    return { text: `${cut}\n…(truncated)…`, truncated: true };
 }
 function sanitizeHistoryContentBlock(block) {
-    if (!block || typeof block !== "object")
-        return block;
-    const rec = block;
-    if (typeof rec.text === "string") {
-        return { ...rec, text: truncateHistoryText(rec.text, SESSIONS_HISTORY_TEXT_MAX_CHARS) };
+    if (!block || typeof block !== "object") {
+        return { block, truncated: false };
+    }
+    const entry = { ...block };
+    let truncated = false;
+    const type = typeof entry.type === "string" ? entry.type : "";
+    if (typeof entry.text === "string") {
+        const res = truncateHistoryText(entry.text);
+        entry.text = res.text;
+        truncated ||= res.truncated;
+    }
+    if (type === "thinking") {
+        if (typeof entry.thinking === "string") {
+            const res = truncateHistoryText(entry.thinking);
+            entry.thinking = res.text;
+            truncated ||= res.truncated;
+        }
+        // The encrypted signature can be extremely large and is not useful for history recall.
+        if ("thinkingSignature" in entry) {
+            delete entry.thinkingSignature;
+            truncated = true;
+        }
     }
-    return block;
+    if (typeof entry.partialJson === "string") {
+        const res = truncateHistoryText(entry.partialJson);
+        entry.partialJson = res.text;
+        truncated ||= res.truncated;
+    }
+    if (type === "image") {
+        const data = typeof entry.data === "string" ? entry.data : undefined;
+        const bytes = data ? data.length : undefined;
+        if ("data" in entry) {
+            delete entry.data;
+            truncated = true;
+        }
+        entry.omitted = true;
+        if (bytes !== undefined) {
+            entry.bytes = bytes;
+        }
+    }
+    return { block: entry, truncated };
 }
-function sanitizeHistoryMessage(msg) {
-    if (!msg || typeof msg !== "object")
-        return msg;
-    const rec = msg;
-    if (typeof rec.content === "string") {
-        return { ...rec, content: truncateHistoryText(rec.content, SESSIONS_HISTORY_TEXT_MAX_CHARS) };
+function sanitizeHistoryMessage(message) {
+    if (!message || typeof message !== "object") {
+        return { message, truncated: false };
+    }
+    const entry = { ...message };
+    let truncated = false;
+    // Tool result details often contain very large nested payloads.
+    if ("details" in entry) {
+        delete entry.details;
+        truncated = true;
     }
-    if (Array.isArray(rec.content)) {
-        return { ...rec, content: rec.content.map(sanitizeHistoryContentBlock) };
+    if ("usage" in entry) {
+        delete entry.usage;
+        truncated = true;
     }
-    return msg;
+    if ("cost" in entry) {
+        delete entry.cost;
+        truncated = true;
+    }
+    if (typeof entry.content === "string") {
+        const res = truncateHistoryText(entry.content);
+        entry.content = res.text;
+        truncated ||= res.truncated;
+    }
+    else if (Array.isArray(entry.content)) {
+        const updated = entry.content.map((block) => sanitizeHistoryContentBlock(block));
+        entry.content = updated.map((item) => item.block);
+        truncated ||= updated.some((item) => item.truncated);
+    }
+    if (typeof entry.text === "string") {
+        const res = truncateHistoryText(entry.text);
+        entry.text = res.text;
+        truncated ||= res.truncated;
+    }
+    return { message: entry, truncated };
 }
 function jsonUtf8Bytes(value) {
     try {
@@ -49,45 +107,23 @@ function jsonUtf8Bytes(value) {
         return Buffer.byteLength(String(value), "utf8");
     }
 }
-function enforceSessionsHistoryHardCap(messages) {
-    const sanitized = messages.map(sanitizeHistoryMessage);
-    const { items, bytes } = capArrayByJsonBytes(sanitized, SESSIONS_HISTORY_MAX_BYTES);
-    const droppedMessages = sanitized.length - items.length;
-    // Count how many messages had content truncated by comparing original vs sanitized text.
-    let contentTruncated = 0;
-    for (let i = 0; i < messages.length; i++) {
-        if (jsonUtf8Bytes(messages[i]) !== jsonUtf8Bytes(sanitized[i])) {
-            contentTruncated++;
-        }
-    }
-    return {
-        messages: items,
-        truncated: droppedMessages > 0 || contentTruncated > 0,
-        droppedMessages,
-        contentTruncated,
-        bytes,
-    };
-}
-function resolveSandboxSessionToolsVisibility(cfg) {
-    return cfg.agents?.defaults?.sandbox?.sessionToolsVisibility ?? "spawned";
-}
-async function isSpawnedSessionAllowed(params) {
-    try {
-        const list = (await callGateway({
-            method: "sessions.list",
-            params: {
-                includeGlobal: false,
-                includeUnknown: false,
-                limit: 500,
-                spawnedBy: params.requesterSessionKey,
-            },
-        }));
-        const sessions = Array.isArray(list?.sessions) ? list.sessions : [];
-        return sessions.some((entry) => entry?.key === params.targetSessionKey);
+function enforceSessionsHistoryHardCap(params) {
+    if (params.bytes <= params.maxBytes) {
+        return { items: params.items, bytes: params.bytes, hardCapped: false };
     }
-    catch {
-        return false;
+    const last = params.items.at(-1);
+    const lastOnly = last ? [last] : [];
+    const lastBytes = jsonUtf8Bytes(lastOnly);
+    if (lastBytes <= params.maxBytes) {
+        return { items: lastOnly, bytes: lastBytes, hardCapped: true };
     }
+    const placeholder = [
+        {
+            role: "assistant",
+            content: "[sessions_history omitted: message too large]",
+        },
+    ];
+    return { items: placeholder, bytes: jsonUtf8Bytes(placeholder), hardCapped: true };
 }
 export function createSessionsHistoryTool(opts) {
     return {
@@ -101,24 +137,16 @@ export function createSessionsHistoryTool(opts) {
                 required: true,
             });
             const cfg = loadConfig();
-            const { mainKey, alias } = resolveMainSessionAlias(cfg);
-            const visibility = resolveSandboxSessionToolsVisibility(cfg);
-            const requesterInternalKey = typeof opts?.agentSessionKey === "string" && opts.agentSessionKey.trim()
-                ? resolveInternalSessionKey({
-                    key: opts.agentSessionKey,
-                    alias,
-                    mainKey,
-                })
-                : undefined;
-            const restrictToSpawned = opts?.sandboxed === true &&
-                visibility === "spawned" &&
-                !!requesterInternalKey &&
-                !isSubagentSessionKey(requesterInternalKey);
+            const { mainKey, alias, effectiveRequesterKey, restrictToSpawned } = resolveSandboxedSessionToolContext({
+                cfg,
+                agentSessionKey: opts?.agentSessionKey,
+                sandboxed: opts?.sandboxed,
+            });
             const resolvedSession = await resolveSessionReference({
                 sessionKey: sessionKeyParam,
                 alias,
                 mainKey,
-                requesterInternalKey,
+                requesterInternalKey: effectiveRequesterKey,
                 restrictToSpawned,
             });
             if (!resolvedSession.ok) {
@@ -128,9 +156,9 @@ export function createSessionsHistoryTool(opts) {
             const resolvedKey = resolvedSession.key;
             const displayKey = resolvedSession.displayKey;
             const resolvedViaSessionId = resolvedSession.resolvedViaSessionId;
-            if (restrictToSpawned && !resolvedViaSessionId) {
-                const ok = await isSpawnedSessionAllowed({
-                    requesterSessionKey: requesterInternalKey,
+            if (restrictToSpawned && !resolvedViaSessionId && resolvedKey !== effectiveRequesterKey) {
+                const ok = await isRequesterSpawnedSessionVisible({
+                    requesterSessionKey: effectiveRequesterKey,
                     targetSessionKey: resolvedKey,
                 });
                 if (!ok) {
@@ -141,45 +169,49 @@ export function createSessionsHistoryTool(opts) {
                 }
             }
             const a2aPolicy = createAgentToAgentPolicy(cfg);
-            const requesterAgentId = resolveAgentIdFromSessionKey(requesterInternalKey);
-            const targetAgentId = resolveAgentIdFromSessionKey(resolvedKey);
-            const isCrossAgent = requesterAgentId !== targetAgentId;
-            if (isCrossAgent) {
-                if (!a2aPolicy.enabled) {
-                    return jsonResult({
-                        status: "forbidden",
-                        error: "Agent-to-agent history is disabled. Set tools.agentToAgent.enabled=true to allow cross-agent access.",
-                    });
-                }
-                if (!a2aPolicy.isAllowed(requesterAgentId, targetAgentId)) {
-                    return jsonResult({
-                        status: "forbidden",
-                        error: "Agent-to-agent history denied by tools.agentToAgent.allow.",
-                    });
-                }
+            const visibility = resolveEffectiveSessionToolsVisibility({
+                cfg,
+                sandboxed: opts?.sandboxed === true,
+            });
+            const visibilityGuard = await createSessionVisibilityGuard({
+                action: "history",
+                requesterSessionKey: effectiveRequesterKey,
+                visibility,
+                a2aPolicy,
+            });
+            const access = visibilityGuard.check(resolvedKey);
+            if (!access.allowed) {
+                return jsonResult({
+                    status: access.status,
+                    error: access.error,
+                });
             }
             const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
                 ? Math.max(1, Math.floor(params.limit))
                 : undefined;
             const includeTools = Boolean(params.includeTools);
-            const result = (await callGateway({
+            const result = await callGateway({
                 method: "chat.history",
                 params: { sessionKey: resolvedKey, limit },
-            }));
+            });
             const rawMessages = Array.isArray(result?.messages) ? result.messages : [];
-            const messages = includeTools ? rawMessages : stripToolMessages(rawMessages);
-            const capped = enforceSessionsHistoryHardCap(messages);
+            const selectedMessages = includeTools ? rawMessages : stripToolMessages(rawMessages);
+            const sanitizedMessages = selectedMessages.map((message) => sanitizeHistoryMessage(message));
+            const contentTruncated = sanitizedMessages.some((entry) => entry.truncated);
+            const cappedMessages = capArrayByJsonBytes(sanitizedMessages.map((entry) => entry.message), SESSIONS_HISTORY_MAX_BYTES);
+            const droppedMessages = cappedMessages.items.length < selectedMessages.length;
+            const hardened = enforceSessionsHistoryHardCap({
+                items: cappedMessages.items,
+                bytes: cappedMessages.bytes,
+                maxBytes: SESSIONS_HISTORY_MAX_BYTES,
+            });
             return jsonResult({
                 sessionKey: displayKey,
-                messages: capped.messages,
-                ...(capped.truncated
-                    ? {
-                        truncated: true,
-                        droppedMessages: capped.droppedMessages,
-                        contentTruncated: capped.contentTruncated,
-                        bytes: capped.bytes,
-                    }
-                    : {}),
+                messages: hardened.items,
+                truncated: droppedMessages || contentTruncated || hardened.hardCapped,
+                droppedMessages: droppedMessages || hardened.hardCapped,
+                contentTruncated,
+                bytes: hardened.bytes,
             });
         },
     };