@tokenbuddy/tokenbuddy 1.0.29 → 1.0.31

package/tests/tokenbuddy.test.ts

@@ -27,7 +27,11 @@ import {
   previewProviderInstall,
   rollbackProviderInstall
 } from "../src/provider-install.js";
-import { detectTerminals } from "../src/terminal-detect.js";
+import {
+  detectTerminals,
+  rewriteHermes,
+  rewriteOpenclaw,
+} from "../src/terminal-detect.js";
 import {
   buildInitSuccessMessage,
   buildInitTerminalSelectionState,
@@ -1915,7 +1919,7 @@ describe("TokenBuddy JSON inspection commands", () => {
       expect.objectContaining({
         id: "gpt-4",
         sellerCount: 1,
-        discountRange: "0.25",
+        discountRange: "2.5折",
         priceRange: "in $1 / out $3"
       })
     ]);
@@ -1938,7 +1942,7 @@ describe("TokenBuddy JSON inspection commands", () => {
     expect(joined).toContain("Discount Range");
     expect(joined).toContain("Price Range");
     expect(joined).toContain("gpt-4");
-    expect(joined).toContain("0.25");
+    expect(joined).toContain("2.5折");
     expect(joined).toContain("$1");
     expect(joined).toContain("$3");
   });
@@ -1975,7 +1979,22 @@ describe("Provider install planning", () => {
     process.env.PATH = `${PROVIDER_BIN_ROOT}${path.delimiter}${previousPath || ""}`;
     fs.writeFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "approval_policy = \"never\"\n", "utf8");
     fs.writeFileSync(path.join(PROVIDER_HOME, ".claude", "settings.json"), JSON.stringify({ theme: "dark" }, null, 2), "utf8");
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), JSON.stringify({ keep: "field" }, null, 2), "utf8");
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), JSON.stringify({
+      keep: "field",
+      models: {
+        providers: {
+          existing: {
+            baseUrl: "https://example.invalid/v1",
+            models: [{ id: "existing-model", name: "existing-model" }],
+          },
+        },
+      },
+      agents: {
+        defaults: {
+          model: "existing/existing-model",
+        },
+      },
+    }, null, 2), "utf8");
     fs.writeFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), JSON.stringify({ share: "disabled" }, null, 2), "utf8");
   });
 
@@ -1996,7 +2015,7 @@ describe("Provider install planning", () => {
     expect(providers).toEqual(expect.arrayContaining([
       expect.objectContaining({ id: "codex", status: "configured", configured: true }),
       expect.objectContaining({ id: "claude-code", status: "configured", configured: true }),
-      expect.objectContaining({ id: "openclaw", status: "configured", configured: true }),
+      expect.objectContaining({ id: "openclaw", status: "installed", configured: false }),
       expect.objectContaining({ id: "hermes", status: "installed", configured: false })
     ]));
 
@@ -2043,10 +2062,10 @@ describe("Provider install planning", () => {
   });
 
   test("reports installed-only providers when executable or native config hints exist", () => {
-    fs.rmSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), { force: true });
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), JSON.stringify({ profile: "default" }, null, 2), "utf8");
+    fs.rmSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), { force: true });
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), JSON.stringify({ profile: "default" }, null, 2), "utf8");
     fs.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
-    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), "model: gpt-4\n", "utf8");
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"), JSON.stringify({ openai: { model: "gpt-4" } }, null, 2), "utf8");
 
     const providers = detectProviders({ home: PROVIDER_HOME });
     expect(providers).toEqual(expect.arrayContaining([
@@ -2055,14 +2074,14 @@ describe("Provider install planning", () => {
         status: "installed",
         configured: false,
         executablePath: expect.stringContaining(path.join("provider-bin", "openclaw")),
-        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".openclaw", "openclaw.json")]),
+        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".openclaw", "config.json")]),
       }),
       expect.objectContaining({
         id: "hermes",
         status: "installed",
         configured: false,
         executablePath: expect.stringContaining(path.join("provider-bin", "hermes")),
-        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".hermes", "config.yaml")]),
+        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".hermes", "settings.json")]),
       }),
     ]));
   });
