@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

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

@@ -1,124 +0,0 @@
-import {
-  assertSellerRoutingConfig,
-  defaultSellerRoutingConfig,
-  mergeSellerRoutingConfig,
-  normalizeSellerRoutingConfig,
-  parseSellerIdList,
-  parseSellerRoutingEnv
-} from "../src/seller-routing-config.js";
-
-describe("seller routing config", () => {
-  test("defaults to fullAuto balanced routing", () => {
-    expect(defaultSellerRoutingConfig()).toEqual({
-      mode: "fullAuto",
-      scorer: "balanced"
-    });
-  });
-
-  test("normalizes fixed and fixedSet configs", () => {
-    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"
-    });
-
-    expect(normalizeSellerRoutingConfig({
-      mode: "fixedSet",
-      sellerIds: ["tbs-1", " ", "tbs-2", "tbs-1"],
-      scorer: "discount"
-    })).toEqual({
-      mode: "fixedSet",
-      sellerIds: ["tbs-1", "tbs-2"],
-      scorer: "discount"
-    });
-  });
-
-  test("does not accept legacy auto/manual modes", () => {
-    expect(() => normalizeSellerRoutingConfig({ mode: "auto" })).toThrow("seller routing mode");
-    expect(() => parseSellerRoutingEnv({ TB_PROXYD_ROUTING_MODE: "manual" })).toThrow("seller routing mode");
-  });
-
-  test("rejects invalid routing scorer values", () => {
-    expect(() => normalizeSellerRoutingConfig({ mode: "fullAuto", scorer: "fast" })).toThrow("seller routing scorer");
-    expect(() => parseSellerRoutingEnv({ TB_PROXYD_ROUTING_SCORER: "random" })).toThrow("seller routing scorer");
-  });
-
-  test("parses only the new routing environment variables", () => {
-    expect(parseSellerRoutingEnv({
-      TB_PROXYD_ROUTING_MODE: "fixedSet",
-      TB_PROXYD_ROUTING_SELLER_IDS: "tbs-1,tbs-2,tbs-1",
-      TB_PROXYD_ROUTING_SCORER: "speed"
-    })).toEqual({
-      mode: "fixedSet",
-      sellerIds: ["tbs-1", "tbs-2"],
-      scorer: "speed"
-    });
-
-    expect(parseSellerRoutingEnv({
-      TB_PROXYD_SELECTION_MODE: "manual",
-      TB_PROXYD_SELECTED_SELLER_ID: "old-seller"
-    })).toBeUndefined();
-  });
-
-  test("infers routing mode from individual environment variables", () => {
-    expect(parseSellerRoutingEnv({
-      TB_PROXYD_ROUTING_SELLER_ID: "tbs-1"
-    })).toEqual({
-      mode: "fixed",
-      sellerId: "tbs-1",
-      scorer: "balanced"
-    });
-
-    expect(parseSellerRoutingEnv({
-      TB_PROXYD_ROUTING_SELLER_IDS: "tbs-1,tbs-2"
-    })).toEqual({
-      mode: "fixedSet",
-      sellerIds: ["tbs-1", "tbs-2"],
-      scorer: "balanced"
-    });
-
-    expect(parseSellerRoutingEnv({
-      TB_PROXYD_ROUTING_SCORER: "discount"
-    })).toEqual({
-      mode: "fullAuto",
-      scorer: "discount"
-    });
-  });
-
-  test("merges explicit overrides over stored config", () => {
-    expect(mergeSellerRoutingConfig(
-      { mode: "fullAuto", scorer: "balanced" },
-      { mode: "fixed", sellerId: "tbs-1", scorer: "discount" }
-    )).toEqual({
-      mode: "fixed",
-      sellerId: "tbs-1",
-      scorer: "discount"
-    });
-  });
-
-  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");
-  });
-
-  test("parses comma-separated seller id lists", () => {
-    expect(parseSellerIdList(" a, b,,a ")).toEqual(["a", "b"]);
-  });
-});

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

