nolo-cli 0.33.0-alpha.9 → 0.34.0-alpha.3

package/chunk-X2K2JSO4.js

@@ -0,0 +1,163 @@
+// packages/ai/tools/agent/quotaCircuitBreaker.ts
+var QUOTA_ERROR_PATTERNS = [
+  /429/,
+  /quota/i,
+  /rate\s*limit/i,
+  /too\s*many\s*requests/i,
+  /额度/,
+  /上限/,
+  /用尽/,
+  /CliProviderQuotaError/i
+];
+function isCliProviderQuotaErrorShape(error) {
+  if (!error || typeof error !== "object") return false;
+  const e = error;
+  return e.name === "CliProviderQuotaError" || typeof e.message === "string" && e.message.startsWith("[QUOTA_LIMITED:");
+}
+function isQuotaExhaustedError(error) {
+  if (!error) return false;
+  if (isCliProviderQuotaErrorShape(error)) return true;
+  if (error instanceof Error) {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error.message));
+  }
+  if (typeof error === "string") {
+    return QUOTA_ERROR_PATTERNS.some((pattern) => pattern.test(error));
+  }
+  const maybeStatus = error.status;
+  if (typeof maybeStatus === "number" && maybeStatus === 429) return true;
+  const maybeStatusCode = error.statusCode;
+  if (typeof maybeStatusCode === "number" && maybeStatusCode === 429) return true;
+  return false;
+}
+function parseResetsInMs(text) {
+  if (!text) return void 0;
+  const unitMs = (n, unit) => {
+    if (/^d/.test(unit)) return n * 24 * 3600 * 1e3;
+    if (/^h/.test(unit)) return n * 3600 * 1e3;
+    if (/^m/.test(unit)) return n * 60 * 1e3;
+    if (/^s/.test(unit)) return n * 1e3;
+    return NaN;
+  };
+  const re = /(\d+)\s*(d(?:ay|ays)?|h(?:r|rs|our|ours)?|m(?:in|ins|inute|inutes)?|s(?:ec|ecs|econd|econds)?)/gi;
+  let totalMs = 0;
+  let matched = false;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    const ms = unitMs(Number(m[1]), m[2]);
+    if (!Number.isFinite(ms)) continue;
+    totalMs += ms;
+    matched = true;
+  }
+  return matched ? totalMs : void 0;
+}
+var DEFAULT_QUOTA_BREAKER_MS = 6 * 3600 * 1e3;
+var DEFAULT_AGENT_NOT_FOUND_BREAKER_MS = 15 * 60 * 1e3;
+
+// packages/ai/agent/agentAvailabilityShared.ts
+var DEFAULT_PROVIDER_RETRY_MS = 5 * 60 * 1e3;
+var MAX_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+function clampCooldownDeadline(at, now) {
+  const min = now;
+  const max = now + MAX_COOLDOWN_MS;
+  return Math.min(Math.max(at, min), max);
+}
+function isAgentUnavailableNow(agent, now = Date.now()) {
+  const at = agent?.nextAvailableAt;
+  return typeof at === "number" && Number.isFinite(at) && at > now;
+}
+function readRetryAfterTimestamp(body, now) {
+  if (!body || typeof body !== "object") return void 0;
+  const root = body;
+  const raw = root.retryAfter ?? root.retry_after ?? root["Retry-After"];
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw > 1e12 ? raw : now + Math.max(0, raw) * 1e3;
+  }
+  if (typeof raw === "string") {
+    const seconds = Number(raw.trim());
+    if (Number.isFinite(seconds)) return now + Math.max(0, seconds) * 1e3;
+    const date = Date.parse(raw);
+    if (Number.isFinite(date)) return date;
+  }
+  return void 0;
+}
+function readResetTimestamp(body, now) {
+  if (!body || typeof body !== "object") return void 0;
+  const root = body;
+  const error = root.error && typeof root.error === "object" ? root.error : root;
+  if (Array.isArray(error.details)) {
+    for (const item of error.details) {
+      if (!item || typeof item !== "object") continue;
+      const retryDelay = item.retryDelay;
+      if (typeof retryDelay === "string") {
+        const ms = parseResetsInMs(retryDelay);
+        if (typeof ms === "number" && Number.isFinite(ms)) return now + ms;
+      }
+    }
+  }
+  const details = !Array.isArray(error.details) && error.details && typeof error.details === "object" ? error.details : void 0;
+  const raw = error.resets_at ?? error.resetsAt ?? details?.resets_at ?? details?.resetsAt;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw > 1e12 ? raw : raw * 1e3;
+  }
+  if (typeof raw === "string") {
+    const parsed = Date.parse(raw);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function parseResetAtText(value, now) {
+  const m = value.match(
+    /resets?\s+at\s+(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?)/i
+  );
+  if (!m?.[1]) return void 0;
+  const parsed = Date.parse(m[1]);
+  return Number.isFinite(parsed) && parsed > now ? parsed : void 0;
+}
+function resolveNextAvailableAt(body, now, headers) {
+  const headerRetryAfter = headers && typeof headers.get === "function" ? headers.get("retry-after") : headers?.["retry-after"] ?? headers?.["Retry-After"];
+  const retryAfter = headerRetryAfter ? readRetryAfterTimestamp({ retryAfter: headerRetryAfter }, now) : readRetryAfterTimestamp(body, now);
+  if (retryAfter !== void 0 && retryAfter > now) {
+    return clampCooldownDeadline(retryAfter, now);
+  }
+  const absolute = readResetTimestamp(body, now);
+  if (absolute !== void 0 && absolute > now) {
+    return clampCooldownDeadline(absolute, now);
+  }
+  const text = typeof body === "string" ? body : JSON.stringify(body ?? "");
+  const parsed = parseResetAtText(text, now) ?? now + (parseResetsInMs(text) ?? DEFAULT_PROVIDER_RETRY_MS);
+  return clampCooldownDeadline(parsed, now);
+}
+function resolveAvailabilityAction(status, body, now, headers) {
+  if (status >= 200 && status < 300) return { kind: "clear" };
+  if (status === 429) {
+    return { kind: "mark", nextAvailableAt: resolveNextAvailableAt(body, now, headers) };
+  }
+  if (status >= 500) {
+    return { kind: "mark", nextAvailableAt: now + DEFAULT_PROVIDER_RETRY_MS };
+  }
+  return { kind: "noop" };
+}
+function mergeAvailabilityDeadline(currentDeadline, nextAvailableAt) {
+  return typeof currentDeadline === "number" && Number.isFinite(currentDeadline) ? Math.max(currentDeadline, nextAvailableAt) : nextAvailableAt;
+}
+var PROBE_INTERVAL_MS = 10 * 60 * 1e3;
+function resolveCooldownGate(input, now) {
+  const nextAvailableAt = input.nextAvailableAt;
+  if (typeof nextAvailableAt !== "number" || !Number.isFinite(nextAvailableAt) || nextAvailableAt <= now) {
+    return "open";
+  }
+  const lastProbeAt = input.lastProbeAt;
+  if (typeof lastProbeAt !== "number" || !Number.isFinite(lastProbeAt)) {
+    return "probe";
+  }
+  return now - lastProbeAt >= PROBE_INTERVAL_MS ? "probe" : "blocked";
+}
+
+export {
+  QUOTA_ERROR_PATTERNS,
+  isQuotaExhaustedError,
+  isAgentUnavailableNow,
+  resolveAvailabilityAction,
+  mergeAvailabilityDeadline,
+  resolveCooldownGate
+};