@@ -2153,9 +2172,15 @@ describe("Provider install planning", () => {
       expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
       expect(store.getProviderRuntimeConfig("opencode")?.config).not.toHaveProperty("sellerId");
 
-      const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), "utf8"));
+      const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), "utf8"));
       expect(openclaw.keep).toBe("field");
-      expect(openclaw.api_url).toBe(proxyUrl);
+      expect(openclaw.models.providers.existing.baseUrl).toBe("https://example.invalid/v1");
+      expect(openclaw.models.providers.tokenbuddy.baseUrl).toBe(`${proxyUrl}/v1`);
+      expect(openclaw.models.providers.tokenbuddy.apiKey).toBe("TOKENBUDDY_PROXY");
+      expect(openclaw.models.providers.tokenbuddy.models).toEqual(expect.arrayContaining([
+        expect.objectContaining({ id: "gpt-4", name: "gpt-4", api: "openai-completions" }),
+      ]));
+      expect(openclaw.agents.defaults.model).toBe("tokenbuddy/gpt-4");
       const opencode = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"));
       expect(opencode.share).toBe("disabled");
       expect(JSON.stringify(opencode)).not.toContain("sellerId");
@@ -2168,7 +2193,13 @@ describe("Provider install planning", () => {
           configured: true,
         }),
       ]));
