@tokenbuddy/tokenbuddy 1.0.13 → 1.0.15

package/tests/seller-catalog-utilities.test.ts

@@ -1,5 +1,6 @@
 import {
   dedupeCatalogEntries,
+  discoverSellerBackedModels,
   filterCatalogByProtocol,
   filterCatalogBySeller,
   manifestModelIds,
@@ -67,4 +68,57 @@ describe("seller catalog utilities", () => {
 
     expect(manifestModelIds(manifest)).toEqual(["gpt-5.4", "claude"]);
   });
+
+  test("discovers models from active buyer-visible registry sellers only", async () => {
+    const fetchMock = jest.spyOn(globalThis, "fetch").mockImplementation(async (url) => {
+      const href = String(url);
+      if (href.endsWith("/registry/sellers")) {
+        return jsonResponse({
+          version: 8,
+          sellers: [
+            {
+              id: "active",
+              status: "active",
+              url: "https://active.example.com",
+              supportedProtocols: ["chat_completions"],
+              paymentMethods: ["clawtip"]
+            },
+            {
+              id: "pending",
+              status: "pending",
+              url: "https://pending.example.com",
+              supportedProtocols: ["chat_completions"],
+              paymentMethods: ["clawtip"]
+            }
+          ]
+        });
+      }
+      if (href === "https://active.example.com/manifest") {
+        return jsonResponse({
+          sellerId: "active",
+          supportedProtocols: ["chat_completions"],
+          paymentMethods: ["clawtip"],
+          models: [{ id: "gpt-5.4" }]
+        });
+      }
+      throw new Error(`unexpected fetch ${href}`);
+    });
+
+    try {
+      const catalog = await discoverSellerBackedModels("https://bootstrap.example.com/registry/sellers");
+
+      expect(catalog.sellers.map((seller) => seller.id)).toEqual(["active"]);
+      expect(catalog.models.map((model) => model.sellerId)).toEqual(["active"]);
+      expect(fetchMock).not.toHaveBeenCalledWith("https://pending.example.com/manifest");
+    } finally {
+      fetchMock.mockRestore();
+    }
+  });
 });
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}

package/tests/seller-pool.test.ts

@@ -132,6 +132,62 @@ describe("SellerPool", () => {
     expect(pool.snapshot()[0].circuit).toBe("open");
   });
 