@@ -1,167 +0,0 @@
-import { planSellerRoutes, type RoutingCandidate, type SellerRoutingStrategyConfig } from "../src/seller-routing-strategy.js";
-
-function candidate(overrides: Partial<RoutingCandidate> & { sellerId: string; registryOrder: number }): RoutingCandidate {
-  return {
-    sellerId: overrides.sellerId,
-    url: overrides.url ?? `https://${overrides.sellerId}.example.com`,
-    supportsModel: overrides.supportsModel ?? true,
-    supportsProtocol: overrides.supportsProtocol ?? true,
-    supportsPayment: overrides.supportsPayment ?? true,
-    healthScore: overrides.healthScore,
-    avgLatencyMs: overrides.avgLatencyMs,
-    healthProbeLatencyMs: overrides.healthProbeLatencyMs,
-    ttftMs: overrides.ttftMs,
-    avgInferenceMs: overrides.avgInferenceMs,
-    avgTokensPerSecond: overrides.avgTokensPerSecond,
-    discountRatio: overrides.discountRatio,
-    registryOrder: overrides.registryOrder
-  };
-}
-
-function planIds(candidates: RoutingCandidate[], config: SellerRoutingStrategyConfig): string[] {
-  return planSellerRoutes(candidates, config).routes.map((route) => route.sellerId);
-}
-
-describe("seller routing strategy", () => {
-  test("fixed mode returns only the configured seller", () => {
-    const result = planSellerRoutes(
-      [
-        candidate({ sellerId: "s1", registryOrder: 0, healthScore: 40 }),
-        candidate({ sellerId: "s2", registryOrder: 1, healthScore: 99 })
-      ],
-      { mode: "fixed", sellerId: "s1", scorer: "speed" }
-    );
-
-    expect(result.routes.map((route) => route.sellerId)).toEqual(["s1"]);
-    expect(result.reason).toBe("fixed:speed:routes_1");
-  });
-
-  test("fixed mode matches seller ids case-insensitively", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "TBS-1", registryOrder: 0 }),
-        candidate({ sellerId: "tbs-2", registryOrder: 1 })
-      ],
-      { mode: "fixed", sellerId: "tbs-1" }
-    );
-
-    expect(ids).toEqual(["TBS-1"]);
-  });
-
-  test("fixed mode fails closed when the configured seller is not compatible", () => {
-    const result = planSellerRoutes(
-      [
-        candidate({ sellerId: "s1", registryOrder: 0, supportsPayment: false }),
-        candidate({ sellerId: "s2", registryOrder: 1 })
-      ],
-      { mode: "fixed", sellerId: "s1" }
-    );
-
-    expect(result.routes).toEqual([]);
-    expect(result.reason).toBe("fixed_seller_not_compatible");
-  });
-
-  test("fixed mode requires a seller id", () => {
-    const result = planSellerRoutes([candidate({ sellerId: "s1", registryOrder: 0 })], { mode: "fixed" });
-
-    expect(result.routes).toEqual([]);
-    expect(result.reason).toBe("fixed_seller_missing");
-  });
-
-  test("fixedSet mode never selects sellers outside the configured pool", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "outside-fast", registryOrder: 0, healthScore: 100 }),
-        candidate({ sellerId: "pool-a", registryOrder: 1, healthScore: 30 }),
-        candidate({ sellerId: "pool-b", registryOrder: 2, healthScore: 70 })
-      ],
-      { mode: "fixedSet", sellerIds: ["pool-a", "pool-b"], scorer: "speed" }
-    );
-
-    expect(ids).toEqual(["pool-b", "pool-a"]);
-  });
-
-  test("fixedSet mode matches seller pools case-insensitively", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "TBS-A", registryOrder: 0, healthScore: 30 }),
-        candidate({ sellerId: "tbs-B", registryOrder: 1, healthScore: 70 })
-      ],
-      { mode: "fixedSet", sellerIds: ["TBS-A", "TBS-B"], scorer: "balanced" }
-    );
-
-    expect(ids).toEqual(["tbs-B", "TBS-A"]);
-  });
-
-  test("fixedSet mode reports empty pool before routing", () => {
-    const result = planSellerRoutes([candidate({ sellerId: "s1", registryOrder: 0 })], { mode: "fixedSet", sellerIds: [] });
-
-    expect(result.routes).toEqual([]);
-    expect(result.reason).toBe("fixed_set_empty");
-  });
-
-  test("fullAuto mode uses all compatible candidates", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "s1", registryOrder: 0 }),
-        candidate({ sellerId: "s2", registryOrder: 1, supportsProtocol: false }),
-        candidate({ sellerId: "s3", registryOrder: 2 })
-      ],
-      { mode: "fullAuto" }
-    );
-
-    expect(ids).toEqual(["s1", "s3"]);
-  });
-
-  test("speed scorer uses TTFT and ten-minute Tok/s, then health", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "high-slow", registryOrder: 0, healthScore: 90, ttftMs: 800, avgInferenceMs: 10, avgTokensPerSecond: 1 }),
-        candidate({ sellerId: "high-fast", registryOrder: 1, healthScore: 90, ttftMs: 100, avgInferenceMs: 1000, avgTokensPerSecond: 80 }),
-        candidate({ sellerId: "low-fast", registryOrder: 2, healthScore: 40, ttftMs: 10, avgInferenceMs: 1000, avgTokensPerSecond: 20 })
-      ],
-      { mode: "fullAuto", scorer: "speed" }
-    );
-
-    expect(ids).toEqual(["high-fast", "low-fast", "high-slow"]);
-  });
-
-  test("discount scorer prefers lower discount ratio, then health", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "expensive", registryOrder: 0, discountRatio: 1, healthScore: 100 }),
-        candidate({ sellerId: "cheap-low-health", registryOrder: 1, discountRatio: 0.01, healthScore: 20 }),
-        candidate({ sellerId: "cheap-high-health", registryOrder: 2, discountRatio: 0.01, healthScore: 90 })
-      ],
-      { mode: "fullAuto", scorer: "discount" }
-    );
-
-    expect(ids).toEqual(["cheap-high-health", "cheap-low-health", "expensive"]);
-  });
-
-  test("balanced scorer combines health, latency, and discount", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "healthy-expensive", registryOrder: 0, healthScore: 90, avgLatencyMs: 100, discountRatio: 1 }),
-        candidate({ sellerId: "balanced", registryOrder: 1, healthScore: 80, avgLatencyMs: 100, discountRatio: 0.01 }),
-        candidate({ sellerId: "cheap-unhealthy", registryOrder: 2, healthScore: 20, avgLatencyMs: 100, discountRatio: 0.01 })
-      ],
-      { mode: "fullAuto", scorer: "balanced" }
-    );
-
-    expect(ids).toEqual(["balanced", "cheap-unhealthy", "healthy-expensive"]);
-  });
-
-  test("registry order is the stable tie breaker", () => {
-    const ids = planIds(
-      [
-        candidate({ sellerId: "s2", registryOrder: 2, healthScore: 80, avgLatencyMs: 100, discountRatio: 0.5 }),
-        candidate({ sellerId: "s0", registryOrder: 0, healthScore: 80, avgLatencyMs: 100, discountRatio: 0.5 }),
-        candidate({ sellerId: "s1", registryOrder: 1, healthScore: 80, avgLatencyMs: 100, discountRatio: 0.5 })
-      ],
-      { mode: "fullAuto", scorer: "balanced" }
-    );
-
-    expect(ids).toEqual(["s0", "s1", "s2"]);
-  });
-});

