@poolzin/pool-bot 2026.3.22 → 2026.3.23

package/dist/acp/runtime/registry.js

@@ -0,0 +1,86 @@
+import { AcpRuntimeError } from "./errors.js";
+const ACP_RUNTIME_REGISTRY_STATE_KEY = Symbol.for("poolbot.acpRuntimeRegistryState");
+function createAcpRuntimeRegistryGlobalState() {
+    return {
+        backendsById: new Map(),
+    };
+}
+function resolveAcpRuntimeRegistryGlobalState() {
+    const runtimeGlobal = globalThis;
+    if (!runtimeGlobal[ACP_RUNTIME_REGISTRY_STATE_KEY]) {
+        runtimeGlobal[ACP_RUNTIME_REGISTRY_STATE_KEY] = createAcpRuntimeRegistryGlobalState();
+    }
+    return runtimeGlobal[ACP_RUNTIME_REGISTRY_STATE_KEY];
+}
+const ACP_BACKENDS_BY_ID = resolveAcpRuntimeRegistryGlobalState().backendsById;
+function normalizeBackendId(id) {
+    return id?.trim().toLowerCase() || "";
+}
+function isBackendHealthy(backend) {
+    if (!backend.healthy) {
+        return true;
+    }
+    try {
+        return backend.healthy();
+    }
+    catch {
+        return false;
+    }
+}
+export function registerAcpRuntimeBackend(backend) {
+    const id = normalizeBackendId(backend.id);
+    if (!id) {
+        throw new Error("ACP runtime backend id is required");
+    }
+    if (!backend.runtime) {
+        throw new Error(`ACP runtime backend "${id}" is missing runtime implementation`);
+    }
+    ACP_BACKENDS_BY_ID.set(id, {
+        ...backend,
+        id,
+    });
+}
+export function unregisterAcpRuntimeBackend(id) {
+    const normalized = normalizeBackendId(id);
+    if (!normalized) {
+        return;
+    }
+    ACP_BACKENDS_BY_ID.delete(normalized);
+}
+export function getAcpRuntimeBackend(id) {
+    const normalized = normalizeBackendId(id);
+    if (normalized) {
+        return ACP_BACKENDS_BY_ID.get(normalized) ?? null;
+    }
+    if (ACP_BACKENDS_BY_ID.size === 0) {
+        return null;
+    }
+    for (const backend of ACP_BACKENDS_BY_ID.values()) {
+        if (isBackendHealthy(backend)) {
+            return backend;
+        }
+    }
+    return ACP_BACKENDS_BY_ID.values().next().value ?? null;
+}
+export function requireAcpRuntimeBackend(id) {
+    const normalized = normalizeBackendId(id);
+    const backend = getAcpRuntimeBackend(normalized || undefined);
+    if (!backend) {
+        throw new AcpRuntimeError("ACP_BACKEND_MISSING", "ACP runtime backend is not configured. Install and enable the acpx runtime plugin.");
+    }
+    if (!isBackendHealthy(backend)) {
+        throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime backend is currently unavailable. Try again in a moment.");
+    }
+    if (normalized && backend.id !== normalized) {
+        throw new AcpRuntimeError("ACP_BACKEND_MISSING", `ACP runtime backend "${normalized}" is not registered.`);
+    }
+    return backend;
+}
+export const __testing = {
+    resetAcpRuntimeBackendsForTests() {
+        ACP_BACKENDS_BY_ID.clear();
+    },
+    getAcpRuntimeRegistryGlobalStateForTests() {
+        return resolveAcpRuntimeRegistryGlobalState();
+    },
+};

package/dist/acp/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/acp/translator.js

@@ -342,3 +342,100 @@ export class AcpGatewayAgent {
         });
     }
 }
