@a-t-h-i/bot-lobby 0.6.18 → 0.6.19

package/webui/dist/index.html

@@ -13,8 +13,8 @@
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
     <title>bot-lobby</title>
     <meta property="csp-nonce" nonce="__CSP_NONCE__">
-    <script type="module" crossorigin src="/assets/index-CHLNxlA1.js" nonce="__CSP_NONCE__"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-m9XcQvH8.css" nonce="__CSP_NONCE__">
+    <script type="module" crossorigin src="/assets/index-BJI9lE5R.js" nonce="__CSP_NONCE__"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Dg0tvkeY.css" nonce="__CSP_NONCE__">
   </head>
   <body>
     <div id="root"></div>

package/src/execution/fallback.ts

@@ -1,75 +0,0 @@
-/**
- * Fallback models. A subscription or key that runs out mid-task (a usage
- * limit, a rate limit, no credit, the provider down or refusing the key)
- * fails every run on that model the same way, so the run goes to the agent's
- * configured fallback model instead, and the exhausted model is skipped for a
- * while so the next agents do not each spend a failed run finding out.
- */
-
-/** What a provider says when a model cannot be used right now. Deliberately narrow: an ordinary failure is not a reason to switch model. */
-const UNAVAILABLE = [
-  /usage limit/i, /rate.?limit/i, /\bquota\b/i, /limit (?:reached|exceeded|will reset)/i, /exceeded (?:your|the|current)/i,
-  /out of (?:usage|credits?|extra usage|tokens)/i, /(?:insufficient|no) (?:credits?|funds|balance|quota)/i, /credit balance/i,
-  /billing/i, /payment required/i, /\b402\b/, /\b429\b/, /too many requests/i, /resource.?exhausted/i,
-  /overloaded/i, /\b529\b/, /(?:at|over) capacity/i, /resets? (?:at|in|on)/i, /subscription/i,
-  /unauthori[sz]ed/i, /\b401\b/, /invalid (?:api )?key/i, /no api key/i, /authentication (?:failed|error)/i,
-  /model (?:is )?(?:not found|not available|unavailable)/i, /unknown model/i, /does not have access/i,
-];
-
-/** True when a failed run's error says its model is out of usage or unavailable, so another model may succeed. */
-export function looksUnavailable(error: string | undefined): boolean {
-  return Boolean(error && UNAVAILABLE.some((pattern) => pattern.test(error)));
-}
-
-/** How long a model that ran out is skipped before it is tried again. */
-export const COOLDOWN_MS = 20 * 60 * 1000;
-
-const exhausted = new Map<string, number>();
-
-/** Remember that `model` cannot be used until the cooldown passes. */
-export function markUnavailable(model: string, now = Date.now()): void {
-  exhausted.set(model, now + COOLDOWN_MS);
-}
-
-/** Whether `model` ran out recently enough to skip. */
-export function isUnavailable(model: string | undefined, now = Date.now()): boolean {
-  if (!model) return false;
-  const until = exhausted.get(model);
-  if (until === undefined) return false;
-  if (until <= now) {
-    exhausted.delete(model);
-    return false;
-  }
-  return true;
-}
-
-/** Forget every exhausted model (tests). */
-export function resetUnavailable(): void {
-  exhausted.clear();
-}
-
-/** A fallback worth switching to: a model other than the one that failed. */
-export function usableFallback<F extends { model: string }>(fallback: F | undefined, current: string | undefined): F | undefined {
-  return fallback && fallback.model !== current ? fallback : undefined;
-}
-
-/**
- * Run `attempt` on `model`; when it fails because that model is out of usage
- * or unavailable, run it again on the fallback. A model already known to be
- * out goes straight to the fallback. `switched` says which model took over.
- */
-export async function withFallback<T extends { status: string; error?: string }>(
-  model: string | undefined,
-  thinking: string,
-  fallback: { model: string; thinking: string } | undefined,
-  attempt: (model: string | undefined, thinking: string) => Promise<T>,
-): Promise<{ result: T; switchedFrom?: string }> {
-  const other = usableFallback(fallback, model);
-  if (other && isUnavailable(model)) return { result: await attempt(other.model, other.thinking), switchedFrom: model ?? "the session model" };
-  const result = await attempt(model, thinking);
-  if (other && result.status === "failed" && looksUnavailable(result.error)) {
-    if (model) markUnavailable(model);
-    return { result: await attempt(other.model, other.thinking), switchedFrom: model ?? "the session model" };
-  }
-  return { result };
-}

package/src/pi/master-fallback.ts

@@ -1,61 +0,0 @@
-/**
- * The master runs in your own Pi session, on the session's model. When that
- * model runs out of usage mid-task (a subscription limit, no credit) the turn
- * ends with an error and the task would stall. With a fallback model set for
- * the master, the session switches to it and the oracle carries on.
- */
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { looksUnavailable, markUnavailable } from "../execution/fallback.ts";
-import { fallbackOf } from "../schemas/configuration.ts";
-import { loadConfig } from "../state/project.ts";
-import { modelRef } from "./model-support.ts";
-import { modelLookup } from "./tools.ts";
-import { isSubagentProcess } from "./quiet.ts";
-
-/** The provider's error when the last thing in the turn was a failed assistant message that says the model is out of usage or unavailable. */
-export function usageFailure(messages: readonly unknown[]): string | undefined {
-  const last = messages.at(-1) as { role?: string; stopReason?: string; errorMessage?: string } | undefined;
-  if (last?.role !== "assistant" || last.stopReason !== "error") return undefined;
-  return looksUnavailable(last.errorMessage) ? last.errorMessage : undefined;
-}
-
-/** What the oracle is told after the switch. */
-export function switchedMessage(from: string, to: string): string {
-  return `bot-lobby: your last turn failed because ${from} is out of usage or unavailable, so this session switched to ${to}. Carry on with the task from where you left off; do not repeat work that is already done.`;
-}
-
-export function registerMasterFallback(pi: ExtensionAPI): void {
-  if (isSubagentProcess()) return;
-  let failure: string | undefined;
-  pi.on("agent_end", (event) => {
-    failure = usageFailure(event.messages);
-  });
-  pi.on("agent_settled", async (_event, ctx: ExtensionContext) => {
-    if (!failure) return;
-    failure = undefined;
-    await switchMaster(pi, ctx);
-  });
-}
-
-async function switchMaster(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
-  const fallback = fallbackOf(loadConfig().master);
-  if (!fallback) return;
-  const current = ctx.model ? modelRef(ctx.model) : "the session model";
-  if (current === fallback.model) {
-    ctx.ui.notify(`bot-lobby: ${current} (the master's fallback) is out of usage too — pick another model or wait.`, "warning");
-    return;
-  }
-  const model = modelLookup(ctx)(fallback.model);
-  if (!model) {
-    ctx.ui.notify(`bot-lobby: the master's fallback model "${fallback.model}" is not known to Pi.`, "warning");
-    return;
-  }
-  if (!(await pi.setModel(model))) {
-    ctx.ui.notify(`bot-lobby: no auth for the master's fallback model ${fallback.model}.`, "warning");
-    return;
-  }
-  pi.setThinkingLevel(fallback.thinking as Parameters<ExtensionAPI["setThinkingLevel"]>[0]);
-  if (ctx.model) markUnavailable(current);
-  ctx.ui.notify(`bot-lobby: ${current} ran out of usage; the master now runs on ${fallback.model} (${fallback.thinking}). Switch back with /model when it is available again.`, "warning");
-  await pi.sendUserMessage(switchedMessage(current, fallback.model));
-}