@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/agents/model-selection.js

@@ -1,11 +1,13 @@
-import { normalizeGoogleModelId } from "./models-config.providers.js";
-import { resolveAgentModelPrimary } from "./agent-scope.js";
+import { resolveAgentConfig, resolveAgentModelPrimary } from "./agent-scope.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "./defaults.js";
+import { normalizeGoogleModelId } from "./models-config.providers.js";
 const ANTHROPIC_MODEL_ALIASES = {
     "opus-4.6": "claude-opus-4-6",
     "opus-4.5": "claude-opus-4-5",
+    "sonnet-4.6": "claude-sonnet-4-6",
     "sonnet-4.5": "claude-sonnet-4-5",
 };
+const OPENAI_CODEX_OAUTH_MODEL_PREFIXES = ["gpt-5.3-codex"];
 function normalizeAliasKey(value) {
     return value.trim().toLowerCase();
 }
@@ -14,59 +16,115 @@ export function modelKey(provider, model) {
 }
 export function normalizeProviderId(provider) {
     const normalized = provider.trim().toLowerCase();
-    if (normalized === "z.ai" || normalized === "z-ai")
+    if (normalized === "z.ai" || normalized === "z-ai") {
         return "zai";
-    if (normalized === "opencode-zen")
+    }
+    if (normalized === "opencode-zen") {
         return "opencode";
-    if (normalized === "qwen")
+    }
+    if (normalized === "qwen") {
         return "qwen-portal";
-    if (normalized === "kimi-code")
+    }
+    if (normalized === "kimi-code") {
         return "kimi-coding";
+    }
     return normalized;
 }
+export function findNormalizedProviderValue(entries, provider) {
+    if (!entries) {
+        return undefined;
+    }
+    const providerKey = normalizeProviderId(provider);
+    for (const [key, value] of Object.entries(entries)) {
+        if (normalizeProviderId(key) === providerKey) {
+            return value;
+        }
+    }
+    return undefined;
+}
+export function findNormalizedProviderKey(entries, provider) {
+    if (!entries) {
+        return undefined;
+    }
+    const providerKey = normalizeProviderId(provider);
+    return Object.keys(entries).find((key) => normalizeProviderId(key) === providerKey);
+}
 export function isCliProvider(provider, cfg) {
     const normalized = normalizeProviderId(provider);
-    if (normalized === "claude-cli")
+    if (normalized === "claude-cli") {
         return true;
-    if (normalized === "codex-cli")
+    }
+    if (normalized === "codex-cli") {
         return true;
+    }
     const backends = cfg?.agents?.defaults?.cliBackends ?? {};
     return Object.keys(backends).some((key) => normalizeProviderId(key) === normalized);
 }
 function normalizeAnthropicModelId(model) {
     const trimmed = model.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return trimmed;
+    }
     const lower = trimmed.toLowerCase();
-    const aliased = ANTHROPIC_MODEL_ALIASES[lower];
-    if (aliased)
-        return aliased;
-    return trimmed;
+    return ANTHROPIC_MODEL_ALIASES[lower] ?? trimmed;
 }
 function normalizeProviderModelId(provider, model) {
-    if (provider === "anthropic")
+    if (provider === "anthropic") {
         return normalizeAnthropicModelId(model);
-    if (provider === "google")
+    }
+    if (provider === "google") {
         return normalizeGoogleModelId(model);
+    }
     return model;
 }