+  test("busy_capacity temporarily blocks selection without opening the circuit", () => {
+    const clock = makeClock();
+    const ctx = build([{ id: "s1", healthScore: 90 }, { id: "s2", healthScore: 50 }]);
+    const pool = new SellerPool({
+      modelIndex: ctx.index,
+      cache: ctx.cache,
+      creditTracker: ctx.credit,
+      failureThreshold: 1,
+      capacityBlockMs: 1000,
+      now: () => clock.now
+    });
+    pool.sync();
+
+    const blocked = pool.recordFailure("s1", "busy_capacity");
+    expect(blocked?.circuit).toBe("closed");
+    expect(blocked?.consecutiveFailures).toBe(0);
+    expect(blocked?.recentFailures).toEqual([]);
+    expect(blocked?.capacityBlockedUntil).toBe(clock.now + 1000);
+
+    let result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
+    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s2"]);
+
+    clock.advance(1001);
+    result = pool.pick({ modelId: "gpt-4o", protocol: "chat_completions", paymentMethod: "clawtip" });
+    expect(result.candidates.map((c) => c.entry.sellerId)).toEqual(["s1", "s2"]);
+
+    pool.recordFailure("s1", "busy_capacity");
+    pool.recordSuccess("s1", 250_000);
+    expect(pool.snapshot().find((entry) => entry.sellerId === "s1")?.capacityBlockedUntil).toBeUndefined();
+  });
+
+  test("sync preserves registry fallback runtime state for sellers still in the registry", () => {
+    const clock = makeClock();
+    const index = new ModelIndex();
+    const sellers = [makeSeller({ id: "s1", models: ["gpt-4o"] })];
+    index.rebuild(sellers, { registryVersion: 1 });
+    const cache = new PrewarmCache();
+    const credit = new CreditTracker();
+    const pool = new SellerPool({
+      modelIndex: index,
+      cache,
+      creditTracker: credit,
+      capacityBlockMs: 1000,
+      now: () => clock.now
+    });
+
+    pool.ensureRegistrySellers(sellers);
+    pool.recordFailure("s1", "busy_capacity");
+    pool.sync();
+
+    expect(pool.snapshot()[0].capacityBlockedUntil).toBe(clock.now + 1000);
+    index.rebuild([], { registryVersion: 2 });
+    pool.sync();
+    expect(pool.snapshot()).toEqual([]);
+  });
+
   test("recordSuccess closes the circuit and reports to the credit tracker", () => {
     const clock = makeClock();
     const ctx = build([{ id: "s1" }]);

package/tests/seller-route-planner.test.ts

@@ -5,6 +5,7 @@ function seller(overrides: Partial<RegistrySeller> & { id: string; models?: stri
   return {
     id: overrides.id,
     name: overrides.name ?? overrides.id,
+    status: overrides.status,
     url: overrides.url ?? `https://${overrides.id}.example.com`,
     supportedProtocols: overrides.supportedProtocols ?? ["chat_completions"],
     paymentMethods: overrides.paymentMethods ?? ["clawtip"],
@@ -80,6 +81,20 @@ describe("seller route planner", () => {
     expect(result.reason).toBe("fullAuto:balanced:routes_1");
   });
 
+  test("only active registry sellers are visible to buyer routing", () => {
+    const result = plan({
+      registrySellers: [
+        seller({ id: "legacy-no-status" }),
+        seller({ id: "active", status: "active" }),
+        seller({ id: "pending", status: "pending" }),
+        seller({ id: "draining", status: "draining" }),
+        seller({ id: "offline", status: "offline" })
+      ]
+    });
+
+    expect(result.routes.map((route) => route.seller.id)).toEqual(["legacy-no-status", "active"]);
+  });
+
   test("fixed mode fails closed when selected seller is outside compatibility", () => {
     const result = plan({
       routing: { mode: "fixed", sellerId: "s3", scorer: "speed" }
@@ -147,4 +162,29 @@ describe("seller route planner", () => {
 
     expect(result.routes.map((route) => route.seller.id)).toEqual(["s2"]);
   });
+
+  test("active capacity blocks are excluded before strategy selection", () => {
+    const now = 10_000;
+    const blocked = plan({
+      now,
+      routing: { mode: "fullAuto", scorer: "speed" },
+      sellerMetrics: [
+        { sellerId: "s1", healthScore: 100, avgLatencyMs: 10, capacityBlockedUntil: now + 1000 },
+        { sellerId: "s2", healthScore: 20, avgLatencyMs: 100 }
+      ]
+    });
+
+    expect(blocked.routes.map((route) => route.seller.id)).toEqual(["s2"]);
+
+    const expired = plan({
+      now: now + 1001,
+      routing: { mode: "fullAuto", scorer: "speed" },
+      sellerMetrics: [
+        { sellerId: "s1", healthScore: 100, avgLatencyMs: 10, capacityBlockedUntil: now + 1000 },
+        { sellerId: "s2", healthScore: 20, avgLatencyMs: 100 }
+      ]
+    });
+
+    expect(expired.routes.map((route) => route.seller.id)).toEqual(["s1", "s2"]);
+  });
 });

package/tests/seller-routing-config.test.ts

@@ -19,10 +19,18 @@ describe("seller routing config", () => {
     expect(normalizeSellerRoutingConfig({
       mode: "fixed",
       sellerId: " tbs-1 ",
+      fixedByModel: {
+        " gpt-4o ": " tbs-2 ",
+        empty: "",
+        ignored: 42
+      },
       scorer: "speed"
     })).toEqual({
       mode: "fixed",
       sellerId: "tbs-1",
+      fixedByModel: {
+        "gpt-4o": "tbs-2"
+      },
       scorer: "speed"
     });
 
@@ -102,6 +110,11 @@ describe("seller routing config", () => {
 
   test("validates required fixed strategy parameters", () => {
     expect(() => assertSellerRoutingConfig({ mode: "fixed", scorer: "balanced" })).toThrow("--seller");
+    expect(() => assertSellerRoutingConfig({
+      mode: "fixed",
+      scorer: "balanced",
+      fixedByModel: { "gpt-4o": "tbs-1" }
+    })).not.toThrow();
     expect(() => assertSellerRoutingConfig({ mode: "fixedSet", sellerIds: [], scorer: "balanced" })).toThrow("--seller-set");
   });
 

package/tests/tokenbuddy.test.ts

@@ -6,6 +6,7 @@ import {
   buildCli,
   fetchClawtipBootstrap,
   normalizeClawtipBootstrapResourceUrl,
+  restartLaunchAgent,
 } from "../src/cli.js";
 import {
   checkOpenClawRuntime,
@@ -71,7 +72,15 @@ describe("TokenBuddy CLI command surface", () => {
       .filter(command => command !== "help")
       .sort();
 
-    expect(commandNames).toEqual(["doctor", "init", "models", "payment", "routing"]);
+    expect(commandNames).toEqual(["daemon", "doctor", "init", "models", "payment", "routing", "ui"]);
+  });
+
+  test("tb daemon help exposes restart", () => {
+    const program = buildCli();
+    const daemon = program.commands.find(command => command.name() === "daemon");
+
+    expect(daemon).toBeDefined();
+    expect(daemon!.commands.map(command => command.name()).sort()).toEqual(["restart"]);
   });
 
   test("tb payment help only exposes list, add, and remove", () => {
@@ -151,6 +160,64 @@ describe("TokenBuddy CLI command surface", () => {
     expect(plist).not.toContain("payCredential");
     expect(plist).not.toContain("PAYMENT_PROOF");
   });
+
+  test("restartLaunchAgent kickstarts the installed LaunchAgent and waits for readiness", async () => {
+    const launchctlCalls: string[][] = [];
+    const result = await restartLaunchAgent(17820, {
+      platform: "darwin",
+      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
+      existsSync: () => true,
+      runLaunchctl: (args) => {
+        launchctlCalls.push(args);
+      },
+      probeDaemonStatus: async () => ({
+        running: true,
+        status: { pid: 100, controlPort: 17820, proxyPort: 17821 }
+      }),
+      waitForDaemonStatus: async () => ({
+        running: true,
+        status: { pid: 200, controlPort: 17820, proxyPort: 17821 }
+      })
+    });
+
+    expect(result).toMatchObject({
+      attempted: true,
+      restarted: true,
+      method: "launchd",
+      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
+      after: {
+        running: true,
+        status: { pid: 200 }
+      }
+    });
+    expect(launchctlCalls).toEqual([[
+      "kickstart",
+      "-k",
+      expect.stringMatching(/^gui\/\d+\/com\.tokenbuddy\.proxyd$/)
+    ]]);
+  });
+
+  test("restartLaunchAgent reports missing LaunchAgent plist without calling launchctl", async () => {
+    const launchctlCalls: string[][] = [];
+    const result = await restartLaunchAgent(17820, {
+      platform: "darwin",
+      plistPath: "/Users/example/Library/LaunchAgents/com.tokenbuddy.proxyd.plist",
+      existsSync: () => false,
+      runLaunchctl: (args) => {
+        launchctlCalls.push(args);
+      },
+      probeDaemonStatus: async () => ({ running: false, error: "offline" }),
+      waitForDaemonStatus: async () => ({ running: false, error: "not called" })
+    });
+
+    expect(result).toMatchObject({
+      attempted: false,
+      restarted: false,
+      method: "launchd",
+      error: expect.stringContaining("tb init")
+    });
+    expect(launchctlCalls).toEqual([]);
+  });
 });
 
 describe("BuyerStore safe SQLite persistence", () => {
@@ -2518,7 +2585,10 @@ describe("TokenBuddy seller routing strategies", () => {
   const events: Array<{ seller: string; url?: string }> = [];
   let primaryPurchaseSucceeds = false;
   let primaryInferenceFails = false;
+  let primaryInferenceBusy = false;
   const dbPath = path.resolve(__dirname, "../../data-test/manual-routing-test.db");
+  const routeEvents = (): Array<{ seller: string; url?: string }> => events
+    .filter((event) => event.url !== "/primary/health" && event.url !== "/backup/health");
 
   const readJsonBody = (req: http.IncomingMessage): Promise<any> => new Promise((resolve) => {
     let body = "";
@@ -2615,6 +2685,11 @@ describe("TokenBuddy seller routing strategies", () => {
 
       if (req.url === "/primary/v1/chat/completions") {
         events.push({ seller: "primary-seller", url: req.url });
+        if (primaryInferenceBusy) {
+          res.statusCode = 429;
+          res.end(JSON.stringify({ error: { code: "busy_capacity", message: "primary seller capacity is full" } }));
+          return;
+        }
         if (primaryInferenceFails) {
           res.statusCode = 500;
           res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed" } }));
@@ -2686,6 +2761,7 @@ describe("TokenBuddy seller routing strategies", () => {
     events.length = 0;
     primaryPurchaseSucceeds = false;
     primaryInferenceFails = false;
+    primaryInferenceBusy = false;
     rmSqliteFiles(dbPath);
     const store = new BuyerStore({ dbPath });
     store.savePayment({
@@ -2738,7 +2814,7 @@ describe("TokenBuddy seller routing strategies", () => {
     // v1.2: the buyer no longer fetches the seller manifest per request.
     // The registry's `models` field is the source of truth. Auto-purchase
     // is still attempted once before failing over.
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
       { seller: "primary-seller", url: "/primary/purchase/create" }
     ]);
 
@@ -2784,7 +2860,7 @@ describe("TokenBuddy seller routing strategies", () => {
     // v1.2: the buyer no longer fetches the seller manifest per request.
     // The backup-seller is selected via the fixed seller routing config; the manifest
     // is sourced from the registry's `models` field.
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
       { seller: "backup-seller", url: "/backup/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/complete" },
       { seller: "backup-seller", url: "/backup/v1/chat/completions" }
@@ -2826,11 +2902,72 @@ describe("TokenBuddy seller routing strategies", () => {
     });
 
     expect(response.ok).toBe(true);
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
+
+  test("daemon applies tb routing set fullAuto without restart", async () => {
+    daemon.stop();
+    events.length = 0;
+    const store = new BuyerStore({ dbPath });
+    store.saveDaemonRuntimeConfig("routing", {
+      mode: "fixed",
+      sellerId: "primary-seller",
+      scorer: "discount"
+    });
+    store.close();
+
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const initialStatus = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(initialStatus.sellerRoutingMode).toBe("fixed");
+    expect(initialStatus.sellerRoutingScorer).toBe("discount");
+    expect(initialStatus.selectedSellerId).toBe("primary-seller");
+
+    const refreshedStore = new BuyerStore({ dbPath });
+    refreshedStore.saveDaemonRuntimeConfig("routing", {
+      mode: "fullAuto",
+      scorer: "balanced"
+    });
+    refreshedStore.close();
+
+    const reloadedStatus = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(reloadedStatus.sellerRoutingMode).toBe("fullAuto");
+    expect(reloadedStatus.sellerRoutingScorer).toBe("balanced");
+    expect(reloadedStatus.selectedSellerId).toBeUndefined();
+    const prewarmBeforeRequest = await (await fetch(`http://127.0.0.1:${daemonControlPort}/v1.2/prewarm`)).json() as any;
+    const scheduledBeforeRequest = prewarmBeforeRequest.scheduler.totalScheduled;
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "fullAuto should reload without restart" }]
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect((await response.json() as any).id).toBe("backup-chat");
+    expect(routeEvents()).toEqual([
+      { seller: "primary-seller", url: "/primary/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/complete" },
       { seller: "backup-seller", url: "/backup/v1/chat/completions" }
     ]);
+    const prewarmAfterRequest = await (await fetch(`http://127.0.0.1:${daemonControlPort}/v1.2/prewarm`)).json() as any;
+    expect(prewarmAfterRequest.scheduler.totalScheduled).toBeGreaterThan(scheduledBeforeRequest);
   });
 
   test("fixedSet routing only uses sellers in the configured pool", async () => {
@@ -2866,7 +3003,7 @@ describe("TokenBuddy seller routing strategies", () => {
     });
 
     expect(response.ok).toBe(true);
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
       { seller: "backup-seller", url: "/backup/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/complete" },
       { seller: "backup-seller", url: "/backup/v1/chat/completions" }
@@ -2911,7 +3048,7 @@ describe("TokenBuddy seller routing strategies", () => {
 
     expect(response.ok).toBe(true);
     expect((await response.json() as any).id).toBe("backup-chat");
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
       { seller: "primary-seller", url: "/primary/purchase/create" },
       { seller: "primary-seller", url: "/primary/purchase/complete" },
       { seller: "primary-seller", url: "/primary/v1/chat/completions" },
@@ -2939,6 +3076,62 @@ describe("TokenBuddy seller routing strategies", () => {
     expect(logs).not.toContain(rawPrompt);
   });
 
+  test("fullAuto routing treats busy_capacity as a capacity block and starts the next request on backup", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = true;
+    primaryInferenceBusy = true;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fullAuto",
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const first = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "primary is at capacity" }]
+      })
+    });
+
+    expect(first.ok).toBe(true);
+    expect((await first.json() as any).id).toBe("backup-chat");
+    expect(routeEvents()).toEqual([
+      { seller: "primary-seller", url: "/primary/purchase/create" },
+      { seller: "primary-seller", url: "/primary/purchase/complete" },
+      { seller: "primary-seller", url: "/primary/v1/chat/completions" },
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+
+    events.length = 0;
+    const second = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "capacity block should still be active" }]
+      })
+    });
+
+    expect(second.ok).toBe(true);
+    expect((await second.json() as any).id).toBe("backup-chat");
+    expect(routeEvents()).toEqual([
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
+
   test("fullAuto routing logs purchase failure failover before trying the backup seller", async () => {
     daemon.stop();
     events.length = 0;
@@ -2970,7 +3163,7 @@ describe("TokenBuddy seller routing strategies", () => {
 
     expect(response.ok).toBe(true);
     expect((await response.json() as any).id).toBe("backup-chat");
-    expect(events).toEqual([
+    expect(routeEvents()).toEqual([
       { seller: "primary-seller", url: "/primary/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/create" },
       { seller: "backup-seller", url: "/backup/purchase/complete" },