@cortexkit/opencode-openai-auth 1.0.4 → 1.1.0

package/src/tui-compiled/raw/shared/abd062d633e29fd2-pool-routing.js

@@ -0,0 +1,192 @@
+import { projectQuota } from "./d5a8f1061ee2f114-index.js";
+import {
+  admit,
+  decideStickyBreak,
+  orderForPlacement,
+  routeOrdered,
+  routeSticky
+} from "./3e7d45a77c6ad4d5-index.js";
+import {
+  isKillswitchEnabled,
+  killswitchPassesPolicy
+} from "./dbc61cd405941828-accounts.js";
+import { windowsFromQuotaMap } from "./bfbdd0f9aae56b47-pool-quota.js";
+export const FORMER_MAIN_ID = "main";
+export function vaultMainRouteId(routes) {
+  return routes.find((route) => route.id.startsWith("vault:") && route.credentialId === "chatgpt:openai")?.id ?? null;
+}
+export function poolKillswitchVerdicts(accounts, storage, now) {
+  const verdicts = new Map;
+  if (isKillswitchEnabled(storage))
+    for (const account of accounts)
+      verdicts.set(account.id, killswitchPassesPolicy(windowsFromQuotaMap(account.quota), storage, account.id === FORMER_MAIN_ID ? void 0 : account.id, now));
+  return verdicts;
+}
+export const POOL_QUOTA_UNKNOWN_RETRY_SECONDS = 5, FIRST_QUOTA_READING_WAIT_MS = 5000;
+export function orderedPlacement(mode) {
+  if (mode === "ordered")
+    return "roster";
+  return mode === "fallback-first" ? "fallback-first" : "main-first";
+}
+export function waitForFirstQuotaReading(input, waitMs = FIRST_QUOTA_READING_WAIT_MS) {
+  const rows = input.rows.filter((row) => row.kind === "oauth" && input.killswitch.get(row.id) !== !1 && projectQuota(row.quota).limits.length === 0);
+  if (rows.length === 0)
+    return;
+  if (admit({
+    rows: input.rows,
+    now: input.now,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    requestPull: () => {}
+  }).admitted.some((row) => input.killswitch.get(row.id) !== !1))
+    return;
+  const pulls = [];
+  admit({
+    rows,
+    now: input.now,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    requestPull: (id) => {
+      const pending = input.requestPull(id);
+      if (pending)
+        pulls.push(pending.catch(() => {}));
+    }
+  });
+  if (pulls.length === 0)
+    return;
+  let timer;
+  return Promise.race([
+    Promise.all(pulls),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, waitMs);
+    })
+  ]).then(() => {}).finally(() => clearTimeout(timer));
+}
+function isConfirmedExhaustion(refusal) {
+  return refusal.reason === "exhausted" || refusal.reason === "budget-spent";
+}
+export function blockFor(id, admission, killswitch) {
+  if (id === void 0)
+    return { reason: "no-credential" };
+  if (killswitch.get(id) === !1)
+    return { reason: "killswitch" };
+  const exclusion = admission.excluded.find((entry) => entry.id === id);
+  if (exclusion?.reason === "rate-limited")
+    return { reason: "mid-stream-rate-limit", resetAtMs: exclusion.until };
+  if (exclusion)
+    return { reason: "no-credential" };
+  const refusal = admission.refused.find((entry) => entry.id === id);
+  if (refusal && "resetAtMs" in refusal)
+    return { reason: "quota-exhausted", resetAtMs: refusal.resetAtMs };
+  if (refusal)
+    return { reason: "quota-unknown" };
+  return { reason: "no-credential" };
+}
+function routeBlock(ids, admission, killswitch) {
+  if (admission.refused.find((refusal) => !isConfirmedExhaustion(refusal) && killswitch.get(refusal.id) !== !1))
+    return { reason: "quota-unknown" };
+  return blockFor(ids[0], admission, killswitch);
+}
+export function planOrdered(input) {
+  const replayable = input.replayable !== !1, mainId = input.mainId === void 0 ? FORMER_MAIN_ID : input.mainId ?? "", placement = replayable ? input.placement : "main-first", route = routeOrdered({
+    rows: input.rows,
+    placement,
+    formerMainId: mainId,
+    killswitch: input.killswitch,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    now: input.now,
+    requestPull: input.requestPull
+  }), ids = orderForPlacement(input.rows.map((row) => row.id), placement, mainId), confirmed = new Set(route.admission.refused.filter((refusal) => isConfirmedExhaustion(refusal) && input.killswitch.get(refusal.id) !== !1).map((refusal) => refusal.id)), lastPath = ids.filter((id) => confirmed.has(id));
+  if (!replayable) {
+    const hasMain = ids.includes(mainId), target = hasMain ? mainId : route.order[0] ?? lastPath[0];
+    if (target !== void 0 && route.order.includes(target))
+      return { kind: "send", order: [target], lastPath: !1 };
+    if (target !== void 0 && confirmed.has(target))
+      return { kind: "send", order: [target], lastPath: !0 };
+    return {
+      kind: "block",
+      block: hasMain ? blockFor(mainId, route.admission, input.killswitch) : routeBlock(ids, route.admission, input.killswitch)
+    };
+  }
+  if (route.order.length > 0)
+    return { kind: "send", order: route.order, lastPath: !1 };
+  if (lastPath.length > 0)
+    return { kind: "send", order: lastPath, lastPath: !0 };
+  return {
+    kind: "block",
+    block: routeBlock(ids, route.admission, input.killswitch)
+  };
+}
+export function admitSticky(input) {
+  const admission = admit({
+    rows: input.rows,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    now: input.now,
+    requestPull: input.requestPull
+  }), projections = new Map;
+  for (const row of input.rows)
+    projections.set(row.id, projectQuota(row.quota));
+  for (const row of admission.admitted)
+    if (row.projection)
+      projections.set(row.id, row.projection);
+  return {
+    projections,
+    excluded: new Set(admission.excluded.map((entry) => entry.id))
+  };
+}
+function routePoolSticky(input, options, extra) {
+  const exclude = extra.exclude, rows = exclude ? input.rows.filter((row) => !exclude.has(row.id)) : input.rows, resetCredits = new Map;
+  for (const row of rows) {
+    const credits = options.resetCredits(row.id);
+    if (credits !== void 0)
+      resetCredits.set(row.id, credits);
+  }
+  return routeSticky({
+    rows,
+    now: input.now,
+    rateLimitMarks: input.rateLimitMarks,
+    refreshBackoff: input.refreshBackoff,
+    requestPull: input.requestPull,
+    killswitch: input.killswitch,
+    requestBytes: options.requestBytes,
+    ...extra.pendingBytes ? { pendingBytes: extra.pendingBytes } : {},
+    rowReservePercent: (row) => options.reservePercent(row.id),
+    refusedPinPolicy: "move-on-confirmed-exhaustion",
+    resetCreditsApplicable: resetCredits,
+    ...extra.pin === void 0 ? {} : { pin: { accountId: extra.pin } },
+    ...options.onEmptyWeightedSet ? { onEmptyWeightedSet: options.onEmptyWeightedSet } : {}
+  });
+}
+export function selectStickyRow(input, options, exclude, pendingBytes) {
+  const route = routePoolSticky(input, options, { exclude, pendingBytes });
+  if (route.outcome !== "dispatch" || route.source === "pin")
+    return;
+  return {
+    accountId: route.accountId,
+    source: route.source,
+    ...route.quotaCheckedAt === void 0 ? {} : { quotaCheckedAt: route.quotaCheckedAt }
+  };
+}
+export function routePinnedRow(input, options, id) {
+  const killed = input.killswitch.get(id) === !1, route = routePoolSticky(input, options, { pin: id });
+  if (route.outcome === "dispatch") {
+    if (route.pin.action === "assign")
+      return { kind: "move", reason: killed ? "killswitch" : "exhausted" };
+    return route.accountId === id ? { kind: "serve" } : { kind: "detour" };
+  }
+  const refusal = route.admission.refused.find((entry) => entry.id === id);
+  if (!killed && refusal && isConfirmedExhaustion(refusal))
+    return { kind: "last-path" };
+  return { kind: "none" };
+}
+export function stickyBreak(input, sticky, id, status) {
+  const killswitchPasses = input.killswitch.get(id);
+  return decideStickyBreak({
+    quota: sticky.projections.get(id),
+    now: input.now,
+    ...status === void 0 ? {} : { status },
+    ...killswitchPasses === void 0 ? {} : { killswitchPasses }
+  });
+}