-      expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(true);
+      const hermesConfig = fs.readFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), "utf8");
+      expect(hermesConfig).toContain("model:");
+      expect(hermesConfig).toContain("default: gpt-4");
+      expect(hermesConfig).toContain("provider: custom");
+      expect(hermesConfig).toContain(`base_url: "${proxyUrl}/v1"`);
+      expect(hermesConfig).toContain("api_key: TOKENBUDDY_PROXY");
+      expect(hermesConfig).toContain("api_mode: chat_completions");
       expect(store.getProviderInstallSnapshot("codex")).toBeDefined();
 
       const rolledBack = rollbackProviderInstall({
@@ -2181,9 +2212,16 @@ describe("Provider install planning", () => {
         expect.objectContaining({ providerId: "hermes", action: "removed" })
       ]));
       expect(fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8")).toBe("approval_policy = \"never\"\n");
-      expect(JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), "utf8"))).toEqual({ keep: "field" });
+      expect(JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "openclaw.json"), "utf8"))).toMatchObject({
+        keep: "field",
+        agents: {
+          defaults: {
+            model: "existing/existing-model",
+          },
+        },
+      });
       expect(JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"))).toEqual({ share: "disabled" });
-      expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(false);
+      expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"))).toBe(false);
       expect(store.getProviderInstallSnapshot("codex")).toBeUndefined();
       expect(store.getProviderRuntimeConfig("claude-code")).toBeUndefined();
     } finally {
@@ -2211,6 +2249,97 @@ describe("Provider install planning", () => {
     expect(parsed.model).toBe("tokenbuddy/gpt-5.4");
     expect(parsed.provider.tokenbuddy.options.baseURL).toBe("http://127.0.0.1:17821/v1");
   });
+
+  test("hermes install preserves existing config and writes active config.yaml model section", () => {
+    fs.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), [
+      "display:",
+      "  compact: false",
+      "model:",
+      "  default: existing-model",
+      "  provider: existing-provider",
+      "  base_url: https://existing.invalid/v1",
+      "fallback_providers: []",
+      "",
+    ].join("\n"), "utf8");
+
+    const changes = previewProviderInstall({
+      providers: ["hermes"],
+      proxyUrl,
+      providerSelections: {
+        hermes: {
+          selectionKind: "single-model",
+          protocolPreference: "chat_completions",
+          defaultModel: "gpt-5.4",
+        },
+      },
+      home: PROVIDER_HOME,
+    });
+
+    const parsed = changes.find((change) => change.providerId === "hermes")?.content || "";
+    expect(parsed).toContain("display:");
+    expect(parsed).toContain("compact: false");
+    expect(parsed).toContain("fallback_providers:");
+    expect(parsed).toContain("default: gpt-5.4");
+    expect(parsed).toContain("provider: custom");
+    expect(parsed).toContain(`base_url: "${proxyUrl}/v1"`);
+    expect(parsed).toContain("api_key: TOKENBUDDY_PROXY");
+    expect(parsed).toContain("api_mode: chat_completions");
+  });
+
+  test("legacy terminal rewrite helpers use active OpenClaw and Hermes config files", () => {
+    const helperHome = path.join(PROVIDER_HOME, "terminal-helper-home");
+    const openclawPath = path.join(helperHome, ".openclaw", "openclaw.json");
+    const hermesPath = path.join(helperHome, ".hermes", "config.yaml");
+    fs.mkdirSync(path.dirname(openclawPath), { recursive: true });
+    fs.mkdirSync(path.dirname(hermesPath), { recursive: true });
+    fs.writeFileSync(openclawPath, JSON.stringify({
+      models: {
+        providers: {
+          existing: {
+            baseUrl: "https://example.invalid/v1",
+            models: [{ id: "existing-model", name: "existing-model" }],
+          },
+        },
+      },
+      agents: {
+        defaults: {
+          model: "existing/existing-model",
+        },
+      },
+    }, null, 2), "utf8");
+    fs.writeFileSync(hermesPath, [
+      "display:",
+      "  compact: false",
+      "model:",
+      "  default: existing-model",
+      "  provider: existing-provider",
+      "fallback_providers: []",
+      "",
+    ].join("\n"), "utf8");
+
+    rewriteOpenclaw(openclawPath, proxyUrl, "gpt-5.4");
+    rewriteHermes(hermesPath, proxyUrl, "gpt-5.4");
+
+    const openclaw = JSON.parse(fs.readFileSync(openclawPath, "utf8"));
+    expect(openclaw.models.providers.existing.baseUrl).toBe("https://example.invalid/v1");
+    expect(openclaw.models.providers.tokenbuddy.baseUrl).toBe(`${proxyUrl}/v1`);
+    expect(openclaw.models.providers.tokenbuddy.apiKey).toBe("TOKENBUDDY_PROXY");
+    expect(openclaw.models.providers.tokenbuddy.models).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: "gpt-5.4", name: "gpt-5.4", api: "openai-completions" }),
+    ]));
+    expect(openclaw.agents.defaults.model).toBe("tokenbuddy/gpt-5.4");
+
+    const hermes = fs.readFileSync(hermesPath, "utf8");
+    expect(hermes).toContain("display:");
+    expect(hermes).toContain("compact: false");
+    expect(hermes).toContain("fallback_providers:");
+    expect(hermes).toContain("default: gpt-5.4");
+    expect(hermes).toContain("provider: custom");
+    expect(hermes).toContain(`base_url: "${proxyUrl}/v1"`);
+    expect(hermes).toContain("api_key: TOKENBUDDY_PROXY");
+    expect(hermes).toContain("api_mode: chat_completions");
+  });
 });
 
 describe("TokenBuddy CLI and Daemon Integration Tests", () => {
@@ -2987,14 +3116,18 @@ describe("TokenBuddy seller routing strategies", () => {
   let daemon: TokenbuddyDaemon;
   let daemonProxyPort: number;
   let daemonControlPort: number;
-  const events: Array<{ seller: string; url?: string }> = [];
+  const events: Array<{ seller: string; url?: string; body?: any; idempotencyKey?: string }> = [];
   let primaryPurchaseSucceeds = false;
   let primaryInferenceFails = false;
+  let primaryInferenceFailsOnceWithIdempotencyConflict = false;
+  const primaryInferenceSeenRequestIds = new Set<string>();
   let primaryInferenceBusy = false;
   let primaryInferenceDelayMs = 0;
   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");
+    .filter((event) => event.url !== "/primary/health" && event.url !== "/backup/health")
+    .filter((event) => event.url !== "/primary/manifest" && event.url !== "/backup/manifest")
+    .map((event) => ({ seller: event.seller, url: event.url }));
 
   const readJsonBody = (req: http.IncomingMessage): Promise<any> => new Promise((resolve) => {
     let body = "";
@@ -3018,7 +3151,7 @@ describe("TokenBuddy seller routing strategies", () => {
               id: "primary-seller",
               name: "Primary Seller",
               url: `http://127.0.0.1:${sellerPort}/primary`,
-              supportedProtocols: ["chat_completions"],
+              supportedProtocols: ["chat_completions", "responses"],
               paymentMethods: ["mock"],
               models: ["gpt-manual"]
             },
@@ -3026,7 +3159,7 @@ describe("TokenBuddy seller routing strategies", () => {
               id: "backup-seller",
               name: "Backup Seller",
               url: `http://127.0.0.1:${sellerPort}/backup`,
-              supportedProtocols: ["chat_completions"],
+              supportedProtocols: ["chat_completions", "responses"],
               paymentMethods: ["mock"],
               models: ["gpt-manual"]
             }
@@ -3039,8 +3172,9 @@ describe("TokenBuddy seller routing strategies", () => {
         events.push({ seller: "primary-seller", url: req.url });
         res.end(JSON.stringify({
           sellerId: "primary-seller",
-          supportedProtocols: ["chat_completions"],
+          supportedProtocols: ["chat_completions", "responses"],
           paymentMethods: ["mock"],
+          selection: { discountRatio: 1 },
           models: [{ id: "gpt-manual" }]
         }));
         return;
@@ -3050,8 +3184,9 @@ describe("TokenBuddy seller routing strategies", () => {
         events.push({ seller: "backup-seller", url: req.url });
         res.end(JSON.stringify({
           sellerId: "backup-seller",
-          supportedProtocols: ["chat_completions"],
+          supportedProtocols: ["chat_completions", "responses"],
           paymentMethods: ["mock"],
+          selection: { discountRatio: 0.01 },
           models: [{ id: "gpt-manual" }]
         }));
         return;
@@ -3089,8 +3224,13 @@ describe("TokenBuddy seller routing strategies", () => {
         return;
       }
 
-      if (req.url === "/primary/v1/chat/completions") {
-        events.push({ seller: "primary-seller", url: req.url });
+      if (req.url === "/primary/v1/chat/completions" || req.url === "/primary/v1/responses") {
+        events.push({
+          seller: "primary-seller",
+          url: req.url,
+          body,
+          idempotencyKey: req.headers["idempotency-key"] as string | undefined
+        });
         if (primaryInferenceDelayMs > 0) {
           await new Promise((resolve) => setTimeout(resolve, primaryInferenceDelayMs));
         }
@@ -3104,10 +3244,35 @@ describe("TokenBuddy seller routing strategies", () => {
           res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed" } }));
           return;
         }
-        res.end(JSON.stringify({
-          id: "primary-chat",
-          usage: { prompt_tokens: 4, completion_tokens: 5 }
-        }));
+        if (primaryInferenceFailsOnceWithIdempotencyConflict) {
+          if (primaryInferenceSeenRequestIds.has(body.requestId)) {
+            res.statusCode = 409;
+            res.end(JSON.stringify({
+              error: {
+                code: "idempotency_conflict",
+                message: "Idempotency key already belongs to an existing request."
+              }
+            }));
+            return;
+          }
+          primaryInferenceSeenRequestIds.add(body.requestId);
+          if (primaryInferenceSeenRequestIds.size === 1) {
+            res.statusCode = 502;
+            res.end(JSON.stringify({ error: { code: "upstream_failed", message: "primary seller failed once" } }));
+            return;
+          }
+        }
+        if (req.url === "/primary/v1/responses") {
+          res.end(JSON.stringify({
+            id: "primary-response",
+            usage: { input_tokens: 4, output_tokens: 5 }
+          }));
+        } else {
+          res.end(JSON.stringify({
+            id: "primary-chat",
+            usage: { prompt_tokens: 4, completion_tokens: 5 }
+          }));
+        }
         return;
       }
 
@@ -3137,12 +3302,19 @@ describe("TokenBuddy seller routing strategies", () => {
         return;
       }
 
-      if (req.url === "/backup/v1/chat/completions") {
+      if (req.url === "/backup/v1/chat/completions" || req.url === "/backup/v1/responses") {
         events.push({ seller: "backup-seller", url: req.url });
-        res.end(JSON.stringify({
-          id: "backup-chat",
-          usage: { prompt_tokens: 4, completion_tokens: 5 }
-        }));
+        if (req.url === "/backup/v1/responses") {
+          res.end(JSON.stringify({
+            id: "backup-response",
+            usage: { input_tokens: 4, output_tokens: 5 }
+          }));
+        } else {
+          res.end(JSON.stringify({
+            id: "backup-chat",
+            usage: { prompt_tokens: 4, completion_tokens: 5 }
+          }));
+        }
         return;
       }
 
@@ -3170,6 +3342,8 @@ describe("TokenBuddy seller routing strategies", () => {
     events.length = 0;
     primaryPurchaseSucceeds = false;
     primaryInferenceFails = false;
+    primaryInferenceFailsOnceWithIdempotencyConflict = false;
+    primaryInferenceSeenRequestIds.clear();
     primaryInferenceBusy = false;
     primaryInferenceDelayMs = 0;
     rmSqliteFiles(dbPath);
@@ -3371,7 +3545,6 @@ describe("TokenBuddy seller routing strategies", () => {
     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" }
@@ -3380,6 +3553,23 @@ describe("TokenBuddy seller routing strategies", () => {
     expect(prewarmAfterRequest.scheduler.totalScheduled).toBeGreaterThan(scheduledBeforeRequest);
   });
 
+  test("routing preview uses seller manifest discount metadata", async () => {
+    const response = await fetch(
+      `http://127.0.0.1:${daemonControlPort}/routing/preview?modelId=gpt-manual&protocol=chat_completions&paymentMethod=mock&mode=fullAuto&scorer=discount`
+    );
+
+    expect(response.ok).toBe(true);
+    const preview = await response.json() as any;
+    expect(preview.plan.reason).toBe("fullAuto:discount:routes_2");
+    expect(preview.plan.routes.map((route: any) => route.seller.id)).toEqual(["backup-seller", "primary-seller"]);
+    expect(preview.plan.routes[0].metrics.discountRatio).toBe(0.01);
+    expect(preview.plan.routes[1].metrics.discountRatio).toBe(1);
+    expect(events).toEqual(expect.arrayContaining([
+      { seller: "primary-seller", url: "/primary/manifest" },
+      { seller: "backup-seller", url: "/backup/manifest" }
+    ]));
+  });
+
   test("fixedSet routing only uses sellers in the configured pool", async () => {
     daemon.stop();
     events.length = 0;
@@ -3434,7 +3624,7 @@ describe("TokenBuddy seller routing strategies", () => {
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
       sellerRouting: {
         mode: "fullAuto",
-        scorer: "balanced"
+        scorer: "speed"
       }
     });
     daemon.start();
@@ -3481,7 +3671,7 @@ describe("TokenBuddy seller routing strategies", () => {
     expect(requestLogs).toContain("event=route.candidates.prewarmed");
     expect(requestLogs).toContain("event=route.selected");
     expect(requestLogs).toContain("routePlanSource=registry_fallback");
-    expect(requestLogs).toContain("routePlanReason=fullAuto:balanced:routes_2");
+    expect(requestLogs).toContain("routePlanReason=fullAuto:speed:routes_2");
     expect(requestLogs).toContain("candidateDiagnostics=");
     expect(requestLogs).toContain("hasNextRoute=true");
     expect(requestLogs).toContain("attemptNumber=");
@@ -3493,6 +3683,124 @@ describe("TokenBuddy seller routing strategies", () => {
     expect(logs).not.toContain(rawPrompt);
   });
 
+  test("soft failure retry uses a fresh seller attempt id after upstream failure", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = true;
+    primaryInferenceFailsOnceWithIdempotencyConflict = true;
+    const requestId = "auto_retry_fresh_seller_attempt_id";
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fixed",
+        sellerId: "primary-seller",
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Idempotency-Key": "idem-fresh-seller-attempt"
+      },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        messages: [{ role: "user", content: "retry should not reuse seller request id" }],
+        requestId
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect((await response.json() as any).id).toBe("primary-chat");
+    const primaryInferenceCalls = events.filter((event) => event.url === "/primary/v1/chat/completions");
+    expect(primaryInferenceCalls).toHaveLength(2);
+    expect(primaryInferenceCalls.map((event) => event.body?.requestId)).toEqual([
+      requestId,
+      `${requestId}_r0_a1_n0`
+    ]);
+    expect(primaryInferenceCalls.map((event) => event.idempotencyKey)).toEqual([
+      "idem-fresh-seller-attempt",
+      "idem-fresh-seller-attempt_r0_a1_n0"
+    ]);
+
+    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
+    expect(inferences.inferences).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        requestId,
+        sellerKey: "primary-seller",
+        endpoint: "/v1/chat/completions",
+        status: "estimated"
+      })
+    ]));
+    expect(JSON.stringify(inferences)).not.toContain(`${requestId}_r0_a1_n0`);
+  });
+
+  test("responses retry uses a fresh seller attempt id after upstream failure", async () => {
+    daemon.stop();
+    events.length = 0;
+    primaryPurchaseSucceeds = true;
+    primaryInferenceFailsOnceWithIdempotencyConflict = true;
+    const requestId = "responses_retry_fresh_seller_attempt_id";
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      sellerRouting: {
+        mode: "fixed",
+        sellerId: "primary-seller",
+        scorer: "balanced"
+      }
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/responses`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Idempotency-Key": "idem-responses-fresh-seller-attempt"
+      },
+      body: JSON.stringify({
+        model: "gpt-manual",
+        input: "retry should not reuse seller request id",
+        requestId
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect((await response.json() as any).id).toBe("primary-response");
+    const primaryInferenceCalls = events.filter((event) => event.url === "/primary/v1/responses");
+    expect(primaryInferenceCalls).toHaveLength(2);
+    expect(primaryInferenceCalls.map((event) => event.body?.requestId)).toEqual([
+      requestId,
+      `${requestId}_r0_a1_n0`
+    ]);
+    expect(primaryInferenceCalls.map((event) => event.idempotencyKey)).toEqual([
+      "idem-responses-fresh-seller-attempt",
+      "idem-responses-fresh-seller-attempt_r0_a1_n0"
+    ]);
+
+    const inferences = await (await fetch(`http://127.0.0.1:${daemonControlPort}/ledger/inferences`)).json() as any;
+    expect(inferences.inferences).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        requestId,
+        sellerKey: "primary-seller",
+        endpoint: "/v1/responses",
+        status: "estimated"
+      })
+    ]));
+    expect(JSON.stringify(inferences)).not.toContain(`${requestId}_r0_a1_n0`);
+  });
+
   test("fullAuto routing treats busy_capacity as a capacity block and starts the next request on backup", async () => {
     daemon.stop();
     events.length = 0;
@@ -3505,7 +3813,7 @@ describe("TokenBuddy seller routing strategies", () => {
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
       sellerRouting: {
         mode: "fullAuto",
-        scorer: "balanced"
+        scorer: "speed"
       }
     });
     daemon.start();
@@ -3561,7 +3869,7 @@ describe("TokenBuddy seller routing strategies", () => {
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
       sellerRouting: {
         mode: "fullAuto",
-        scorer: "balanced"
+        scorer: "speed"
       },
       sellerConcurrency: {
         enabled: true,
@@ -3666,7 +3974,7 @@ describe("TokenBuddy seller routing strategies", () => {
       sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
       sellerRouting: {
         mode: "fullAuto",
-        scorer: "balanced"
+        scorer: "speed"
       }
     });
     daemon.start();