package/tests/stream-failover.test.ts

@@ -1,52 +0,0 @@
-import { STREAM_FAILOVER_RETRY_HINT, StreamFailover } from "../src/stream-failover.js";
-
-describe("StreamFailover", () => {
-  test("fresh state reports no chunks committed", () => {
-    const sf = new StreamFailover();
-    expect(sf.snapshot()).toEqual({ firstChunkCommitted: false, bytesFlushed: 0 });
-  });
-
-  test("markFirstChunkCommitted transitions once and only once", () => {
-    const sf = new StreamFailover();
-    sf.markFirstChunkCommitted();
-    sf.markFirstChunkCommitted();
-    expect(sf.snapshot().firstChunkCommitted).toBe(true);
-  });
-
-  test("recordBytesWritten accumulates flushed bytes", () => {
-    const sf = new StreamFailover();
-    sf.recordBytesWritten(128);
-    sf.recordBytesWritten(64);
-    expect(sf.snapshot().bytesFlushed).toBe(192);
-  });
-
-  test("decideOnStreamAbort before first chunk defers to the controller", () => {
-    const sf = new StreamFailover();
-    const decision = sf.decideOnStreamAbort("upstream_reset");
-    expect(decision.action).toBe("let_stream_complete");
-    expect(decision.retryHintValue).toBe("0");
-  });
-
-  test("decideOnStreamAbort after first chunk aborts and surfaces retry hint", () => {
-    const sf = new StreamFailover();
-    sf.markFirstChunkCommitted();
-    sf.recordBytesWritten(2048);
-    const decision = sf.decideOnStreamAbort("upstream_reset");
-    expect(decision.action).toBe("abort_with_retry_hint");
-    expect(decision.retryHintValue).toBe(STREAM_FAILOVER_RETRY_HINT);
-    expect(decision.bytesFlushed).toBe(2048);
-  });
-
-  test("reset clears the chunk and byte counters", () => {
-    const sf = new StreamFailover();
-    sf.markFirstChunkCommitted();
-    sf.recordBytesWritten(999);
-    sf.reset();
-    expect(sf.snapshot()).toEqual({ firstChunkCommitted: false, bytesFlushed: 0 });
-  });
-
-  test("default header name is X-TokenBuddy-Retry-Hint and is overridable", () => {
-    expect(new StreamFailover().headerName).toBe("X-TokenBuddy-Retry-Hint");
-    expect(new StreamFailover({ retryHintHeader: "X-Custom-Retry" }).headerName).toBe("X-Custom-Retry");
-  });
-});