+function shouldUseOpenAICodexProvider(provider, model) {
+    if (provider !== "openai") {
+        return false;
+    }
+    const normalized = model.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return OPENAI_CODEX_OAUTH_MODEL_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(`${prefix}-`));
+}
+export function normalizeModelRef(provider, model) {
+    const normalizedProvider = normalizeProviderId(provider);
+    const normalizedModel = normalizeProviderModelId(normalizedProvider, model.trim());
+    if (shouldUseOpenAICodexProvider(normalizedProvider, normalizedModel)) {
+        return { provider: "openai-codex", model: normalizedModel };
+    }
+    return { provider: normalizedProvider, model: normalizedModel };
+}
 export function parseModelRef(raw, defaultProvider) {
     const trimmed = raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     const slash = trimmed.indexOf("/");
     if (slash === -1) {
-        const provider = normalizeProviderId(defaultProvider);
-        const model = normalizeProviderModelId(provider, trimmed);
-        return { provider, model };
+        return normalizeModelRef(defaultProvider, trimmed);
     }
     const providerRaw = trimmed.slice(0, slash).trim();
-    const provider = normalizeProviderId(providerRaw);
     const model = trimmed.slice(slash + 1).trim();
-    if (!provider || !model)
+    if (!providerRaw || !model) {
         return null;
-    const normalizedModel = normalizeProviderModelId(provider, model);
-    return { provider, model: normalizedModel };
+    }
+    return normalizeModelRef(providerRaw, model);
+}
+export function normalizeModelSelection(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const primary = value.primary;
+    if (typeof primary === "string") {
+        const trimmed = primary.trim();
+        return trimmed || undefined;
+    }
+    return undefined;
 }
 export function resolveAllowlistModelKey(raw, defaultProvider) {
     const parsed = parseModelRef(raw, defaultProvider);
@@ -95,11 +153,13 @@ export function buildModelAliasIndex(params) {
     const rawModels = params.cfg.agents?.defaults?.models ?? {};
     for (const [keyRaw, entryRaw] of Object.entries(rawModels)) {
         const parsed = parseModelRef(String(keyRaw ?? ""), params.defaultProvider);
-        if (!parsed)
+        if (!parsed) {
             continue;
+        }
         const alias = String(entryRaw?.alias ?? "").trim();
-        if (!alias)
+        if (!alias) {
             continue;
+        }
         const aliasKey = normalizeAliasKey(alias);
         byAlias.set(aliasKey, { alias, ref: parsed });
         const key = modelKey(parsed.provider, parsed.model);
@@ -111,8 +171,9 @@ export function buildModelAliasIndex(params) {
 }
 export function resolveModelRefFromString(params) {
     const trimmed = params.raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return null;
+    }
     if (!trimmed.includes("/")) {
         const aliasKey = normalizeAliasKey(trimmed);
         const aliasMatch = params.aliasIndex?.byAlias.get(aliasKey);
@@ -121,15 +182,17 @@ export function resolveModelRefFromString(params) {
         }
     }
     const parsed = parseModelRef(trimmed, params.defaultProvider);
-    if (!parsed)
+    if (!parsed) {
         return null;
+    }
     return { ref: parsed };
 }
 export function resolveConfiguredModelRef(params) {
     const rawModel = (() => {
         const raw = params.cfg.agents?.defaults?.model;
-        if (typeof raw === "string")
+        if (typeof raw === "string") {
             return raw.trim();
+        }
         return raw?.primary?.trim() ?? "";
     })();
     if (rawModel) {
@@ -141,8 +204,9 @@ export function resolveConfiguredModelRef(params) {
         if (!trimmed.includes("/")) {
             const aliasKey = normalizeAliasKey(trimmed);
             const aliasMatch = aliasIndex.byAlias.get(aliasKey);
-            if (aliasMatch)
+            if (aliasMatch) {
                 return aliasMatch.ref;
+            }
             // Default to anthropic if no provider is specified, but warn as this is deprecated.
             console.warn(`[poolbot] Model "${trimmed}" specified without provider. Falling back to "anthropic/${trimmed}". Please use "anthropic/${trimmed}" in your config.`);
             return { provider: "anthropic", model: trimmed };
@@ -152,8 +216,9 @@ export function resolveConfiguredModelRef(params) {
             defaultProvider: params.defaultProvider,
             aliasIndex,
         });
-        if (resolved)
+        if (resolved) {
             return resolved.ref;
+        }
     }
     return { provider: params.defaultProvider, model: params.defaultModel };
 }
@@ -184,6 +249,25 @@ export function resolveDefaultModelForAgent(params) {
         defaultModel: DEFAULT_MODEL,
     });
 }
+export function resolveSubagentConfiguredModelSelection(params) {
+    const agentConfig = resolveAgentConfig(params.cfg, params.agentId);
+    return (normalizeModelSelection(agentConfig?.subagents?.model) ??
+        normalizeModelSelection(params.cfg.agents?.defaults?.subagents?.model) ??
+        normalizeModelSelection(agentConfig?.model));
+}
+export function resolveSubagentSpawnModelSelection(params) {
+    const runtimeDefault = resolveDefaultModelForAgent({
+        cfg: params.cfg,
+        agentId: params.agentId,
+    });
+    return (normalizeModelSelection(params.modelOverride) ??
+        resolveSubagentConfiguredModelSelection({
+            cfg: params.cfg,
+            agentId: params.agentId,
+        }) ??
+        normalizeModelSelection(params.cfg.agents?.defaults?.model?.primary) ??
+        `${runtimeDefault.provider}/${runtimeDefault.model}`);
+}
 export function buildAllowedModelSet(params) {
     const rawAllowlist = (() => {
         const modelMap = params.cfg.agents?.defaults?.models ?? {};
@@ -191,13 +275,15 @@ export function buildAllowedModelSet(params) {
     })();
     const allowAny = rawAllowlist.length === 0;
     const defaultModel = params.defaultModel?.trim();
-    const defaultKey = defaultModel && params.defaultProvider
-        ? modelKey(params.defaultProvider, defaultModel)
-        : undefined;
+    const defaultRef = defaultModel && params.defaultProvider
+        ? parseModelRef(defaultModel, params.defaultProvider)
+        : null;
+    const defaultKey = defaultRef ? modelKey(defaultRef.provider, defaultRef.model) : undefined;
     const catalogKeys = new Set(params.catalog.map((entry) => modelKey(entry.provider, entry.id)));
     if (allowAny) {
-        if (defaultKey)
+        if (defaultKey) {
             catalogKeys.add(defaultKey);
+        }
         return {
             allowAny: true,
             allowedCatalog: params.catalog,
@@ -208,8 +294,9 @@ export function buildAllowedModelSet(params) {
     const configuredProviders = (params.cfg.models?.providers ?? {});
     for (const raw of rawAllowlist) {
         const parsed = parseModelRef(String(raw), params.defaultProvider);
-        if (!parsed)
+        if (!parsed) {
             continue;
+        }
         const key = modelKey(parsed.provider, parsed.model);
         const providerKey = normalizeProviderId(parsed.provider);
         if (isCliProvider(parsed.provider, params.cfg)) {
@@ -229,8 +316,9 @@ export function buildAllowedModelSet(params) {
     }
     const allowedCatalog = params.catalog.filter((entry) => allowedKeys.has(modelKey(entry.provider, entry.id)));
     if (allowedCatalog.length === 0 && allowedKeys.size === 0) {
-        if (defaultKey)
+        if (defaultKey) {
             catalogKeys.add(defaultKey);
+        }
         return {
             allowAny: true,
             allowedCatalog: params.catalog,
@@ -256,8 +344,9 @@ export function getModelRefStatus(params) {
 }
 export function resolveAllowedModelRef(params) {
     const trimmed = params.raw.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return { error: "invalid model: empty" };
+    }
     const aliasIndex = buildModelAliasIndex({
         cfg: params.cfg,
         defaultProvider: params.defaultProvider,
@@ -267,8 +356,9 @@ export function resolveAllowedModelRef(params) {
         defaultProvider: params.defaultProvider,
         aliasIndex,
     });
-    if (!resolved)
+    if (!resolved) {
         return { error: `invalid model: ${trimmed}` };
+    }
     const status = getModelRefStatus({
         cfg: params.cfg,
         catalog: params.catalog,
@@ -283,11 +373,13 @@ export function resolveAllowedModelRef(params) {
 }
 export function resolveThinkingDefault(params) {
     const configured = params.cfg.agents?.defaults?.thinkingDefault;
-    if (configured)
+    if (configured) {
         return configured;
+    }
     const candidate = params.catalog?.find((entry) => entry.provider === params.provider && entry.id === params.model);
-    if (candidate?.reasoning)
+    if (candidate?.reasoning) {
         return "low";
+    }
     return "off";
 }
 /**
@@ -296,8 +388,9 @@ export function resolveThinkingDefault(params) {
  */
 export function resolveHooksGmailModel(params) {
     const hooksModel = params.cfg.hooks?.gmail?.model;
-    if (!hooksModel?.trim())
+    if (!hooksModel?.trim()) {
         return null;
+    }
     const aliasIndex = buildModelAliasIndex({
         cfg: params.cfg,
         defaultProvider: params.defaultProvider,

package/dist/agents/pi-auth-json.js

@@ -16,7 +16,7 @@ async function readAuthJson(filePath) {
     }
 }
 /**
- * Convert an OpenClaw auth-profiles credential to pi-coding-agent auth.json format.
+ * Convert an Pool Bot auth-profiles credential to pi-coding-agent auth.json format.
  * Returns null if the credential cannot be converted.
  */
 function convertCredential(cred) {
@@ -76,7 +76,7 @@ function credentialsEqual(a, b) {
 /**
  * pi-coding-agent's ModelRegistry/AuthStorage expects credentials in auth.json.
  *
- * OpenClaw stores credentials in auth-profiles.json instead. This helper
+ * Pool Bot stores credentials in auth-profiles.json instead. This helper
  * bridges all credentials into agentDir/auth.json so pi-coding-agent can
  * (a) consider providers authenticated and (b) include built-in models in its
  * registry/catalog output.

package/dist/agents/pi-embedded-helpers/bootstrap.js

@@ -1,17 +1,21 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { truncateUtf16Safe } from "../../utils.js";
 function isBase64Signature(value) {
     const trimmed = value.trim();
-    if (!trimmed)
+    if (!trimmed) {
         return false;
+    }
     const compact = trimmed.replace(/\s+/g, "");
-    if (!/^[A-Za-z0-9+/=_-]+$/.test(compact))
+    if (!/^[A-Za-z0-9+/=_-]+$/.test(compact)) {
         return false;
+    }
     const isUrl = compact.includes("-") || compact.includes("_");
     try {
         const buf = Buffer.from(compact, isUrl ? "base64url" : "base64");
-        if (buf.length === 0)
+        if (buf.length === 0) {
             return false;
+        }
         const encoded = buf.toString(isUrl ? "base64url" : "base64");
         const normalize = (input) => input.replace(/=+$/g, "");
         return normalize(encoded) === normalize(compact);
@@ -27,8 +31,9 @@ function isBase64Signature(value) {
  * like "msg_abc123...". We only strip "msg_*" to preserve any provider-valid signatures.
  */
 export function stripThoughtSignatures(content, options) {
-    if (!Array.isArray(content))
+    if (!Array.isArray(content)) {
         return content;
+    }
     const allowBase64Only = options?.allowBase64Only ?? false;
     const includeCamelCase = options?.includeCamelCase ?? false;
     const shouldStripSignature = (value) => {
@@ -38,8 +43,9 @@ export function stripThoughtSignatures(content, options) {
         return typeof value !== "string" || !isBase64Signature(value);
     };
     return content.map((block) => {
-        if (!block || typeof block !== "object")
+        if (!block || typeof block !== "object") {
             return block;
+        }
         const rec = block;
         const stripSnake = shouldStripSignature(rec.thought_signature);
         const stripCamel = includeCamelCase ? shouldStripSignature(rec.thoughtSignature) : false;
@@ -47,14 +53,18 @@ export function stripThoughtSignatures(content, options) {
             return block;
         }
         const next = { ...rec };
-        if (stripSnake)
+        if (stripSnake) {
             delete next.thought_signature;
-        if (stripCamel)
+        }
+        if (stripCamel) {
             delete next.thoughtSignature;
+        }
         return next;
     });
 }
 export const DEFAULT_BOOTSTRAP_MAX_CHARS = 20_000;
+export const DEFAULT_BOOTSTRAP_TOTAL_MAX_CHARS = 150_000;
+const MIN_BOOTSTRAP_FILE_BUDGET_CHARS = 64;
 const BOOTSTRAP_HEAD_RATIO = 0.7;
 const BOOTSTRAP_TAIL_RATIO = 0.2;
 export function resolveBootstrapMaxChars(cfg) {
@@ -64,6 +74,13 @@ export function resolveBootstrapMaxChars(cfg) {
     }
     return DEFAULT_BOOTSTRAP_MAX_CHARS;
 }
+export function resolveBootstrapTotalMaxChars(cfg) {
+    const raw = cfg?.agents?.defaults?.bootstrapTotalMaxChars;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+        return Math.floor(raw);
+    }
+    return DEFAULT_BOOTSTRAP_TOTAL_MAX_CHARS;
+}
 function trimBootstrapContent(content, fileName, maxChars) {
     const trimmed = content.trimEnd();
     if (trimmed.length <= maxChars) {
@@ -92,6 +109,19 @@ function trimBootstrapContent(content, fileName, maxChars) {
         originalLength: trimmed.length,
     };
 }
+function clampToBudget(content, budget) {
+    if (budget <= 0) {
+        return "";
+    }
+    if (content.length <= budget) {
+        return content;
+    }
+    if (budget <= 3) {
+        return truncateUtf16Safe(content, budget);
+    }
+    const safe = budget - 1;
+    return `${truncateUtf16Safe(content, safe)}…`;
+}
 export async function ensureSessionHeader(params) {
     const file = params.sessionFile;
     try {
@@ -114,24 +144,43 @@ export async function ensureSessionHeader(params) {
 }
 export function buildBootstrapContextFiles(files, opts) {
     const maxChars = opts?.maxChars ?? DEFAULT_BOOTSTRAP_MAX_CHARS;
+    const totalMaxChars = Math.max(1, Math.floor(opts?.totalMaxChars ?? Math.max(maxChars, DEFAULT_BOOTSTRAP_TOTAL_MAX_CHARS)));
+    let remainingTotalChars = totalMaxChars;
     const result = [];
     for (const file of files) {
+        if (remainingTotalChars <= 0) {
+            break;
+        }
         if (file.missing) {
+            const missingText = `[MISSING] Expected at: ${file.path}`;
+            const cappedMissingText = clampToBudget(missingText, remainingTotalChars);
+            if (!cappedMissingText) {
+                break;
+            }
+            remainingTotalChars = Math.max(0, remainingTotalChars - cappedMissingText.length);
             result.push({
-                path: file.name,
-                content: `[MISSING] Expected at: ${file.path}`,
+                path: file.path,
+                content: cappedMissingText,
             });
             continue;
         }
-        const trimmed = trimBootstrapContent(file.content ?? "", file.name, maxChars);
-        if (!trimmed.content)
+        if (remainingTotalChars < MIN_BOOTSTRAP_FILE_BUDGET_CHARS) {
+            opts?.warn?.(`remaining bootstrap budget is ${remainingTotalChars} chars (<${MIN_BOOTSTRAP_FILE_BUDGET_CHARS}); skipping additional bootstrap files`);
+            break;
+        }
+        const fileMaxChars = Math.max(1, Math.min(maxChars, remainingTotalChars));
+        const trimmed = trimBootstrapContent(file.content ?? "", file.name, fileMaxChars);
+        const contentWithinBudget = clampToBudget(trimmed.content, remainingTotalChars);
+        if (!contentWithinBudget) {
             continue;
-        if (trimmed.truncated) {
+        }
+        if (trimmed.truncated || contentWithinBudget.length < trimmed.content.length) {
             opts?.warn?.(`workspace bootstrap file ${file.name} is ${trimmed.originalLength} chars (limit ${trimmed.maxChars}); truncating in injected context`);
         }
+        remainingTotalChars = Math.max(0, remainingTotalChars - contentWithinBudget.length);
         result.push({
-            path: file.name,
-            content: trimmed.content,
+            path: file.path,
+            content: contentWithinBudget,
         });
     }
     return result;
@@ -146,8 +195,9 @@ export function sanitizeGoogleTurnOrdering(messages) {
         content.trim() === GOOGLE_TURN_ORDER_BOOTSTRAP_TEXT) {
         return messages;
     }
-    if (role !== "assistant")
+    if (role !== "assistant") {
         return messages;
+    }
     // Cloud Code Assist rejects histories that begin with a model turn (tool call or text).
     // Prepend a tiny synthetic user turn so the rest of the transcript can be used.
     const bootstrap = {