+/**
+ * Apply prompt prefix to a prompt request
+ */
+export function applyPromptPrefix(request, config) {
+    if (!config.enabled || !config.prefix) {
+        return request;
+    }
+    // Check session filter
+    if (config.sessionIds && !config.sessionIds.includes(request.sessionId)) {
+        return request;
+    }
+    // Apply prefix to prompt text
+    const modified = { ...request };
+    if (modified.prompt) {
+        const promptText = typeof modified.prompt === "string" ? modified.prompt : JSON.stringify(modified.prompt);
+        modified.prompt = (config.prefix + "\n\n" + promptText);
+    }
+    return modified;
+}
+/**
+ * Cancel scoping manager to prevent cascade cancels
+ */
+export class CancelScopingManager {
+    cancelHistory = [];
+    config;
+    constructor(config = {}) {
+        this.config = {
+            enabled: config.enabled ?? true,
+            timeWindowMs: config.timeWindowMs ?? 5000, // 5 seconds default
+            maxCancelsInWindow: config.maxCancelsInWindow ?? 3,
+            sessionIds: config.sessionIds,
+        };
+    }
+    /**
+     * Check if a cancel request should be allowed
+     */
+    shouldAllowCancel(sessionId, reason) {
+        if (!this.config.enabled) {
+            return { allowed: true };
+        }
+        // Check session filter
+        if (this.config.sessionIds && !this.config.sessionIds.includes(sessionId)) {
+            return { allowed: true };
+        }
+        const now = Date.now();
+        const windowStart = now - (this.config.timeWindowMs ?? 5000);
+        // Clean old records
+        this.cancelHistory = this.cancelHistory.filter((r) => r.timestamp > windowStart);
+        // Count recent cancels for this session
+        const recentCancels = this.cancelHistory.filter((r) => r.sessionId === sessionId && r.timestamp > windowStart).length;
+        const maxAllowed = this.config.maxCancelsInWindow ?? 3;
+        if (recentCancels >= maxAllowed) {
+            return {
+                allowed: false,
+                reason: `Cancel rate limit exceeded: ${recentCancels}/${maxAllowed} cancels in the last ${this.config.timeWindowMs}ms`,
+            };
+        }
+        // Record this cancel
+        this.cancelHistory.push({
+            sessionId,
+            timestamp: now,
+            reason,
+        });
+        return { allowed: true };
+    }
+    /**
+     * Clear cancel history
+     */
+    clear() {
+        this.cancelHistory = [];
+    }
+    /**
+     * Get statistics about cancel activity
+     */
+    getStats() {
+        const now = Date.now();
+        const windowStart = now - (this.config.timeWindowMs ?? 5000);
+        const recentHistory = this.cancelHistory.filter((r) => r.timestamp > windowStart);
+        const cancelsBySession = recentHistory.reduce((acc, r) => {
+            acc[r.sessionId] = (acc[r.sessionId] || 0) + 1;
+            return acc;
+        }, {});
+        return {
+            totalCancels: recentHistory.length,
+            cancelsBySession,
+            oldestCancelInWindow: recentHistory.length > 0 ? Math.min(...recentHistory.map((r) => r.timestamp)) : undefined,
+        };
+    }
+}
+/**
+ * Process a cancel notification with scoping
+ */
+export function processCancelWithScoping(notification, manager) {
+    const sessionId = notification.sessionId || "unknown";
+    const reason = notification.reason || "user_requested";
+    return manager.shouldAllowCancel(sessionId, reason);
+}

package/dist/agents/failover-error.js

@@ -1,5 +1,5 @@
-import { classifyFailoverReason } from "./pi-embedded-helpers.js";
-const TIMEOUT_HINT_RE = /timeout|timed out|deadline exceeded|context deadline exceeded/i;
+import { readErrorName } from "../infra/errors.js";
+import { classifyFailoverReason, isTimeoutErrorMessage, } from "./pi-embedded-helpers.js";
 const ABORT_TIMEOUT_RE = /request was aborted|request aborted/i;
 export class FailoverError extends Error {
     reason;
@@ -28,104 +28,200 @@ export function resolveFailoverStatus(reason) {
             return 402;
         case "rate_limit":
             return 429;
+        case "overloaded":
+            return 503;
         case "auth":
             return 401;
+        case "auth_permanent":
+            return 403;
         case "timeout":
             return 408;
         case "format":
             return 400;
         case "model_not_found":
             return 404;
+        case "session_expired":
+            return 410; // Gone - session no longer exists
         default:
             return undefined;
     }
 }
