@poolzin/pool-bot 2026.2.20 → 2026.2.22

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

@@ -2,32 +2,39 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import { createAgentSession, estimateTokens, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
 import { resolveHeartbeatPrompt } from "../../auto-reply/heartbeat.js";
-import { listChannelSupportedActions, resolveChannelMessageToolHints } from "../channel-tools.js";
 import { resolveChannelCapabilities } from "../../config/channel-capabilities.js";
 import { getMachineDisplayName } from "../../infra/machine-name.js";
+import { getGlobalHookRunner } from "../../plugins/hook-runner-global.js";
+import { enqueueCommandInLane } from "../../process/command-queue.js";
+import { isCronSessionKey, isSubagentSessionKey } from "../../routing/session-key.js";
+import { resolveSignalReactionLevel } from "../../signal/reaction-level.js";
 import { resolveTelegramInlineButtonsScope } from "../../telegram/inline-buttons.js";
 import { resolveTelegramReactionLevel } from "../../telegram/reaction-level.js";
-import { resolveSignalReactionLevel } from "../../signal/reaction-level.js";
-import { enqueueCommandInLane } from "../../process/command-queue.js";
+import { buildTtsSystemPromptHint } from "../../tts/tts.js";
+import { resolveUserPath } from "../../utils.js";
 import { normalizeMessageChannel } from "../../utils/message-channel.js";
-import { isSubagentSessionKey } from "../../routing/session-key.js";
 import { isReasoningTagProvider } from "../../utils/provider-utils.js";
-import { resolveUserPath } from "../../utils.js";
 import { resolvePoolbotAgentDir } from "../agent-paths.js";
 import { resolveSessionAgentIds } from "../agent-scope.js";
 import { makeBootstrapWarn, resolveBootstrapContextForRun } from "../bootstrap-files.js";
-import { resolvePoolbotDocsPath } from "../docs-path.js";
+import { listChannelSupportedActions, resolveChannelMessageToolHints } from "../channel-tools.js";
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../defaults.js";
+import { resolvePoolbotDocsPath } from "../docs-path.js";
 import { getApiKeyForModel, resolveModelAuthMode } from "../model-auth.js";
 import { ensurePoolbotModelsJson } from "../models-config.js";
 import { ensureSessionHeader, validateAnthropicTurns, validateGeminiTurns, } from "../pi-embedded-helpers.js";
 import { ensurePiCompactionReserveTokens, resolveCompactionReserveTokensFloor, } from "../pi-settings.js";
 import { createPoolbotCodingTools } from "../pi-tools.js";
 import { resolveSandboxContext } from "../sandbox.js";
+import { repairSessionFileIfNeeded } from "../session-file-repair.js";
 import { guardSessionManager } from "../session-tool-result-guard-wrapper.js";
-import { resolveTranscriptPolicy } from "../transcript-policy.js";
-import { acquireSessionWriteLock } from "../session-write-lock.js";
+import { sanitizeToolUseResultPairing } from "../session-transcript-repair.js";
+import { acquireSessionWriteLock, resolveSessionLockMaxHoldFromTimeout, } from "../session-write-lock.js";
+import { detectRuntimeShell } from "../shell-utils.js";
 import { applySkillEnvOverrides, applySkillEnvOverridesFromSnapshot, loadWorkspaceSkillEntries, resolveSkillsPromptForRun, } from "../skills.js";
+import { resolveTranscriptPolicy } from "../transcript-policy.js";
+import { compactWithSafetyTimeout, EMBEDDED_COMPACTION_TIMEOUT_MS, } from "./compaction-safety-timeout.js";
 import { buildEmbeddedExtensionPaths } from "./extensions.js";
 import { logToolSchemasForGoogle, sanitizeSessionHistory, sanitizeToolsForGoogle, } from "./google.js";
 import { getDmHistoryLimitFromSessionKey, limitHistoryTurns } from "./history.js";
@@ -38,27 +45,137 @@ import { buildEmbeddedSandboxInfo } from "./sandbox-info.js";
 import { prewarmSessionFile, trackSessionManagerAccess } from "./session-manager-cache.js";
 import { applySystemPromptOverrideToSession, buildEmbeddedSystemPrompt, createSystemPromptOverride, } from "./system-prompt.js";
 import { splitSdkTools } from "./tool-split.js";
-import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone } from "../date-time.js";
-import { describeUnknownError, mapThinkingLevel, resolveExecToolDefaults } from "./utils.js";
-import { buildTtsSystemPromptHint } from "../../tts/tts.js";
+import { describeUnknownError, mapThinkingLevel } from "./utils.js";
+import { flushPendingToolResultsAfterIdle } from "./wait-for-idle-before-flush.js";
+function createCompactionDiagId() {
+    return `cmp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function getMessageTextChars(msg) {
+    const content = msg.content;
+    if (typeof content === "string") {
+        return content.length;
+    }
+    if (!Array.isArray(content)) {
+        return 0;
+    }
+    let total = 0;
+    for (const block of content) {
+        if (!block || typeof block !== "object") {
+            continue;
+        }
+        const text = block.text;
+        if (typeof text === "string") {
+            total += text.length;
+        }
+    }
+    return total;
+}
+function resolveMessageToolLabel(msg) {
+    const candidate = msg.toolName ??
+        msg.name ??
+        msg.tool;
+    return typeof candidate === "string" && candidate.trim().length > 0 ? candidate : undefined;
+}
+function summarizeCompactionMessages(messages) {
+    let historyTextChars = 0;
+    let toolResultChars = 0;
+    const contributors = [];
+    let estTokens = 0;
+    let tokenEstimationFailed = false;
+    for (const msg of messages) {
+        const role = typeof msg.role === "string" ? msg.role : "unknown";
+        const chars = getMessageTextChars(msg);
+        historyTextChars += chars;
+        if (role === "toolResult") {
+            toolResultChars += chars;
+        }
+        contributors.push({ role, chars, tool: resolveMessageToolLabel(msg) });
+        if (!tokenEstimationFailed) {
+            try {
+                estTokens += estimateTokens(msg);
+            }
+            catch {
+                tokenEstimationFailed = true;
+            }
+        }
+    }
+    return {
+        messages: messages.length,
+        historyTextChars,
+        toolResultChars,
+        estTokens: tokenEstimationFailed ? undefined : estTokens,
+        contributors: contributors.toSorted((a, b) => b.chars - a.chars).slice(0, 3),
+    };
+}
+function classifyCompactionReason(reason) {
+    const text = (reason ?? "").trim().toLowerCase();
+    if (!text) {
+        return "unknown";
+    }
+    if (text.includes("nothing to compact")) {
+        return "no_compactable_entries";
+    }
+    if (text.includes("below threshold")) {
+        return "below_threshold";
+    }
+    if (text.includes("already compacted")) {
+        return "already_compacted_recently";
+    }
+    if (text.includes("guard")) {
+        return "guard_blocked";
+    }
+    if (text.includes("summary")) {
+        return "summary_failed";
+    }
+    if (text.includes("timed out") || text.includes("timeout")) {
+        return "timeout";
+    }
+    if (text.includes("400") ||
+        text.includes("401") ||
+        text.includes("403") ||
+        text.includes("429")) {
+        return "provider_error_4xx";
+    }
+    if (text.includes("500") ||
+        text.includes("502") ||
+        text.includes("503") ||
+        text.includes("504")) {
+        return "provider_error_5xx";
+    }
+    return "unknown";
+}
 /**
  * Core compaction logic without lane queueing.
  * Use this when already inside a session/global lane to avoid deadlocks.
  */
 export async function compactEmbeddedPiSessionDirect(params) {
+    const startedAt = Date.now();
+    const diagId = params.diagId?.trim() || createCompactionDiagId();
+    const trigger = params.trigger ?? "manual";
+    const attempt = params.attempt ?? 1;
+    const maxAttempts = params.maxAttempts ?? 1;
+    const runId = params.runId ?? params.sessionId;
     const resolvedWorkspace = resolveUserPath(params.workspaceDir);
     const prevCwd = process.cwd();
     const provider = (params.provider ?? DEFAULT_PROVIDER).trim() || DEFAULT_PROVIDER;
     const modelId = (params.model ?? DEFAULT_MODEL).trim() || DEFAULT_MODEL;
-    const agentDir = params.agentDir ?? resolvePoolbotAgentDir();
-    await ensurePoolbotModelsJson(params.config, agentDir);
-    const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
-    if (!model) {
+    const fail = (reason) => {
+        log.warn(`[compaction-diag] end runId=${runId} sessionKey=${params.sessionKey ?? params.sessionId} ` +
+            `diagId=${diagId} trigger=${trigger} provider=${provider}/${modelId} ` +
+            `attempt=${attempt} maxAttempts=${maxAttempts} outcome=failed reason=${classifyCompactionReason(reason)} ` +
+            `durationMs=${Date.now() - startedAt}`);
         return {
             ok: false,
             compacted: false,
-            reason: error ?? `Unknown model: ${provider}/${modelId}`,
+            reason,
         };
+    };
+    const agentDir = params.agentDir ?? resolvePoolbotAgentDir();
+    await ensurePoolbotModelsJson(params.config, agentDir);
+    const { model, error, authStorage, modelRegistry } = resolveModel(provider, modelId, agentDir, params.config);
+    if (!model) {
+        const reason = error ?? `Unknown model: ${provider}/${modelId}`;
+        return fail(reason);
     }
     try {
         const apiKeyInfo = await getApiKeyForModel({
@@ -84,11 +201,8 @@ export async function compactEmbeddedPiSessionDirect(params) {
         }
     }
     catch (err) {
-        return {
-            ok: false,
-            compacted: false,
-            reason: describeUnknownError(err),
-        };
+        const reason = describeUnknownError(err);
+        return fail(reason);
     }
     await fs.mkdir(resolvedWorkspace, { recursive: true });
     const sandboxSessionKey = params.sessionKey?.trim() || params.sessionId;
@@ -141,7 +255,6 @@ export async function compactEmbeddedPiSessionDirect(params) {
         const runAbortController = new AbortController();
         const toolsRaw = createPoolbotCodingTools({
             exec: {
-                ...resolveExecToolDefaults(params.config),
                 elevated: params.bashElevated,
             },
             sandbox,
@@ -159,6 +272,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
             abortSignal: runAbortController.signal,
             modelProvider: model.provider,
             modelId,
+            modelContextWindowTokens: model.contextWindow,
             modelAuthMode: resolveModelAuthMode(model.provider, params.config),
         });
         const tools = sanitizeToolsForGoogle({ tools: toolsRaw, provider });
@@ -178,8 +292,9 @@ export async function compactEmbeddedPiSessionDirect(params) {
                 accountId: params.agentAccountId ?? undefined,
             });
             if (inlineButtonsScope !== "off") {
-                if (!runtimeCapabilities)
+                if (!runtimeCapabilities) {
                     runtimeCapabilities = [];
+                }
                 if (!runtimeCapabilities.some((cap) => String(cap).trim().toLowerCase() === "inlinebuttons")) {
                     runtimeCapabilities.push("inlineButtons");
                 }
@@ -226,6 +341,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
             arch: os.arch(),
             node: process.version,
             model: `${provider}/${modelId}`,
+            shell: detectRuntimeShell(),
             channel: runtimeChannel,
             capabilities: runtimeCapabilities,
             channelActions,
@@ -240,7 +356,9 @@ export async function compactEmbeddedPiSessionDirect(params) {
             config: params.config,
         });
         const isDefaultAgent = sessionAgentId === defaultAgentId;
-        const promptMode = isSubagentSessionKey(params.sessionKey) ? "minimal" : "full";
+        const promptMode = isSubagentSessionKey(params.sessionKey) || isCronSessionKey(params.sessionKey)
+            ? "minimal"
+            : "full";
         const docsPath = await resolvePoolbotDocsPath({
             workspaceDir: effectiveWorkspace,
             argv1: process.argv[1],
@@ -272,12 +390,20 @@ export async function compactEmbeddedPiSessionDirect(params) {
             userTime,
             userTimeFormat,
             contextFiles,
+            memoryCitationsMode: params.config?.memory?.citations,
         });
         const systemPromptOverride = createSystemPromptOverride(appendPrompt);
         const sessionLock = await acquireSessionWriteLock({
             sessionFile: params.sessionFile,
+            maxHoldMs: resolveSessionLockMaxHoldFromTimeout({
+                timeoutMs: EMBEDDED_COMPACTION_TIMEOUT_MS,
+            }),
         });
         try {
+            await repairSessionFileIfNeeded({
+                sessionFile: params.sessionFile,
+                warn: (message) => log.warn(message),
+            });
             await prewarmSessionFile(params.sessionFile);
             const transcriptPolicy = resolveTranscriptPolicy({
                 modelApi: model.api,
@@ -326,6 +452,7 @@ export async function compactEmbeddedPiSessionDirect(params) {
                     modelApi: model.api,
                     modelId,
                     provider,
+                    config: params.config,
                     sessionManager,
                     sessionId: params.sessionId,
                     policy: transcriptPolicy,
@@ -336,11 +463,54 @@ export async function compactEmbeddedPiSessionDirect(params) {
                 const validated = transcriptPolicy.validateAnthropicTurns
                     ? validateAnthropicTurns(validatedGemini)
                     : validatedGemini;
-                const limited = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                // Capture full message history BEFORE limiting — plugins need the complete conversation
+                const preCompactionMessages = [...session.messages];
+                const truncated = limitHistoryTurns(validated, getDmHistoryLimitFromSessionKey(params.sessionKey, params.config));
+                // Re-run tool_use/tool_result pairing repair after truncation, since
+                // limitHistoryTurns can orphan tool_result blocks by removing the
+                // assistant message that contained the matching tool_use.
+                const limited = transcriptPolicy.repairToolUseResultPairing
+                    ? sanitizeToolUseResultPairing(truncated)
+                    : truncated;
                 if (limited.length > 0) {
                     session.agent.replaceMessages(limited);
                 }
-                const result = await session.compact(params.customInstructions);
+                // Run before_compaction hooks (fire-and-forget).
+                // The session JSONL already contains all messages on disk, so plugins
+                // can read sessionFile asynchronously and process in parallel with
+                // the compaction LLM call — no need to block or wait for after_compaction.
+                const hookRunner = getGlobalHookRunner();
+                const hookCtx = {
+                    agentId: params.sessionKey?.split(":")[0] ?? "main",
+                    sessionKey: params.sessionKey,
+                    sessionId: params.sessionId,
+                    workspaceDir: params.workspaceDir,
+                    messageProvider: params.messageChannel ?? params.messageProvider,
+                };
+                if (hookRunner?.hasHooks("before_compaction")) {
+                    hookRunner
+                        .runBeforeCompaction({
+                        messageCount: preCompactionMessages.length,
+                        compactingCount: limited.length,
+                        messages: preCompactionMessages,
+                        sessionFile: params.sessionFile,
+                    }, hookCtx)
+                        .catch((hookErr) => {
+                        log.warn(`before_compaction hook failed: ${String(hookErr)}`);
+                    });
+                }
+                const diagEnabled = log.isEnabled("debug");
+                const preMetrics = diagEnabled ? summarizeCompactionMessages(session.messages) : undefined;
+                if (diagEnabled && preMetrics) {
+                    log.debug(`[compaction-diag] start runId=${runId} sessionKey=${params.sessionKey ?? params.sessionId} ` +
+                        `diagId=${diagId} trigger=${trigger} provider=${provider}/${modelId} ` +
+                        `attempt=${attempt} maxAttempts=${maxAttempts} ` +
+                        `pre.messages=${preMetrics.messages} pre.historyTextChars=${preMetrics.historyTextChars} ` +
+                        `pre.toolResultChars=${preMetrics.toolResultChars} pre.estTokens=${preMetrics.estTokens ?? "unknown"}`);
+                    log.debug(`[compaction-diag] contributors diagId=${diagId} top=${JSON.stringify(preMetrics.contributors)}`);
+                }
+                const compactStartedAt = Date.now();
+                const result = await compactWithSafetyTimeout(() => session.compact(params.customInstructions));
                 // Estimate tokens after compaction by summing token estimates for remaining messages
                 let tokensAfter;
                 try {
@@ -357,6 +527,34 @@ export async function compactEmbeddedPiSessionDirect(params) {
                     // If estimation fails, leave tokensAfter undefined
                     tokensAfter = undefined;
                 }
+                // Run after_compaction hooks (fire-and-forget).
+                // Also includes sessionFile for plugins that only need to act after
+                // compaction completes (e.g. analytics, cleanup).
+                if (hookRunner?.hasHooks("after_compaction")) {
+                    hookRunner
+                        .runAfterCompaction({
+                        messageCount: session.messages.length,
+                        tokenCount: tokensAfter,
+                        compactedCount: limited.length - session.messages.length,
+                        sessionFile: params.sessionFile,
+                    }, hookCtx)
+                        .catch((hookErr) => {
+                        log.warn(`after_compaction hook failed: ${hookErr}`);
+                    });
+                }
+                const postMetrics = diagEnabled ? summarizeCompactionMessages(session.messages) : undefined;
+                if (diagEnabled && preMetrics && postMetrics) {
+                    log.debug(`[compaction-diag] end runId=${runId} sessionKey=${params.sessionKey ?? params.sessionId} ` +
+                        `diagId=${diagId} trigger=${trigger} provider=${provider}/${modelId} ` +
+                        `attempt=${attempt} maxAttempts=${maxAttempts} outcome=compacted reason=none ` +
+                        `durationMs=${Date.now() - compactStartedAt} retrying=false ` +
+                        `post.messages=${postMetrics.messages} post.historyTextChars=${postMetrics.historyTextChars} ` +
+                        `post.toolResultChars=${postMetrics.toolResultChars} post.estTokens=${postMetrics.estTokens ?? "unknown"} ` +
+                        `delta.messages=${postMetrics.messages - preMetrics.messages} ` +
+                        `delta.historyTextChars=${postMetrics.historyTextChars - preMetrics.historyTextChars} ` +
+                        `delta.toolResultChars=${postMetrics.toolResultChars - preMetrics.toolResultChars} ` +
+                        `delta.estTokens=${typeof preMetrics.estTokens === "number" && typeof postMetrics.estTokens === "number" ? postMetrics.estTokens - preMetrics.estTokens : "unknown"}`);
+                }
                 return {
                     ok: true,
                     compacted: true,
@@ -370,7 +568,10 @@ export async function compactEmbeddedPiSessionDirect(params) {
                 };
             }
             finally {
-                sessionManager.flushPendingToolResults?.();
+                await flushPendingToolResultsAfterIdle({
+                    agent: session?.agent,
+                    sessionManager,
+                });
                 session.dispose();
             }
         }
@@ -379,11 +580,8 @@ export async function compactEmbeddedPiSessionDirect(params) {
         }
     }
     catch (err) {
-        return {
-            ok: false,
-            compacted: false,
-            reason: describeUnknownError(err),
-        };
+        const reason = describeUnknownError(err);
+        return fail(reason);
     }
     finally {
         restoreSkillEnv?.();

package/dist/agents/pi-embedded-runner/extra-params.js

@@ -1,5 +1,15 @@
 import { streamSimple } from "@mariozechner/pi-ai";
 import { log } from "./logger.js";
+const OPENROUTER_APP_HEADERS = {
+    "HTTP-Referer": "https://poolbot.dev",
+    "X-Title": "PoolBot",
+};
+const ANTHROPIC_CONTEXT_1M_BETA = "context-1m-2025-08-07";
+const ANTHROPIC_1M_MODEL_PREFIXES = ["claude-opus-4", "claude-sonnet-4"];
+// NOTE: We only force `store=true` for *direct* OpenAI Responses.
+// Codex responses (chatgpt.com/backend-api/codex/responses) require `store=false`.
+const OPENAI_RESPONSES_APIS = new Set(["openai-responses"]);
+const OPENAI_RESPONSES_PROVIDERS = new Set(["openai"]);
 /**
  * Resolve provider-specific extra params from model config.
  * Used to pass through stream params like temperature/maxTokens.
@@ -11,17 +21,35 @@ export function resolveExtraParams(params) {
     const modelConfig = params.cfg?.agents?.defaults?.models?.[modelKey];
     return modelConfig?.params ? { ...modelConfig.params } : undefined;
 }
-function resolveCacheControlTtl(extraParams, provider, modelId) {
-    const raw = extraParams?.cacheControlTtl;
-    if (raw !== "5m" && raw !== "1h")
+/**
+ * Resolve cacheRetention from extraParams, supporting both new `cacheRetention`
+ * and legacy `cacheControlTtl` values for backwards compatibility.
+ *
+ * Mapping: "5m" → "short", "1h" → "long"
+ *
+ * Only applies to Anthropic provider (OpenRouter uses openai-completions API
+ * with hardcoded cache_control, not the cacheRetention stream option).
+ */
+function resolveCacheRetention(extraParams, provider) {
+    if (provider !== "anthropic") {
         return undefined;
-    if (provider === "anthropic")
-        return raw;
-    if (provider === "openrouter" && modelId.startsWith("anthropic/"))
-        return raw;
+    }
+    // Prefer new cacheRetention if present
+    const newVal = extraParams?.cacheRetention;
+    if (newVal === "none" || newVal === "short" || newVal === "long") {
+        return newVal;
+    }
+    // Fall back to legacy cacheControlTtl with mapping
+    const legacy = extraParams?.cacheControlTtl;
+    if (legacy === "5m") {
+        return "short";
+    }
+    if (legacy === "1h") {
+        return "long";
+    }
     return undefined;
 }
-function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider, modelId) {
+function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider) {
     if (!extraParams || Object.keys(extraParams).length === 0) {
         return undefined;
     }
@@ -32,9 +60,9 @@ function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider, mode
     if (typeof extraParams.maxTokens === "number") {
         streamParams.maxTokens = extraParams.maxTokens;
     }
-    const cacheControlTtl = resolveCacheControlTtl(extraParams, provider, modelId);
-    if (cacheControlTtl) {
-        streamParams.cacheControlTtl = cacheControlTtl;
+    const cacheRetention = resolveCacheRetention(extraParams, provider);
+    if (cacheRetention) {
+        streamParams.cacheRetention = cacheRetention;
     }
     if (Object.keys(streamParams).length === 0) {
         return undefined;
@@ -47,8 +75,149 @@ function createStreamFnWithExtraParams(baseStreamFn, extraParams, provider, mode
     });
     return wrappedStreamFn;
 }
+function isDirectOpenAIBaseUrl(baseUrl) {
+    if (typeof baseUrl !== "string" || !baseUrl.trim()) {
+        return true;
+    }
+    try {
+        const host = new URL(baseUrl).hostname.toLowerCase();
+        return host === "api.openai.com" || host === "chatgpt.com";
+    }
+    catch {
+        const normalized = baseUrl.toLowerCase();
+        return normalized.includes("api.openai.com") || normalized.includes("chatgpt.com");
+    }
+}
+function shouldForceResponsesStore(model) {
+    if (typeof model.api !== "string" || typeof model.provider !== "string") {
+        return false;
+    }
+    if (!OPENAI_RESPONSES_APIS.has(model.api)) {
+        return false;
+    }
+    if (!OPENAI_RESPONSES_PROVIDERS.has(model.provider)) {
+        return false;
+    }
+    return isDirectOpenAIBaseUrl(model.baseUrl);
+}
+function createOpenAIResponsesStoreWrapper(baseStreamFn) {
+    const underlying = baseStreamFn ?? streamSimple;
+    return (model, context, options) => {
+        if (!shouldForceResponsesStore(model)) {
+            return underlying(model, context, options);
+        }
+        const originalOnPayload = options?.onPayload;
+        return underlying(model, context, {
+            ...options,
+            onPayload: (payload) => {
+                if (payload && typeof payload === "object") {
+                    payload.store = true;
+                }
+                originalOnPayload?.(payload);
+            },
+        });
+    };
+}
+function isAnthropic1MModel(modelId) {
+    const normalized = modelId.trim().toLowerCase();
+    return ANTHROPIC_1M_MODEL_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+function parseHeaderList(value) {
+    if (typeof value !== "string") {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function resolveAnthropicBetas(extraParams, provider, modelId) {
+    if (provider !== "anthropic") {
+        return undefined;
+    }
+    const betas = new Set();
+    const configured = extraParams?.anthropicBeta;
+    if (typeof configured === "string" && configured.trim()) {
+        betas.add(configured.trim());
+    }
+    else if (Array.isArray(configured)) {
+        for (const beta of configured) {
+            if (typeof beta === "string" && beta.trim()) {
+                betas.add(beta.trim());
+            }
+        }
+    }
+    if (extraParams?.context1m === true) {
+        if (isAnthropic1MModel(modelId)) {
+            betas.add(ANTHROPIC_CONTEXT_1M_BETA);
+        }
+        else {
+            log.warn(`ignoring context1m for non-opus/sonnet model: ${provider}/${modelId}`);
+        }
+    }
+    return betas.size > 0 ? [...betas] : undefined;
+}
+function mergeAnthropicBetaHeader(headers, betas) {
+    const merged = { ...headers };
+    const existingKey = Object.keys(merged).find((key) => key.toLowerCase() === "anthropic-beta");
+    const existing = existingKey ? parseHeaderList(merged[existingKey]) : [];
+    const values = Array.from(new Set([...existing, ...betas]));
+    const key = existingKey ?? "anthropic-beta";
+    merged[key] = values.join(",");
+    return merged;
+}
+function createAnthropicBetaHeadersWrapper(baseStreamFn, betas) {
+    const underlying = baseStreamFn ?? streamSimple;
+    return (model, context, options) => underlying(model, context, {
+        ...options,
+        headers: mergeAnthropicBetaHeader(options?.headers, betas),
+    });
+}
+/**
+ * Create a streamFn wrapper that adds OpenRouter app attribution headers.
+ * These headers allow Pool Bot to appear on OpenRouter's leaderboard.
+ */
+function createOpenRouterHeadersWrapper(baseStreamFn) {
+    const underlying = baseStreamFn ?? streamSimple;
+    return (model, context, options) => underlying(model, context, {
+        ...options,
+        headers: {
+            ...OPENROUTER_APP_HEADERS,
+            ...options?.headers,
+        },
+    });
+}
+/**
+ * Create a streamFn wrapper that injects tool_stream=true for Z.AI providers.
+ *
+ * Z.AI's API supports the `tool_stream` parameter to enable real-time streaming
+ * of tool call arguments and reasoning content. When enabled, the API returns
+ * progressive tool_call deltas, allowing users to see tool execution in real-time.
+ *
+ * @see https://docs.z.ai/api-reference#streaming
+ */
+function createZaiToolStreamWrapper(baseStreamFn, enabled) {
+    const underlying = baseStreamFn ?? streamSimple;
+    return (model, context, options) => {
+        if (!enabled) {
+            return underlying(model, context, options);
+        }
+        const originalOnPayload = options?.onPayload;
+        return underlying(model, context, {
+            ...options,
+            onPayload: (payload) => {
+                if (payload && typeof payload === "object") {
+                    // Inject tool_stream: true for Z.AI API
+                    payload.tool_stream = true;
+                }
+                originalOnPayload?.(payload);
+            },
+        });
+    };
+}
 /**
  * Apply extra params (like temperature) to an agent's streamFn.
+ * Also adds OpenRouter app attribution headers when using the OpenRouter provider.
  *
  * @internal Exported for testing
  */
@@ -62,9 +231,31 @@ export function applyExtraParamsToAgent(agent, cfg, provider, modelId, extraPara
         ? Object.fromEntries(Object.entries(extraParamsOverride).filter(([, value]) => value !== undefined))
         : undefined;
     const merged = Object.assign({}, extraParams, override);
-    const wrappedStreamFn = createStreamFnWithExtraParams(agent.streamFn, merged, provider, modelId);
+    const wrappedStreamFn = createStreamFnWithExtraParams(agent.streamFn, merged, provider);
     if (wrappedStreamFn) {
         log.debug(`applying extraParams to agent streamFn for ${provider}/${modelId}`);
         agent.streamFn = wrappedStreamFn;
     }
+    const anthropicBetas = resolveAnthropicBetas(merged, provider, modelId);
+    if (anthropicBetas?.length) {
+        log.debug(`applying Anthropic beta header for ${provider}/${modelId}: ${anthropicBetas.join(",")}`);
+        agent.streamFn = createAnthropicBetaHeadersWrapper(agent.streamFn, anthropicBetas);
+    }
+    if (provider === "openrouter") {
+        log.debug(`applying OpenRouter app attribution headers for ${provider}/${modelId}`);
+        agent.streamFn = createOpenRouterHeadersWrapper(agent.streamFn);
+    }
+    // Enable Z.AI tool_stream for real-time tool call streaming.
+    // Enabled by default for Z.AI provider, can be disabled via params.tool_stream: false
+    if (provider === "zai" || provider === "z-ai") {
+        const toolStreamEnabled = merged?.tool_stream !== false;
+        if (toolStreamEnabled) {
+            log.debug(`enabling Z.AI tool_stream for ${provider}/${modelId}`);
+            agent.streamFn = createZaiToolStreamWrapper(agent.streamFn, true);
+        }
+    }
+    // Work around upstream pi-ai hardcoding `store: false` for Responses API.
+    // Force `store=true` for direct OpenAI/OpenAI Codex providers so multi-turn
+    // server-side conversation state is preserved.
+    agent.streamFn = createOpenAIResponsesStoreWrapper(agent.streamFn);
 }