@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/agents/model-fallback.js

@@ -151,7 +151,6 @@ function resolveFallbackCandidates(params) {
 }
 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();
@@ -169,14 +168,16 @@ function shouldProbePrimaryDuringCooldown(params) {
     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;
+    // FIX: Only probe when cooldown has actually expired.
+    // Previously we probed 2 minutes early (PROBE_MARGIN_MS), but this caused
+    // probes to fail and increase the cooldown, creating a vicious cycle where
+    // providers never recovered from cooldown.
+    return params.now >= soonest;
 }
 /** @internal – exposed for unit tests only */
 export const _probeThrottleInternals = {
     lastProbeAttempt,
     MIN_PROBE_INTERVAL_MS,
-    PROBE_MARGIN_MS,
     resolveProbeThrottleKey,
 };
 export async function runWithModelFallback(params) {

package/dist/agents/tools/common.js

@@ -1,209 +1,24 @@
-import fs from "node:fs/promises";
-import { detectMime } from "../../media/mime.js";
-import { sanitizeToolResultImages } from "../tool-images.js";
-export const OWNER_ONLY_TOOL_ERROR = "Tool restricted to owner senders.";
-export class ToolInputError extends Error {
-    status = 400;
-    constructor(message) {
-        super(message);
-        this.name = "ToolInputError";
-    }
-}
-export class ToolAuthorizationError extends ToolInputError {
-    status = 403;
-    constructor(message) {
-        super(message);
-        this.name = "ToolAuthorizationError";
-    }
-}
-export function createActionGate(actions) {
-    return (key, defaultValue = true) => {
-        const value = actions?.[key];
-        if (value === undefined) {
-            return defaultValue;
-        }
-        return value !== false;
-    };
-}
-export function readStringParam(params, key, options = {}) {
-    const { required = false, trim = true, label = key, allowEmpty = false } = options;
-    const raw = params[key];
-    if (typeof raw !== "string") {
-        if (required) {
-            throw new ToolInputError(`${label} required`);
-        }
+// Stub for agents/tools/common.js
+export function readNumberParam(params, key, opts) {
+    const val = params[key];
+    if (typeof val !== "number")
         return undefined;
-    }
-    const value = trim ? raw.trim() : raw;
-    if (!value && !allowEmpty) {
-        if (required) {
-            throw new ToolInputError(`${label} required`);
-        }
+    if (opts?.integer && !Number.isInteger(val))
         return undefined;
-    }
-    return value;
-}
-export function readStringOrNumberParam(params, key, options = {}) {
-    const { required = false, label = key } = options;
-    const raw = params[key];
-    if (typeof raw === "number" && Number.isFinite(raw)) {
-        return String(raw);
-    }
-    if (typeof raw === "string") {
-        const value = raw.trim();
-        if (value) {
-            return value;
-        }
-    }
-    if (required) {
-        throw new ToolInputError(`${label} required`);
-    }
-    return undefined;
-}
-export function readNumberParam(params, key, options = {}) {
-    const { required = false, label = key, integer = false } = options;
-    const raw = params[key];
-    let value;
-    if (typeof raw === "number" && Number.isFinite(raw)) {
-        value = raw;
-    }
-    else if (typeof raw === "string") {
-        const trimmed = raw.trim();
-        if (trimmed) {
-            const parsed = Number.parseFloat(trimmed);
-            if (Number.isFinite(parsed)) {
-                value = parsed;
-            }
-        }
-    }
-    if (value === undefined) {
-        if (required) {
-            throw new ToolInputError(`${label} required`);
-        }
-        return undefined;
-    }
-    return integer ? Math.trunc(value) : value;
-}
-export function readStringArrayParam(params, key, options = {}) {
-    const { required = false, label = key } = options;
-    const raw = params[key];
-    if (Array.isArray(raw)) {
-        const values = raw
-            .filter((entry) => typeof entry === "string")
-            .map((entry) => entry.trim())
-            .filter(Boolean);
-        if (values.length === 0) {
-            if (required) {
-                throw new ToolInputError(`${label} required`);
-            }
-            return undefined;
-        }
-        return values;
-    }
-    if (typeof raw === "string") {
-        const value = raw.trim();
-        if (!value) {
-            if (required) {
-                throw new ToolInputError(`${label} required`);
-            }
-            return undefined;
-        }
-        return [value];
-    }
-    if (required) {
-        throw new ToolInputError(`${label} required`);
-    }
-    return undefined;
-}
-export function readReactionParams(params, options) {
-    const emojiKey = options.emojiKey ?? "emoji";
-    const removeKey = options.removeKey ?? "remove";
-    const remove = typeof params[removeKey] === "boolean" ? params[removeKey] : false;
-    const emoji = readStringParam(params, emojiKey, {
-        required: true,
-        allowEmpty: true,
-    });
-    if (remove && !emoji) {
-        throw new ToolInputError(options.removeErrorMessage);
-    }
-    return { emoji, remove, isEmpty: !emoji };
-}
-export function jsonResult(payload) {
-    return {
-        content: [
-            {
-                type: "text",
-                text: JSON.stringify(payload, null, 2),
-            },
-        ],
-        details: payload,
-    };
-}
-export function wrapOwnerOnlyToolExecution(tool, senderIsOwner) {
-    if (tool.ownerOnly !== true || senderIsOwner || !tool.execute) {
-        return tool;
-    }
-    return {
-        ...tool,
-        execute: async () => {
-            throw new Error(OWNER_ONLY_TOOL_ERROR);
-        },
-    };
-}
-export async function imageResult(params) {
-    const content = [
-        {
-            type: "text",
-            text: params.extraText ?? `MEDIA:${params.path}`,
-        },
-        {
-            type: "image",
-            data: params.base64,
-            mimeType: params.mimeType,
-        },
-    ];
-    const result = {
-        content,
-        details: { path: params.path, ...params.details },
-    };
-    return await sanitizeToolResultImages(result, params.label, params.imageSanitization);
-}
-export async function imageResultFromFile(params) {
-    const buf = await fs.readFile(params.path);
-    const mimeType = (await detectMime({ buffer: buf.slice(0, 256) })) ?? "image/png";
-    return await imageResult({
-        label: params.label,
-        path: params.path,
-        base64: buf.toString("base64"),
-        mimeType,
-        extraText: params.extraText,
-        details: params.details,
-        imageSanitization: params.imageSanitization,
-    });
+    return val;
 }
-/**
- * Validate and parse an `availableTags` parameter from untrusted input.
- * Returns `undefined` when the value is missing or not an array.
- * Entries that lack a string `name` are silently dropped.
- */
-export function parseAvailableTags(raw) {
-    if (raw === undefined || raw === null) {
+export function readStringParam(params, key, opts) {
+    const val = params[key];
+    if (typeof val !== "string") {
+        if (opts?.required)
+            throw new Error(`Missing required param: ${key}`);
         return undefined;
     }
-    if (!Array.isArray(raw)) {
+    const trimmed = opts?.trim !== false ? val.trim() : val;
+    if (!trimmed && !opts?.allowEmpty) {
+        if (opts?.required)
+            throw new Error(`Missing required param: ${key}`);
         return undefined;
     }
-    const result = raw
-        .filter((t) => typeof t === "object" && t !== null && typeof t.name === "string")
-        .map((t) => ({
-        ...(t.id !== undefined && typeof t.id === "string" ? { id: t.id } : {}),
-        name: t.name,
-        ...(typeof t.moderated === "boolean" ? { moderated: t.moderated } : {}),
-        ...(t.emoji_id === null || typeof t.emoji_id === "string" ? { emoji_id: t.emoji_id } : {}),
-        ...(t.emoji_name === null || typeof t.emoji_name === "string"
-            ? { emoji_name: t.emoji_name }
-            : {}),
-    }));
-    // Return undefined instead of empty array to avoid accidentally clearing all tags
-    return result.length ? result : undefined;
+    return trimmed;
 }