-function getStatusCode(err) {
-    if (!err || typeof err !== "object")
+function findErrorProperty(err, reader, seen = new Set()) {
+    const direct = reader(err);
+    if (direct !== undefined) {
+        return direct;
+    }
+    if (!err || typeof err !== "object") {
+        return undefined;
+    }
+    if (seen.has(err)) {
+        return undefined;
+    }
+    seen.add(err);
+    const candidate = err;
+    return (findErrorProperty(candidate.error, reader, seen) ??
+        findErrorProperty(candidate.cause, reader, seen));
+}
+function readDirectStatusCode(err) {
+    if (!err || typeof err !== "object") {
         return undefined;
+    }
     const candidate = err.status ??
         err.statusCode;
-    if (typeof candidate === "number")
+    if (typeof candidate === "number") {
         return candidate;
+    }
     if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
         return Number(candidate);
     }
     return undefined;
 }
-function getErrorName(err) {
-    if (!err || typeof err !== "object")
-        return "";
-    return "name" in err ? String(err.name) : "";
+function getStatusCode(err) {
+    return findErrorProperty(err, readDirectStatusCode);
 }
-function getErrorCode(err) {
-    if (!err || typeof err !== "object")
+function readDirectErrorCode(err) {
+    if (!err || typeof err !== "object") {
         return undefined;
-    const candidate = err.code;
-    if (typeof candidate !== "string")
+    }
+    const directCode = err.code;
+    if (typeof directCode === "string") {
+        const trimmed = directCode.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    const status = err.status;
+    if (typeof status !== "string" || /^\d+$/.test(status)) {
         return undefined;
-    const trimmed = candidate.trim();
+    }
+    const trimmed = status.trim();
     return trimmed ? trimmed : undefined;
 }
-function getErrorMessage(err) {
-    if (err instanceof Error)
-        return err.message;
-    if (typeof err === "string")
-        return err;
+function getErrorCode(err) {
+    return findErrorProperty(err, readDirectErrorCode);
+}
+function readDirectErrorMessage(err) {
+    if (err instanceof Error) {
+        return err.message || undefined;
+    }
+    if (typeof err === "string") {
+        return err || undefined;
+    }
     if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") {
         return String(err);
     }
-    if (typeof err === "symbol")
-        return err.description ?? "";
+    if (typeof err === "symbol") {
+        return err.description ?? undefined;
+    }
     if (err && typeof err === "object") {
         const message = err.message;
-        if (typeof message === "string")
-            return message;
+        if (typeof message === "string") {
+            return message || undefined;
+        }
+    }
+    return undefined;
+}
+function getErrorMessage(err) {
+    return findErrorProperty(err, readDirectErrorMessage) ?? "";
+}
+function getErrorCause(err) {
+    if (!err || typeof err !== "object" || !("cause" in err)) {
+        return undefined;
+    }
+    return err.cause;
+}
+/** Classify rate-limit / overloaded from symbolic error codes like RESOURCE_EXHAUSTED. */
+function classifyFailoverReasonFromSymbolicCode(raw) {
+    const normalized = raw?.trim().toUpperCase();
+    if (!normalized) {
+        return null;
+    }
+    switch (normalized) {
+        case "RESOURCE_EXHAUSTED":
+        case "RATE_LIMIT":
+        case "RATE_LIMITED":
+        case "RATE_LIMIT_EXCEEDED":
+        case "TOO_MANY_REQUESTS":
+        case "THROTTLED":
+        case "THROTTLING":
+        case "THROTTLINGEXCEPTION":
+        case "THROTTLING_EXCEPTION":
+            return "rate_limit";
+        case "OVERLOADED":
+        case "OVERLOADED_ERROR":
+            return "overloaded";
+        default:
+            return null;
     }
-    return "";
 }
 function hasTimeoutHint(err) {
-    if (!err)
+    if (!err) {
         return false;
-    if (getErrorName(err) === "TimeoutError")
+    }
+    if (readErrorName(err) === "TimeoutError") {
         return true;
+    }
     const message = getErrorMessage(err);
-    return Boolean(message && TIMEOUT_HINT_RE.test(message));
+    return Boolean(message && isTimeoutErrorMessage(message));
 }
 export function isTimeoutError(err) {
-    if (hasTimeoutHint(err))
+    if (hasTimeoutHint(err)) {
         return true;
-    if (!err || typeof err !== "object")
+    }
+    if (!err || typeof err !== "object") {
         return false;
-    if (getErrorName(err) !== "AbortError")
+    }
+    if (readErrorName(err) !== "AbortError") {
         return false;
+    }
     const message = getErrorMessage(err);
-    if (message && ABORT_TIMEOUT_RE.test(message))
+    if (message && ABORT_TIMEOUT_RE.test(message)) {
         return true;
+    }
     const cause = "cause" in err ? err.cause : undefined;
     const reason = "reason" in err ? err.reason : undefined;
     return hasTimeoutHint(cause) || hasTimeoutHint(reason);
 }
 export function resolveFailoverReasonFromError(err) {
-    if (isFailoverError(err))
+    if (isFailoverError(err)) {
         return err.reason;
-    const status = getStatusCode(err);
-    if (status === 402)
-        return "billing";
-    if (status === 429)
-        return "rate_limit";
-    if (status === 401 || status === 403)
-        return "auth";
-    if (status === 408)
-        return "timeout";
+    }
+    const message = getErrorMessage(err);
+    // Check symbolic error codes (e.g. RESOURCE_EXHAUSTED from Google APIs)
+    const symbolicCodeReason = classifyFailoverReasonFromSymbolicCode(getErrorCode(err));
+    if (symbolicCodeReason) {
+        return symbolicCodeReason;
+    }
     const code = (getErrorCode(err) ?? "").toUpperCase();
-    if (["ETIMEDOUT", "ESOCKETTIMEDOUT", "ECONNRESET", "ECONNABORTED"].includes(code)) {
+    if ([
+        "ETIMEDOUT",
+        "ESOCKETTIMEDOUT",
+        "ECONNRESET",
+        "ECONNABORTED",
+        "ECONNREFUSED",
+        "ENETUNREACH",
+        "EHOSTUNREACH",
+        "EHOSTDOWN",
+        "ENETRESET",
+        "EPIPE",
+        "EAI_AGAIN",
+    ].includes(code)) {
         return "timeout";
     }
-    if (isTimeoutError(err))
+    // Walk into error cause chain *before* timeout heuristics so that a specific
+    // cause (e.g. RESOURCE_EXHAUSTED wrapped in AbortError) overrides a parent
+    // message-based "timeout" guess from isTimeoutError.
+    const cause = getErrorCause(err);
+    if (cause && cause !== err) {
+        const causeReason = resolveFailoverReasonFromError(cause);
+        if (causeReason) {
+            return causeReason;
+        }
+    }
+    if (isTimeoutError(err)) {
         return "timeout";
-    const message = getErrorMessage(err);
-    if (!message)
+    }
+    if (!message) {
         return null;
+    }
     return classifyFailoverReason(message);
 }
 export function describeFailoverError(err) {
@@ -146,11 +242,13 @@ export function describeFailoverError(err) {
     };
 }
 export function coerceToFailoverError(err, context) {
-    if (isFailoverError(err))
+    if (isFailoverError(err)) {
         return err;
+    }
     const reason = resolveFailoverReasonFromError(err);
-    if (!reason)
+    if (!reason) {
         return null;
+    }
     const message = getErrorMessage(err) || String(err);
     const status = getStatusCode(err) ?? resolveFailoverStatus(reason);
     const code = getErrorCode(err);