@poolzin/pool-bot 2026.2.11 → 2026.2.18

package/dist/agents/command-poll-backoff.js

@@ -0,0 +1,63 @@
+// Exponential backoff schedule for command polling
+const BACKOFF_SCHEDULE_MS = [5000, 10000, 30000, 60000];
+/**
+ * Calculate suggested retry delay based on consecutive no-output poll count.
+ * Implements exponential backoff schedule: 5s → 10s → 30s → 60s (capped).
+ */
+export function calculateBackoffMs(consecutiveNoOutputPolls) {
+    const index = Math.min(consecutiveNoOutputPolls, BACKOFF_SCHEDULE_MS.length - 1);
+    return BACKOFF_SCHEDULE_MS[index] ?? 60000;
+}
+/**
+ * Record a command poll and return suggested retry delay.
+ * @param state Session state to track polling in
+ * @param commandId Unique identifier for the command being polled
+ * @param hasNewOutput Whether this poll returned new output
+ * @returns Suggested delay in milliseconds before next poll
+ */
+export function recordCommandPoll(state, commandId, hasNewOutput) {
+    if (!state.commandPollCounts) {
+        state.commandPollCounts = new Map();
+    }
+    const existing = state.commandPollCounts.get(commandId);
+    const now = Date.now();
+    if (hasNewOutput) {
+        state.commandPollCounts.set(commandId, { count: 0, lastPollAt: now });
+        return BACKOFF_SCHEDULE_MS[0] ?? 5000;
+    }
+    const newCount = (existing?.count ?? -1) + 1;
+    state.commandPollCounts.set(commandId, { count: newCount, lastPollAt: now });
+    return calculateBackoffMs(newCount);
+}
+/**
+ * Get current suggested backoff for a command without modifying state.
+ * Useful for checking current backoff level.
+ */
+export function getCommandPollSuggestion(state, commandId) {
+    const pollData = state.commandPollCounts?.get(commandId);
+    if (!pollData) {
+        return undefined;
+    }
+    return calculateBackoffMs(pollData.count);
+}
+/**
+ * Reset poll count for a command (e.g., when command completes).
+ */
+export function resetCommandPollCount(state, commandId) {
+    state.commandPollCounts?.delete(commandId);
+}
+/**
+ * Prune stale command poll records (older than 1 hour).
+ * Call periodically to prevent memory bloat.
+ */
+export function pruneStaleCommandPolls(state, maxAgeMs = 3600000) {
+    if (!state.commandPollCounts) {
+        return;
+    }
+    const now = Date.now();
+    for (const [commandId, data] of state.commandPollCounts.entries()) {
+        if (now - data.lastPollAt > maxAgeMs) {
+            state.commandPollCounts.delete(commandId);
+        }
+    }
+}

package/dist/agents/current-time.js

@@ -0,0 +1,16 @@
+import { formatUserTime, resolveUserTimeFormat, resolveUserTimezone, } from "./date-time.js";
+export function resolveCronStyleNow(cfg, nowMs) {
+    const userTimezone = resolveUserTimezone(cfg.agents?.defaults?.userTimezone);
+    const userTimeFormat = resolveUserTimeFormat(cfg.agents?.defaults?.timeFormat);
+    const formattedTime = formatUserTime(new Date(nowMs), userTimezone, userTimeFormat) ?? new Date(nowMs).toISOString();
+    const timeLine = `Current time: ${formattedTime} (${userTimezone})`;
+    return { userTimezone, formattedTime, timeLine };
+}
+export function appendCronStyleCurrentTimeLine(text, cfg, nowMs) {
+    const base = text.trimEnd();
+    if (!base || base.includes("Current time:")) {
+        return base;
+    }
+    const { timeLine } = resolveCronStyleNow(cfg, nowMs);
+    return `${base}\n${timeLine}`;
+}

package/dist/agents/glob-pattern.js