package/tests/thousand-seller.test.ts

@@ -1,151 +0,0 @@
-import { ModelIndex } from "../src/model-index.js";
-import { PrewarmCache, prewarmKey } from "../src/prewarm-cache.js";
-import { CreditTracker } from "../src/credit-tracker.js";
-import { SellerPool } from "../src/seller-pool.js";
-import { RouteFailover } from "../src/route-failover.js";
-import { PrewarmScheduler, type ProbeResult, type SellerProber } from "../src/prewarm-scheduler.js";
-import type { RegistrySeller } from "../src/seller-catalog.js";
-
-/**
- * v1.2 §18.15: "thousand-seller" integration smoke. Validates the
- * end-to-end pipeline at a scale that simulates a real public registry:
- *   - the model-index build stays cheap (sub-100ms for 1k sellers)
- *   - the prewarm scheduler respects its per-minute and per-seller caps
- *   - the route-failover controller still returns a clean decision when
- *     a single seller among a thousand fails
- *
- * The test does not exercise live HTTP traffic; it uses stub probers and
- * pre-populated registries so it can run as a fast unit test on every
- * change.
- */
-describe("v1.2 thousand-seller integration smoke", () => {
-  function buildLargeRegistry(size: number, focusModel: string): RegistrySeller[] {
-    const sellers: RegistrySeller[] = [];
-    for (let i = 0; i < size; i += 1) {
-      sellers.push({
-        id: `seller-${i.toString().padStart(4, "0")}`,
-        name: `Seller ${i}`,
-        url: `https://seller-${i}.example.com`,
-        supportedProtocols: ["chat_completions"],
-        paymentMethods: ["clawtip"],
-        // ~1/3 of the sellers serve BOTH models, 2/3 serve only
-        // `focusModel`. This simulates a realistic registry mix.
-        models: i % 3 === 0 ? [focusModel, "secondary-model"] : [focusModel]
-      });
-    }
-    return sellers;
-  }
-
-  test("model-index builds in well under a second for 1000 sellers", () => {
-    const index = new ModelIndex();
-    const sellers = buildLargeRegistry(1000, "gpt-4o");
-    const started = Date.now();
-    index.rebuild(sellers, { registryVersion: 1, defaultSellerId: "seller-0000" });
-    const elapsed = Date.now() - started;
-    expect(elapsed).toBeLessThan(500);
-    expect(index.stats().sellerCount).toBe(1000);
-    expect(index.stats().modelCount).toBe(2);
-  });
-
-  test("picking the focus model returns the configured candidate set", () => {
-    const index = new ModelIndex();
-    index.rebuild(buildLargeRegistry(1000, "gpt-4o"), { registryVersion: 1 });
-    const candidates = index.sellersFor("gpt-4o", { protocol: "chat_completions", paymentMethod: "clawtip" });
-    // Every seller in the registry serves `gpt-4o` (either alone or
-    // alongside `secondary-model`), so all 1000 are eligible.
-    expect(candidates.length).toBe(1000);
-  });
-
-  test("prewarm scheduler enforces the global per-minute cap across many tasks", async () => {
-    const index = new ModelIndex();
-    const sellers = buildLargeRegistry(50, "gpt-4o");
-    index.rebuild(sellers, { registryVersion: 1 });
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-
-    // Prober resolves immediately. The scheduler should still cap the
-    // number of actual probe calls per minute.
-    const prober: SellerProber = async (): Promise<ProbeResult> => ({ ok: true, latencyMs: 1, httpStatus: 200 });
-    const scheduler = new PrewarmScheduler({
-      modelIndex: index,
-      cache,
-      prober,
-      // Lower the caps so the test runs in a few ms.
-      maxPrewarmPerMinute: 5,
-      concurrency: 1,
-      sleep: () => new Promise(() => undefined)
-    });
-
-    // Enqueue three independent (model, protocol, payment) tasks; only
-    // `gpt-4o` and `gpt-4o` slots exist so the third (and beyond) will
-    // be rate-limited after 2 actual probe invocations.
-    const tasks = await Promise.all([
-      scheduler.schedulePrewarm({ modelId: "gpt-4o", reason: "lazy" }),
-      scheduler.schedulePrewarm({ modelId: "gpt-4o", reason: "lazy" }),
-      scheduler.schedulePrewarm({ modelId: "gpt-4o", reason: "lazy" })
-    ]);
-    const succeeded = tasks.filter((t) => t.status === "succeeded").length;
-    const rateLimited = tasks.filter((t) => t.status === "rate_limited").length;
-    expect(succeeded).toBeGreaterThan(0);
-    expect(rateLimited + succeeded).toBe(3);
-    expect(scheduler.stats().totalRateLimited).toBe(rateLimited);
-  });
-
-  test("seller-pool + route-failover pipeline still produces a clean decision under a thousand sellers", () => {
-    const index = new ModelIndex();
-    index.rebuild(buildLargeRegistry(1000, "gpt-4o"), { registryVersion: 1 });
-    const cache = new PrewarmCache();
-    const credit = new CreditTracker();
-    const pool = new SellerPool({ modelIndex: index, cache, creditTracker: credit });
-    pool.sync();
-    const failover = new RouteFailover({ pool, creditTracker: credit });
-    // 1k sellers all serve gpt-4o. Pick the top-4 by health (all
-    // default to 80 healthScore from the stub commit) and verify
-    // that a hard 4xx on the first one fails over to the next three
-    // without ever exhausting the pool.
-    const eligible = index.sellersFor("gpt-4o", { protocol: "chat_completions", paymentMethod: "clawtip" });
-    const subset = eligible.slice(0, 100);
-    cache.commitWarm({
-      modelId: "gpt-4o",
-      protocol: "chat_completions",
-      paymentMethod: "clawtip",
-      candidates: subset.map((seller) => ({ sellerId: seller.id, url: seller.url, healthScore: 80 }))
-    });
-    pool.sync();
-    // pool size matches the deduped seller count in the cache (each
-    // seller appears exactly once even if listed by multiple registry
-    // entries).
-    expect(pool.size()).toBe(subset.length);
-    const first = failover.pickNext("gpt-4o", "chat_completions", "clawtip");
-    expect(first).toBeDefined();
-    credit.recordPurchase(first!.sellerId, 1_000_000, 1_000_000);
-    const decision = failover.decide(
-      { sellerId: first!.sellerId, status: 404, errorKind: "hard_4xx", attempt: 0 },
-      100
-    );
-    expect(decision.action).toBe("failover_next");
-    expect(decision.wastedCreditMicros).toBeGreaterThan(0);
-  });
-
-  test("prewarm-key collisions are impossible across the (model, protocol, payment) space", () => {
-    // Even with 1000 sellers, the (model, protocol, payment) key must
-    // be unique. We assert the count of unique keys equals the count of
-    // committed entries.
-    const cache = new PrewarmCache();
-    for (let i = 0; i < 1000; i += 1) {
-      const protocol = i % 2 === 0 ? "chat_completions" : "responses";
-      const payment = i % 3 === 0 ? "clawtip" : "mock";
-      cache.commitWarm({
-        modelId: `m-${i}`,
-        protocol,
-        paymentMethod: payment,
-        candidates: [{ sellerId: `s-${i}`, url: "https://x", healthScore: 80 }]
-      });
-    }
-    const keys = new Set<string>();
-    for (const entry of cache.snapshot()) {
-      keys.add(prewarmKey(entry.modelId, entry.protocol, entry.paymentMethod));
-    }
-    expect(keys.size).toBe(1000);
-  });
-});