@poolzin/pool-bot 2026.2.21 → 2026.2.22

package/dist/agents/pi-embedded-runner/google.js

@@ -1,11 +1,13 @@
 import { EventEmitter } from "node:events";
 import { registerUnhandledRejectionHandler } from "../../infra/unhandled-rejections.js";
+import { hasInterSessionUserProvenance, normalizeInputProvenance, } from "../../sessions/input-provenance.js";
+import { resolveImageSanitizationLimits } from "../image-sanitization.js";
 import { downgradeOpenAIReasoningBlocks, isCompactionFailureError, isGoogleModelApi, sanitizeGoogleTurnOrdering, sanitizeSessionMessagesImages, } from "../pi-embedded-helpers.js";
-import { sanitizeToolUseResultPairing } from "../session-transcript-repair.js";
-import { log } from "./logger.js";
-import { describeUnknownError } from "./utils.js";
 import { cleanToolSchemaForGemini } from "../pi-tools.schema.js";
+import { sanitizeToolCallInputs, stripToolResultDetails, sanitizeToolUseResultPairing, } from "../session-transcript-repair.js";
 import { resolveTranscriptPolicy } from "../transcript-policy.js";
+import { log } from "./logger.js";
+import { describeUnknownError } from "./utils.js";
 const GOOGLE_TURN_ORDERING_CUSTOM_TYPE = "google-turn-ordering-bootstrap";
 const GOOGLE_SCHEMA_UNSUPPORTED_KEYWORDS = new Set([
     "patternProperties",
@@ -30,17 +32,21 @@ const GOOGLE_SCHEMA_UNSUPPORTED_KEYWORDS = new Set([
     "maxProperties",
 ]);
 const ANTIGRAVITY_SIGNATURE_RE = /^[A-Za-z0-9+/]+={0,2}$/;
+const INTER_SESSION_PREFIX_BASE = "[Inter-session message]";
 function isValidAntigravitySignature(value) {
-    if (typeof value !== "string")
+    if (typeof value !== "string") {
         return false;
+    }
     const trimmed = value.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
-    if (trimmed.length % 4 !== 0)
+    }
+    if (trimmed.length % 4 !== 0) {
         return false;
+    }
     return ANTIGRAVITY_SIGNATURE_RE.test(trimmed);
 }
-function sanitizeAntigravityThinkingBlocks(messages) {
+export function sanitizeAntigravityThinkingBlocks(messages) {
     let touched = false;
     const out = [];
     for (const msg of messages) {
@@ -91,9 +97,81 @@ function sanitizeAntigravityThinkingBlocks(messages) {
     }
     return touched ? out : messages;
 }
+function buildInterSessionPrefix(message) {
+    const provenance = normalizeInputProvenance(message.provenance);
+    if (!provenance) {
+        return INTER_SESSION_PREFIX_BASE;
+    }
+    const details = [
+        provenance.sourceSessionKey ? `sourceSession=${provenance.sourceSessionKey}` : undefined,
+        provenance.sourceChannel ? `sourceChannel=${provenance.sourceChannel}` : undefined,
+        provenance.sourceTool ? `sourceTool=${provenance.sourceTool}` : undefined,
+    ].filter(Boolean);
+    if (details.length === 0) {
+        return INTER_SESSION_PREFIX_BASE;
+    }
+    return `${INTER_SESSION_PREFIX_BASE} ${details.join(" ")}`;
+}
+function annotateInterSessionUserMessages(messages) {
+    let touched = false;
+    const out = [];
+    for (const msg of messages) {
+        if (!hasInterSessionUserProvenance(msg)) {
+            out.push(msg);
+            continue;
+        }
+        const prefix = buildInterSessionPrefix(msg);
+        const user = msg;
+        if (typeof user.content === "string") {
+            if (user.content.startsWith(prefix)) {
+                out.push(msg);
+                continue;
+            }
+            touched = true;
+            out.push({
+                ...msg,
+                content: `${prefix}\n${user.content}`,
+            });
+            continue;
+        }
+        if (!Array.isArray(user.content)) {
+            out.push(msg);
+            continue;
+        }
+        const textIndex = user.content.findIndex((block) => block &&
+            typeof block === "object" &&
+            block.type === "text" &&
+            typeof block.text === "string");
+        if (textIndex >= 0) {
+            const existing = user.content[textIndex];
+            if (existing.text.startsWith(prefix)) {
+                out.push(msg);
+                continue;
+            }
+            const nextContent = [...user.content];
+            nextContent[textIndex] = {
+                ...existing,
+                text: `${prefix}\n${existing.text}`,
+            };
+            touched = true;
+            out.push({
+                ...msg,
+                content: nextContent,
+            });
+            continue;
+        }
+        touched = true;
+        out.push({
+            ...msg,
+            content: [{ type: "text", text: prefix }, ...user.content],
+        });
+    }
+    return touched ? out : messages;
+}
 function findUnsupportedSchemaKeywords(schema, path) {
-    if (!schema || typeof schema !== "object")
+    if (!schema || typeof schema !== "object") {
         return [];
+    }
     if (Array.isArray(schema)) {
         return schema.flatMap((item, index) => findUnsupportedSchemaKeywords(item, `${path}[${index}]`));
     }
@@ -108,8 +186,9 @@ function findUnsupportedSchemaKeywords(schema, path) {
         }
     }
     for (const [key, value] of Object.entries(record)) {
-        if (key === "properties")
+        if (key === "properties") {
             continue;
+        }
         if (GOOGLE_SCHEMA_UNSUPPORTED_KEYWORDS.has(key)) {
             violations.push(`${path}.${key}`);
         }
@@ -120,12 +199,17 @@ function findUnsupportedSchemaKeywords(schema, path) {
     return violations;
 }
 export function sanitizeToolsForGoogle(params) {
-    if (params.provider !== "google-antigravity" && params.provider !== "google-gemini-cli") {
+    // google-antigravity serves Anthropic models (e.g. claude-opus-4-6-thinking),
+    // NOT Gemini. Applying Gemini schema cleaning strips JSON Schema keywords
+    // (minimum, maximum, format, etc.) that Anthropic's API requires for
+    // draft 2020-12 compliance. Only clean for actual Gemini providers.
+    if (params.provider !== "google-gemini-cli") {
         return params.tools;
     }
     return params.tools.map((tool) => {
-        if (!tool.parameters || typeof tool.parameters !== "object")
+        if (!tool.parameters || typeof tool.parameters !== "object") {
             return tool;
+        }
         return {
             ...tool,
             parameters: cleanToolSchemaForGemini(tool.parameters),
@@ -170,8 +254,9 @@ export function onUnhandledCompactionFailure(cb) {
 }
 registerUnhandledRejectionHandler((reason) => {
     const message = describeUnknownError(reason);
-    if (!isCompactionFailureError(message))
+    if (!isCompactionFailureError(message)) {
         return false;
+    }
     log.error(`Auto-compaction failed (unhandled): ${message}`);
     compactionFailureEmitter.emit("failure", message);
     return true;
@@ -182,8 +267,9 @@ function readLastModelSnapshot(sessionManager) {
         const entries = sessionManager.getEntries();
         for (let i = entries.length - 1; i >= 0; i--) {
             const entry = entries[i];
-            if (entry?.type !== "custom" || entry?.customType !== MODEL_SNAPSHOT_CUSTOM_TYPE)
+            if (entry?.type !== "custom" || entry?.customType !== MODEL_SNAPSHOT_CUSTOM_TYPE) {
                 continue;
+            }
             const data = entry?.data;
             if (data && typeof data === "object") {
                 return data;
@@ -255,19 +341,23 @@ export async function sanitizeSessionHistory(params) {
             provider: params.provider,
             modelId: params.modelId,
         });
-    const sanitizedImages = await sanitizeSessionMessagesImages(params.messages, "session:history", {
+    const withInterSessionMarkers = annotateInterSessionUserMessages(params.messages);
+    const sanitizedImages = await sanitizeSessionMessagesImages(withInterSessionMarkers, "session:history", {
         sanitizeMode: policy.sanitizeMode,
         sanitizeToolCallIds: policy.sanitizeToolCallIds,
         toolCallIdMode: policy.toolCallIdMode,
         preserveSignatures: policy.preserveSignatures,
         sanitizeThoughtSignatures: policy.sanitizeThoughtSignatures,
+        ...resolveImageSanitizationLimits(params.config),
     });
     const sanitizedThinking = policy.normalizeAntigravityThinkingBlocks
         ? sanitizeAntigravityThinkingBlocks(sanitizedImages)
         : sanitizedImages;
+    const sanitizedToolCalls = sanitizeToolCallInputs(sanitizedThinking);
     const repairedTools = policy.repairToolUseResultPairing
-        ? sanitizeToolUseResultPairing(sanitizedThinking)
-        : sanitizedThinking;
+        ? sanitizeToolUseResultPairing(sanitizedToolCalls)
+        : sanitizedToolCalls;
+    const sanitizedToolResults = stripToolResultDetails(repairedTools);
     const isOpenAIResponsesApi = params.modelApi === "openai-responses" || params.modelApi === "openai-codex-responses";
     const hasSnapshot = Boolean(params.provider || params.modelApi || params.modelId);
     const priorSnapshot = hasSnapshot ? readLastModelSnapshot(params.sessionManager) : null;
@@ -279,9 +369,9 @@ export async function sanitizeSessionHistory(params) {
             modelId: params.modelId,
         })
         : false;
-    const sanitizedOpenAI = isOpenAIResponsesApi && modelChanged
-        ? downgradeOpenAIReasoningBlocks(repairedTools)
-        : repairedTools;
+    const sanitizedOpenAI = isOpenAIResponsesApi
+        ? downgradeOpenAIReasoningBlocks(sanitizedToolResults)
+        : sanitizedToolResults;
     if (hasSnapshot && (!priorSnapshot || modelChanged)) {
         appendModelSnapshot(params.sessionManager, {
             timestamp: Date.now(),

package/dist/agents/pi-embedded-runner/history.js

@@ -8,8 +8,9 @@ function stripThreadSuffix(value) {
  * assistant responses). This reduces token usage for long-running DM sessions.
  */
 export function limitHistoryTurns(messages, limit) {
-    if (!limit || limit <= 0 || messages.length === 0)
+    if (!limit || limit <= 0 || messages.length === 0) {
         return messages;
+    }
     let userCount = 0;
     let lastUserIndex = messages.length;
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -26,36 +27,53 @@ export function limitHistoryTurns(messages, limit) {
 /**
  * Extract provider + user ID from a session key and look up dmHistoryLimit.
  * Supports per-DM overrides and provider defaults.
+ * For channel/group sessions, uses historyLimit from provider config.
  */
-export function getDmHistoryLimitFromSessionKey(sessionKey, config) {
-    if (!sessionKey || !config)
+export function getHistoryLimitFromSessionKey(sessionKey, config) {
+    if (!sessionKey || !config) {
         return undefined;
+    }
     const parts = sessionKey.split(":").filter(Boolean);
     const providerParts = parts.length >= 3 && parts[0] === "agent" ? parts.slice(2) : parts;
     const provider = providerParts[0]?.toLowerCase();
-    if (!provider)
+    if (!provider) {
         return undefined;
+    }
     const kind = providerParts[1]?.toLowerCase();
     const userIdRaw = providerParts.slice(2).join(":");
     const userId = stripThreadSuffix(userIdRaw);
-    if (kind !== "dm")
-        return undefined;
-    const getLimit = (providerConfig) => {
-        if (!providerConfig)
-            return undefined;
-        if (userId && providerConfig.dms?.[userId]?.historyLimit !== undefined) {
-            return providerConfig.dms[userId].historyLimit;
-        }
-        return providerConfig.dmHistoryLimit;
-    };
     const resolveProviderConfig = (cfg, providerId) => {
         const channels = cfg?.channels;
-        if (!channels || typeof channels !== "object")
+        if (!channels || typeof channels !== "object") {
             return undefined;
+        }
         const entry = channels[providerId];
-        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
             return undefined;
+        }
         return entry;
     };
-    return getLimit(resolveProviderConfig(config, provider));
+    const providerConfig = resolveProviderConfig(config, provider);
+    if (!providerConfig) {
+        return undefined;
+    }
+    // For DM sessions: per-DM override -> dmHistoryLimit.
+    // Accept both "direct" (new) and "dm" (legacy) for backward compat.
+    if (kind === "dm" || kind === "direct") {
+        if (userId && providerConfig.dms?.[userId]?.historyLimit !== undefined) {
+            return providerConfig.dms[userId].historyLimit;
+        }
+        return providerConfig.dmHistoryLimit;
+    }
+    // For channel/group sessions: use historyLimit from provider config
+    // This prevents context overflow in long-running channel sessions
+    if (kind === "channel" || kind === "group") {
+        return providerConfig.historyLimit;
+    }
+    return undefined;
 }
+/**
+ * @deprecated Use getHistoryLimitFromSessionKey instead.
+ * Alias for backward compatibility.
+ */
+export const getDmHistoryLimitFromSessionKey = getHistoryLimitFromSessionKey;