@@ -0,0 +1,42 @@
+function escapeRegex(value) {
+    // Standard "escape string for regex literal" pattern.
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function compileGlobPattern(params) {
+    const normalized = params.normalize(params.raw);
+    if (!normalized) {
+        return { kind: "exact", value: "" };
+    }
+    if (normalized === "*") {
+        return { kind: "all" };
+    }
+    if (!normalized.includes("*")) {
+        return { kind: "exact", value: normalized };
+    }
+    return {
+        kind: "regex",
+        value: new RegExp(`^${escapeRegex(normalized).replaceAll("\\*", ".*")}$`),
+    };
+}
+export function compileGlobPatterns(params) {
+    if (!Array.isArray(params.raw)) {
+        return [];
+    }
+    return params.raw
+        .map((raw) => compileGlobPattern({ raw, normalize: params.normalize }))
+        .filter((pattern) => pattern.kind !== "exact" || pattern.value);
+}
+export function matchesAnyGlobPattern(value, patterns) {
+    for (const pattern of patterns) {
+        if (pattern.kind === "all") {
+            return true;
+        }
+        if (pattern.kind === "exact" && value === pattern.value) {
+            return true;
+        }
+        if (pattern.kind === "regex" && pattern.value.test(value)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/agents/memory-search.js

@@ -17,6 +17,10 @@ const DEFAULT_HYBRID_ENABLED = true;
 const DEFAULT_HYBRID_VECTOR_WEIGHT = 0.7;
 const DEFAULT_HYBRID_TEXT_WEIGHT = 0.3;
 const DEFAULT_HYBRID_CANDIDATE_MULTIPLIER = 4;
+const DEFAULT_MMR_ENABLED = false;
+const DEFAULT_MMR_LAMBDA = 0.7;
+const DEFAULT_TEMPORAL_DECAY_ENABLED = false;
+const DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS = 30;
 const DEFAULT_CACHE_ENABLED = true;
 const DEFAULT_SOURCES = ["memory"];
 function normalizeSources(sources, sessionMemoryEnabled) {
@@ -141,6 +145,22 @@ function mergeConfig(defaults, overrides, agentId) {
         candidateMultiplier: overrides?.query?.hybrid?.candidateMultiplier ??
             defaults?.query?.hybrid?.candidateMultiplier ??
             DEFAULT_HYBRID_CANDIDATE_MULTIPLIER,
+        mmr: {
+            enabled: overrides?.query?.hybrid?.mmr?.enabled ??
+                defaults?.query?.hybrid?.mmr?.enabled ??
+                DEFAULT_MMR_ENABLED,
+            lambda: overrides?.query?.hybrid?.mmr?.lambda ??
+                defaults?.query?.hybrid?.mmr?.lambda ??
+                DEFAULT_MMR_LAMBDA,
+        },
+        temporalDecay: {
+            enabled: overrides?.query?.hybrid?.temporalDecay?.enabled ??
+                defaults?.query?.hybrid?.temporalDecay?.enabled ??
+                DEFAULT_TEMPORAL_DECAY_ENABLED,
+            halfLifeDays: overrides?.query?.hybrid?.temporalDecay?.halfLifeDays ??
+                defaults?.query?.hybrid?.temporalDecay?.halfLifeDays ??
+                DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS,
+        },
     };
     const cache = {
         enabled: overrides?.cache?.enabled ?? defaults?.cache?.enabled ?? DEFAULT_CACHE_ENABLED,
@@ -154,6 +174,9 @@ function mergeConfig(defaults, overrides, agentId) {
     const normalizedVectorWeight = sum > 0 ? vectorWeight / sum : DEFAULT_HYBRID_VECTOR_WEIGHT;
     const normalizedTextWeight = sum > 0 ? textWeight / sum : DEFAULT_HYBRID_TEXT_WEIGHT;
     const candidateMultiplier = clampInt(hybrid.candidateMultiplier, 1, 20);
+    const temporalDecayHalfLifeDays = Math.max(1, Math.floor(Number.isFinite(hybrid.temporalDecay.halfLifeDays)
+        ? hybrid.temporalDecay.halfLifeDays
+        : DEFAULT_TEMPORAL_DECAY_HALF_LIFE_DAYS));
     const deltaBytes = clampInt(sync.sessions.deltaBytes, 0, Number.MAX_SAFE_INTEGER);
     const deltaMessages = clampInt(sync.sessions.deltaMessages, 0, Number.MAX_SAFE_INTEGER);
     return {
@@ -185,6 +208,16 @@ function mergeConfig(defaults, overrides, agentId) {
                 vectorWeight: normalizedVectorWeight,
                 textWeight: normalizedTextWeight,
                 candidateMultiplier,
+                mmr: {
+                    enabled: Boolean(hybrid.mmr.enabled),
+                    lambda: Number.isFinite(hybrid.mmr.lambda)
+                        ? Math.max(0, Math.min(1, hybrid.mmr.lambda))
+                        : DEFAULT_MMR_LAMBDA,
+                },
+                temporalDecay: {
+                    enabled: Boolean(hybrid.temporalDecay.enabled),
+                    halfLifeDays: temporalDecayHalfLifeDays,
+                },
             },
         },
         cache: {

package/dist/agents/model-alias-lines.js

@@ -0,0 +1,18 @@
+export function buildModelAliasLines(cfg) {
+    const models = cfg?.agents?.defaults?.models ?? {};
+    const entries = [];
+    for (const [keyRaw, entryRaw] of Object.entries(models)) {
+        const model = String(keyRaw ?? "").trim();
+        if (!model) {
+            continue;
+        }
+        const alias = String(entryRaw?.alias ?? "").trim();
+        if (!alias) {
+            continue;
+        }
+        entries.push({ alias, model });
+    }
+    return entries
+        .toSorted((a, b) => a.alias.localeCompare(b.alias))
+        .map((entry) => `- ${entry.alias}: ${entry.model}`);
+}

package/dist/agents/model-auth-label.js

@@ -0,0 +1,61 @@
+import { ensureAuthProfileStore, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "./auth-profiles.js";
+import { getCustomProviderApiKey, resolveEnvApiKey } from "./model-auth.js";
+import { normalizeProviderId } from "./model-selection.js";
+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}`;
+}
+export 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";
+}

package/dist/agents/model-fallback.js

@@ -1,7 +1,7 @@
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./defaults.js";
 import { coerceToFailoverError, describeFailoverError, isFailoverError, isTimeoutError, } from "./failover-error.js";
 import { buildModelAliasIndex, modelKey, parseModelRef, resolveConfiguredModelRef, resolveModelRefFromString, } from "./model-selection.js";
-import { ensureAuthProfileStore, isProfileInCooldown, resolveAuthProfileOrder, } from "./auth-profiles.js";
+import { ensureAuthProfileStore, getSoonestCooldownExpiry, isProfileInCooldown, resolveAuthProfileOrder, } from "./auth-profiles.js";
 function isAbortError(err) {
     if (!err || typeof err !== "object")
         return false;
@@ -135,6 +135,36 @@ function resolveFallbackCandidates(params) {
     }
     return candidates;
 }
+const lastProbeAttempt = new Map();
+const MIN_PROBE_INTERVAL_MS = 30_000; // 30 seconds between probes per key
+const PROBE_MARGIN_MS = 2 * 60 * 1000;
+const PROBE_SCOPE_DELIMITER = "::";
+function resolveProbeThrottleKey(provider, agentDir) {
+    const scope = String(agentDir ?? "").trim();
+    return scope ? `${scope}${PROBE_SCOPE_DELIMITER}${provider}` : provider;
+}
+function shouldProbePrimaryDuringCooldown(params) {
+    if (!params.isPrimary || !params.hasFallbackCandidates) {
+        return false;
+    }
+    const lastProbe = lastProbeAttempt.get(params.throttleKey) ?? 0;
+    if (params.now - lastProbe < MIN_PROBE_INTERVAL_MS) {
+        return false;
+    }
+    const soonest = getSoonestCooldownExpiry(params.authStore, params.profileIds);
+    if (soonest === null || !Number.isFinite(soonest)) {
+        return true;
+    }
+    // Probe when cooldown already expired or within the configured margin.
+    return params.now >= soonest - PROBE_MARGIN_MS;
+}
+/** @internal – exposed for unit tests only */
+export const _probeThrottleInternals = {
+    lastProbeAttempt,
+    MIN_PROBE_INTERVAL_MS,
+    PROBE_MARGIN_MS,
+    resolveProbeThrottleKey,
+};
 export async function runWithModelFallback(params) {
     const candidates = resolveFallbackCandidates({
         cfg: params.cfg,
@@ -146,6 +176,7 @@ export async function runWithModelFallback(params) {
         ? ensureAuthProfileStore(params.agentDir, { allowKeychainPrompt: false })
         : null;
     const attempts = [];
+    const hasFallbackCandidates = candidates.length > 1;
     let lastError;
     for (let i = 0; i < candidates.length; i += 1) {
         const candidate = candidates[i];
@@ -157,14 +188,34 @@ export async function runWithModelFallback(params) {
             });
             const isAnyProfileAvailable = profileIds.some((id) => !isProfileInCooldown(authStore, id));
             if (profileIds.length > 0 && !isAnyProfileAvailable) {
-                // All profiles for this provider are in cooldown; skip without attempting
-                attempts.push({
-                    provider: candidate.provider,
-                    model: candidate.model,
-                    error: `Provider ${candidate.provider} is in cooldown (all profiles unavailable)`,
-                    reason: "rate_limit",
+                // All profiles for this provider are in cooldown.
+                // For the primary model (i === 0), probe it if the soonest cooldown
+                // expiry is close or already past. This avoids staying on a fallback
+                // model long after the real rate-limit window clears.
+                const now = Date.now();
+                const probeThrottleKey = resolveProbeThrottleKey(candidate.provider, params.agentDir);
+                const shouldProbe = shouldProbePrimaryDuringCooldown({
+                    isPrimary: i === 0,
+                    hasFallbackCandidates,
+                    now,
+                    throttleKey: probeThrottleKey,
+                    authStore,
+                    profileIds,
                 });
-                continue;
+                if (!shouldProbe) {
+                    // Skip without attempting
+                    attempts.push({
+                        provider: candidate.provider,
+                        model: candidate.model,
+                        error: `Provider ${candidate.provider} is in cooldown (all profiles unavailable)`,
+                        reason: "rate_limit",
+                    });
+                    continue;
+                }
+                // Primary model probe: attempt it despite cooldown to detect recovery.
+                // If it fails, the error is caught below and we fall through to the
+                // next candidate as usual.
+                lastProbeAttempt.set(probeThrottleKey, now);
             }
         }
         try {

package/dist/agents/models-config.e2e-harness.js

@@ -0,0 +1,115 @@
+import { withTempHome as withTempHomeBase } from "../../test/helpers/temp-home.js";
+import { afterEach, beforeEach, vi } from "vitest";
+export async function withModelsTempHome(fn) {
+    return withTempHomeBase(fn, { prefix: "openclaw-models-" });
+}
+export function installModelsConfigTestHooks(opts) {
+    let previousHome;
+    const originalFetch = globalThis.fetch;
+    beforeEach(() => {
+        previousHome = process.env.HOME;
+    });
+    afterEach(() => {
+        process.env.HOME = previousHome;
+        if (opts?.restoreFetch && originalFetch) {
+            globalThis.fetch = originalFetch;
+        }
+    });
+}
+export async function withTempEnv(vars, fn) {
+    const previous = {};
+    for (const envVar of vars) {
+        previous[envVar] = process.env[envVar];
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        for (const envVar of vars) {
+            const value = previous[envVar];
+            if (value === undefined) {
+                delete process.env[envVar];
+            }
+            else {
+                process.env[envVar] = value;
+            }
+        }
+    }
+}
+export function unsetEnv(vars) {
+    for (const envVar of vars) {
+        delete process.env[envVar];
+    }
+}
+export const COPILOT_TOKEN_ENV_VARS = ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"];
+export async function withUnsetCopilotTokenEnv(fn) {
+    return withTempEnv(COPILOT_TOKEN_ENV_VARS, async () => {
+        unsetEnv(COPILOT_TOKEN_ENV_VARS);
+        return fn();
+    });
+}
+export function mockCopilotTokenExchangeSuccess() {
+    const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        json: async () => ({
+            token: "copilot-token;proxy-ep=proxy.copilot.example",
+            expires_at: Math.floor(Date.now() / 1000) + 3600,
+        }),
+    });
+    globalThis.fetch = fetchMock;
+    return fetchMock;
+}
+export const MODELS_CONFIG_IMPLICIT_ENV_VARS = [
+    "CLOUDFLARE_AI_GATEWAY_API_KEY",
+    "COPILOT_GITHUB_TOKEN",
+    "GH_TOKEN",
+    "GITHUB_TOKEN",
+    "HF_TOKEN",
+    "HUGGINGFACE_HUB_TOKEN",
+    "MINIMAX_API_KEY",
+    "MOONSHOT_API_KEY",
+    "NVIDIA_API_KEY",
+    "OLLAMA_API_KEY",
+    "POOLBOT_AGENT_DIR",
+    "PI_CODING_AGENT_DIR",
+    "QIANFAN_API_KEY",
+    "SYNTHETIC_API_KEY",
+    "TOGETHER_API_KEY",
+    "VENICE_API_KEY",
+    "VLLM_API_KEY",
+    "XIAOMI_API_KEY",
+    // Avoid ambient AWS creds unintentionally enabling Bedrock discovery.
+    "AWS_ACCESS_KEY_ID",
+    "AWS_CONFIG_FILE",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "AWS_DEFAULT_REGION",
+    "AWS_PROFILE",
+    "AWS_REGION",
+    "AWS_SESSION_TOKEN",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SHARED_CREDENTIALS_FILE",
+];
+export const CUSTOM_PROXY_MODELS_CONFIG = {
+    models: {
+        providers: {
+            "custom-proxy": {
+                baseUrl: "http://localhost:4000/v1",
+                apiKey: "TEST_KEY",
+                api: "openai-completions",
+                models: [
+                    {
+                        id: "llama-3.1-8b",
+                        name: "Llama 3.1 8B (Proxy)",
+                        api: "openai-completions",
+                        reasoning: false,
+                        input: ["text"],
+                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                        contextWindow: 128000,
+                        maxTokens: 32000,
+                    },
+                ],
+            },
+        },
+    },
+};

package/dist/agents/ollama-stream.js

@@ -1,5 +1,5 @@
-import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
 import { randomUUID } from "node:crypto";
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai";
 export const OLLAMA_NATIVE_BASE_URL = "http://127.0.0.1:11434";
 function extractTextContent(content) {
     if (typeof content === "string") {
@@ -102,8 +102,12 @@ function extractOllamaTools(tools) {
 // ── Response conversion ─────────────────────────────────────────────────────
 export function buildAssistantMessage(response, modelInfo) {
     const content = [];
-    if (response.message.content) {
-        content.push({ type: "text", text: response.message.content });
+    // Qwen 3 (and potentially other reasoning models) may return their final
+    // answer in a `reasoning` field with an empty `content`. Fall back to
+    // `reasoning` so the response isn't silently dropped.
+    const text = response.message.content || response.message.reasoning || "";
+    if (text) {
+        content.push({ type: "text", text });
     }
     const toolCalls = response.message.tool_calls;
     if (toolCalls && toolCalls.length > 0) {
@@ -230,6 +234,10 @@ export function createOllamaStreamFn(baseUrl) {
                     if (chunk.message?.content) {
                         accumulatedContent += chunk.message.content;
                     }
+                    else if (chunk.message?.reasoning) {
+                        // Qwen 3 reasoning mode: content may be empty, output in reasoning
+                        accumulatedContent += chunk.message.reasoning;
+                    }
                     // Ollama sends tool_calls in intermediate (done:false) chunks,
                     // NOT in the final done:true chunk. Collect from all chunks.
                     if (chunk.message?.tool_calls) {

package/dist/agents/openclaw-tools.js

@@ -0,0 +1,135 @@
+import { resolvePluginTools } from "../plugins/tools.js";
+import { resolveSessionAgentId } from "./agent-scope.js";
+import { createAgentsListTool } from "./tools/agents-list-tool.js";
+import { createBrowserTool } from "./tools/browser-tool.js";
+import { createCanvasTool } from "./tools/canvas-tool.js";
+import { createCronTool } from "./tools/cron-tool.js";
+import { createGatewayTool } from "./tools/gateway-tool.js";
+import { createImageTool } from "./tools/image-tool.js";
+import { createMessageTool } from "./tools/message-tool.js";
+import { createNodesTool } from "./tools/nodes-tool.js";
+import { createSessionStatusTool } from "./tools/session-status-tool.js";
+import { createSessionsHistoryTool } from "./tools/sessions-history-tool.js";
+import { createSessionsListTool } from "./tools/sessions-list-tool.js";
+import { createSessionsSendTool } from "./tools/sessions-send-tool.js";
+import { createSessionsSpawnTool } from "./tools/sessions-spawn-tool.js";
+import { createSubagentsTool } from "./tools/subagents-tool.js";
+import { createTtsTool } from "./tools/tts-tool.js";
+import { createWebFetchTool, createWebSearchTool } from "./tools/web-tools.js";
+import { resolveWorkspaceRoot } from "./workspace-dir.js";
+export function createOpenClawTools(options) {
+    const workspaceDir = resolveWorkspaceRoot(options?.workspaceDir);
+    const imageTool = options?.agentDir?.trim()
+        ? createImageTool({
+            config: options?.config,
+            agentDir: options.agentDir,
+            workspaceDir,
+            sandbox: options?.sandboxRoot && options?.sandboxFsBridge
+                ? { root: options.sandboxRoot, bridge: options.sandboxFsBridge }
+                : undefined,
+            modelHasVision: options?.modelHasVision,
+        })
+        : null;
+    const webSearchTool = createWebSearchTool({
+        config: options?.config,
+        sandboxed: options?.sandboxed,
+    });
+    const webFetchTool = createWebFetchTool({
+        config: options?.config,
+        sandboxed: options?.sandboxed,
+    });
+    const messageTool = options?.disableMessageTool
+        ? null
+        : createMessageTool({
+            agentAccountId: options?.agentAccountId,
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+            currentChannelId: options?.currentChannelId,
+            currentChannelProvider: options?.agentChannel,
+            currentThreadTs: options?.currentThreadTs,
+            replyToMode: options?.replyToMode,
+            hasRepliedRef: options?.hasRepliedRef,
+            sandboxRoot: options?.sandboxRoot,
+            requireExplicitTarget: options?.requireExplicitMessageTarget,
+        });
+    const tools = [
+        createBrowserTool({
+            sandboxBridgeUrl: options?.sandboxBrowserBridgeUrl,
+            allowHostControl: options?.allowHostBrowserControl,
+        }),
+        createCanvasTool(),
+        createNodesTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        createCronTool({
+            agentSessionKey: options?.agentSessionKey,
+        }),
+        ...(messageTool ? [messageTool] : []),
+        createTtsTool({
+            agentChannel: options?.agentChannel,
+            config: options?.config,
+        }),
+        createGatewayTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        createAgentsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            requesterAgentIdOverride: options?.requesterAgentIdOverride,
+        }),
+        createSessionsListTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsHistoryTool({
+            agentSessionKey: options?.agentSessionKey,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSendTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            sandboxed: options?.sandboxed,
+        }),
+        createSessionsSpawnTool({
+            agentSessionKey: options?.agentSessionKey,
+            agentChannel: options?.agentChannel,
+            agentAccountId: options?.agentAccountId,
+            agentTo: options?.agentTo,
+            agentThreadId: options?.agentThreadId,
+            agentGroupId: options?.agentGroupId,
+            agentGroupChannel: options?.agentGroupChannel,
+            agentGroupSpace: options?.agentGroupSpace,
+            sandboxed: options?.sandboxed,
+            requesterAgentIdOverride: options?.requesterAgentIdOverride,
+        }),
+        createSubagentsTool({
+            agentSessionKey: options?.agentSessionKey,
+        }),
+        createSessionStatusTool({
+            agentSessionKey: options?.agentSessionKey,
+            config: options?.config,
+        }),
+        ...(webSearchTool ? [webSearchTool] : []),
+        ...(webFetchTool ? [webFetchTool] : []),
+        ...(imageTool ? [imageTool] : []),
+    ];
+    const pluginTools = resolvePluginTools({
+        context: {
+            config: options?.config,
+            workspaceDir,
+            agentDir: options?.agentDir,
+            agentId: resolveSessionAgentId({
+                sessionKey: options?.agentSessionKey,
+                config: options?.config,
+            }),
+            sessionKey: options?.agentSessionKey,
+            messageChannel: options?.agentChannel,
+            agentAccountId: options?.agentAccountId,
+            sandboxed: options?.sandboxed,
+        },
+        existingToolNames: new Set(tools.map((tool) => tool.name)),
+        toolAllowlist: options?.pluginToolAllowlist,
+    });
+    return [...tools, ...pluginTools];
+}