@poolzin/pool-bot 2026.2.24 → 2026.2.26

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

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

@@ -7,11 +7,13 @@ const MAX_PING_PONG_TURNS = 5;
 export function resolveAnnounceTargetFromKey(sessionKey) {
     const rawParts = sessionKey.split(":").filter(Boolean);
     const parts = rawParts.length >= 3 && rawParts[0] === "agent" ? rawParts.slice(2) : rawParts;
-    if (parts.length < 3)
+    if (parts.length < 3) {
         return null;
+    }
     const [channelRaw, kind, ...rest] = parts;
-    if (kind !== "group" && kind !== "channel")
+    if (kind !== "group" && kind !== "channel") {
         return null;
+    }
     // Extract topic/thread ID from rest (supports both :topic: and :thread:)
     // Telegram uses :topic:, other platforms use :thread:
     let threadId;
@@ -24,15 +26,18 @@ export function resolveAnnounceTargetFromKey(sessionKey) {
     }
     // Remove :topic:N or :thread:N suffix from ID for target
     const id = match ? restJoined.replace(/:(topic|thread):\d+$/, "") : restJoined.trim();
-    if (!id)
+    if (!id) {
         return null;
-    if (!channelRaw)
+    }
+    if (!channelRaw) {
         return null;
+    }
     const normalizedChannel = normalizeAnyChannelId(channelRaw) ?? normalizeChatChannelId(channelRaw);
     const channel = normalizedChannel ?? channelRaw.toLowerCase();
     const kindTarget = (() => {
-        if (!normalizedChannel)
+        if (!normalizedChannel) {
             return id;
+        }
         if (normalizedChannel === "discord" || normalizedChannel === "slack") {
             return `channel:${id}`;
         }
@@ -109,8 +114,9 @@ export function isReplySkip(text) {
 export function resolvePingPongTurns(cfg) {
     const raw = cfg?.session?.agentToAgent?.maxPingPongTurns;
     const fallback = DEFAULT_PING_PONG_TURNS;
-    if (typeof raw !== "number" || !Number.isFinite(raw))
+    if (typeof raw !== "number" || !Number.isFinite(raw)) {
         return fallback;
+    }
     const rounded = Math.floor(raw);
     return Math.max(0, Math.min(MAX_PING_PONG_TURNS, rounded));
 }

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

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
 import { optionalStringEnum } from "../schema/typebox.js";
-import { spawnSubagentDirect } from "../subagent-spawn.js";
+import { SUBAGENT_SPAWN_MODES, spawnSubagentDirect } from "../subagent-spawn.js";
 import { jsonResult, readStringParam } from "./common.js";
 const SessionsSpawnToolSchema = Type.Object({
     task: Type.String(),
@@ -11,13 +11,15 @@ const SessionsSpawnToolSchema = Type.Object({
     runTimeoutSeconds: Type.Optional(Type.Number({ minimum: 0 })),
     // Back-compat: older callers used timeoutSeconds for this tool.
     timeoutSeconds: Type.Optional(Type.Number({ minimum: 0 })),
+    thread: Type.Optional(Type.Boolean()),
+    mode: optionalStringEnum(SUBAGENT_SPAWN_MODES),
     cleanup: optionalStringEnum(["delete", "keep"]),
 });
 export function createSessionsSpawnTool(opts) {
     return {
         label: "Sessions",
         name: "sessions_spawn",
-        description: "Spawn a background sub-agent run in an isolated session and announce the result back to the requester chat.",
+        description: 'Spawn a sub-agent in an isolated session (mode="run" one-shot or mode="session" persistent) and route results back to the requester chat/thread.',
         parameters: SessionsSpawnToolSchema,
         execute: async (_toolCallId, args) => {
             const params = args;
@@ -26,6 +28,7 @@ export function createSessionsSpawnTool(opts) {
             const requestedAgentId = readStringParam(params, "agentId");
             const modelOverride = readStringParam(params, "model");
             const thinkingOverrideRaw = readStringParam(params, "thinking");
+            const mode = params.mode === "run" || params.mode === "session" ? params.mode : undefined;
             const cleanup = params.cleanup === "keep" || params.cleanup === "delete" ? params.cleanup : "keep";
             // Back-compat: older callers used timeoutSeconds for this tool.
             const timeoutSecondsCandidate = typeof params.runTimeoutSeconds === "number"
@@ -36,6 +39,7 @@ export function createSessionsSpawnTool(opts) {
             const runTimeoutSeconds = typeof timeoutSecondsCandidate === "number" && Number.isFinite(timeoutSecondsCandidate)
                 ? Math.max(0, Math.floor(timeoutSecondsCandidate))
                 : undefined;
+            const thread = params.thread === true;
             const result = await spawnSubagentDirect({
                 task,
                 label: label || undefined,
@@ -43,6 +47,8 @@ export function createSessionsSpawnTool(opts) {
                 model: modelOverride,
                 thinking: thinkingOverrideRaw,
                 runTimeoutSeconds,
+                thread,
+                mode,
                 cleanup,
                 expectsCompletionMessage: true,
             }, {

package/dist/agents/tools/subagents-tool.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { Type } from "@sinclair/typebox";
 import { clearSessionQueues } from "../../auto-reply/reply/queue.js";
+import { DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH } from "../../config/agent-limits.js";
 import { loadConfig } from "../../config/config.js";
 import { loadSessionStore, resolveStorePath, updateSessionStore } from "../../config/sessions.js";
 import { callGateway } from "../../gateway/call.js";
@@ -181,7 +182,7 @@ function resolveRequesterKey(params) {
     // Check if this sub-agent can spawn children (orchestrator).
     // If so, it should see its own children, not its parent's children.
     const callerDepth = getSubagentDepthFromSessionStore(callerSessionKey, { cfg: params.cfg });
-    const maxSpawnDepth = params.cfg.agents?.defaults?.subagents?.maxSpawnDepth ?? 1;
+    const maxSpawnDepth = params.cfg.agents?.defaults?.subagents?.maxSpawnDepth ?? DEFAULT_SUBAGENT_MAX_SPAWN_DEPTH;
     if (callerDepth < maxSpawnDepth) {
         // Orchestrator sub-agent: use its own session key as requester
         // so it sees children it spawned.

package/dist/agents/tools/whatsapp-actions.js

@@ -1,5 +1,6 @@
 import { sendReactionWhatsApp } from "../../web/outbound.js";
 import { createActionGate, jsonResult, readReactionParams, readStringParam } from "./common.js";
+import { resolveAuthorizedWhatsAppOutboundTarget } from "./whatsapp-target-auth.js";
 export async function handleWhatsAppAction(params, cfg) {
     const action = readStringParam(params, "action", { required: true });
     const isActionEnabled = createActionGate(cfg.channels?.whatsapp?.actions);
@@ -16,12 +17,19 @@ export async function handleWhatsAppAction(params, cfg) {
         const accountId = readStringParam(params, "accountId");
         const fromMeRaw = params.fromMe;
         const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : undefined;
+        // Resolve account + allowFrom via shared account logic so auth and routing stay aligned.
+        const resolved = resolveAuthorizedWhatsAppOutboundTarget({
+            cfg,
+            chatJid,
+            accountId,
+            actionLabel: "reaction",
+        });
         const resolvedEmoji = remove ? "" : emoji;
-        await sendReactionWhatsApp(chatJid, messageId, resolvedEmoji, {
+        await sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
             verbose: false,
             fromMe,
             participant: participant ?? undefined,
-            accountId: accountId ?? undefined,
+            accountId: resolved.accountId,
         });
         if (!remove && !isEmpty) {
             return jsonResult({ ok: true, added: emoji });

package/dist/agents/tools/whatsapp-target-auth.js

@@ -0,0 +1,18 @@
+import { resolveWhatsAppAccount } from "../../web/accounts.js";
+import { resolveWhatsAppOutboundTarget } from "../../whatsapp/resolve-outbound-target.js";
+import { ToolAuthorizationError } from "./common.js";
+export function resolveAuthorizedWhatsAppOutboundTarget(params) {
+    const account = resolveWhatsAppAccount({
+        cfg: params.cfg,
+        accountId: params.accountId,
+    });
+    const resolution = resolveWhatsAppOutboundTarget({
+        to: params.chatJid,
+        allowFrom: account.allowFrom ?? [],
+        mode: "implicit",
+    });
+    if (!resolution.ok) {
+        throw new ToolAuthorizationError(`WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`);
+    }
+    return { to: resolution.to, accountId: account.accountId };
+}

package/dist/agents/transcript-policy.js

@@ -1,5 +1,5 @@
-import { isAntigravityClaude, isGoogleModelApi } from "./pi-embedded-helpers/google.js";
 import { normalizeProviderId } from "./model-selection.js";
+import { isAntigravityClaude, isGoogleModelApi } from "./pi-embedded-helpers/google.js";
 const MISTRAL_MODEL_HINTS = [
     "mistral",
     "mixtral",
@@ -17,28 +17,34 @@ const OPENAI_MODEL_APIS = new Set([
 ]);
 const OPENAI_PROVIDERS = new Set(["openai", "openai-codex"]);
 function isOpenAiApi(modelApi) {
-    if (!modelApi)
+    if (!modelApi) {
         return false;
+    }
     return OPENAI_MODEL_APIS.has(modelApi);
 }
 function isOpenAiProvider(provider) {
-    if (!provider)
+    if (!provider) {
         return false;
+    }
     return OPENAI_PROVIDERS.has(normalizeProviderId(provider));
 }
 function isAnthropicApi(modelApi, provider) {
-    if (modelApi === "anthropic-messages")
+    if (modelApi === "anthropic-messages") {
         return true;
+    }
     const normalized = normalizeProviderId(provider ?? "");
-    return normalized === "anthropic" || normalized === "minimax";
+    // MiniMax now uses openai-completions API, not anthropic-messages
+    return normalized === "anthropic";
 }
 function isMistralModel(params) {
     const provider = normalizeProviderId(params.provider ?? "");
-    if (provider === "mistral")
+    if (provider === "mistral") {
         return true;
+    }
     const modelId = (params.modelId ?? "").toLowerCase();
-    if (!modelId)
+    if (!modelId) {
         return false;
+    }
     return MISTRAL_MODEL_HINTS.some((hint) => modelId.includes(hint));
 }
 export function resolveTranscriptPolicy(params) {
@@ -55,8 +61,13 @@ export function resolveTranscriptPolicy(params) {
         provider,
         modelId,
     });
+    const isCopilotClaude = provider === "github-copilot" && modelId.toLowerCase().includes("claude");
+    // GitHub Copilot's Claude endpoints can reject persisted `thinking` blocks with
+    // non-binary/non-base64 signatures (e.g. thinkingSignature: "reasoning_text").
+    // Drop these blocks at send-time to keep sessions usable.
+    const dropThinkingBlocks = isCopilotClaude;
     const needsNonImageSanitize = isGoogle || isAnthropic || isMistral || isOpenRouterGemini;
-    const sanitizeToolCallIds = isGoogle || isMistral;
+    const sanitizeToolCallIds = isGoogle || isMistral || isAnthropic;
     const toolCallIdMode = isMistral
         ? "strict9"
         : sanitizeToolCallIds
@@ -67,6 +78,7 @@ export function resolveTranscriptPolicy(params) {
         ? { allowBase64Only: true, includeCamelCase: true }
         : undefined;
     const normalizeAntigravityThinkingBlocks = isAntigravityClaudeModel;
+    const sanitizeThinkingSignatures = isAntigravityClaudeModel;
     return {
         sanitizeMode: isOpenAi ? "images-only" : needsNonImageSanitize ? "full" : "images-only",
         sanitizeToolCallIds: !isOpenAi && sanitizeToolCallIds,
@@ -75,6 +87,8 @@ export function resolveTranscriptPolicy(params) {
         preserveSignatures: isAntigravityClaudeModel,
         sanitizeThoughtSignatures: isOpenAi ? undefined : sanitizeThoughtSignatures,
         normalizeAntigravityThinkingBlocks,
+        sanitizeThinkingSignatures,
+        dropThinkingBlocks,
         applyGoogleTurnOrdering: !isOpenAi && isGoogle,
         validateGeminiTurns: !isOpenAi && isGoogle,
         validateAnthropicTurns: !isOpenAi && isAnthropic,

package/dist/agents/venice-models.js

@@ -1,3 +1,5 @@
+import { createSubsystemLogger } from "../logging/subsystem.js";
+const log = createSubsystemLogger("venice-models");
 export const VENICE_BASE_URL = "https://api.venice.ai/api/v1";
 export const VENICE_DEFAULT_MODEL_ID = "llama-3.3-70b";
 export const VENICE_DEFAULT_MODEL_REF = `venice/${VENICE_DEFAULT_MODEL_ID}`;
@@ -282,6 +284,11 @@ export function buildVeniceModelDefinition(entry) {
         cost: VENICE_DEFAULT_COST,
         contextWindow: entry.contextWindow,
         maxTokens: entry.maxTokens,
+        // Avoid usage-only streaming chunks that can break OpenAI-compatible parsers.
+        // See: https://github.com/openclaw/openclaw/issues/15819
+        compat: {
+            supportsUsageInStreaming: false,
+        },
     };
 }
 /**
@@ -298,12 +305,12 @@ export async function discoverVeniceModels() {
             signal: AbortSignal.timeout(5000),
         });
         if (!response.ok) {
-            console.warn(`[venice-models] Failed to discover models: HTTP ${response.status}, using static catalog`);
+            log.warn(`Failed to discover models: HTTP ${response.status}, using static catalog`);
             return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition);
         }
         const data = (await response.json());
         if (!Array.isArray(data.data) || data.data.length === 0) {
-            console.warn("[venice-models] No models found from API, using static catalog");
+            log.warn("No models found from API, using static catalog");
             return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition);
         }
         // Merge discovered models with catalog metadata
@@ -330,13 +337,14 @@ export async function discoverVeniceModels() {
                     cost: VENICE_DEFAULT_COST,
                     contextWindow: apiModel.model_spec.availableContextTokens || 128000,
                     maxTokens: 8192,
+                    compat: { supportsUsageInStreaming: false },
                 });
             }
         }
         return models.length > 0 ? models : VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition);
     }
     catch (error) {
-        console.warn(`[venice-models] Discovery failed: ${String(error)}, using static catalog`);
+        log.warn(`Discovery failed: ${String(error)}, using static catalog`);
         return VENICE_MODEL_CATALOG.map(buildVeniceModelDefinition);
     }
 }