@tokenbuddy/tokenbuddy 1.0.5 → 1.0.6

package/tests/tokenbuddy.test.ts

@@ -8,10 +8,21 @@ import {
   rollbackProviderInstall
 } from "../src/provider-install.js";
 import { detectTerminals } from "../src/terminal-detect.js";
+import {
+  buildInitSuccessMessage,
+  buildInitTerminalOptions,
+  detectExistingClawtipBinding,
+  INIT_COMING_SOON_PAYMENT_OPTIONS,
+  INIT_PAYMENT_OPTIONS,
+  noteInitComingSoonPayments,
+  OTHER_TERMINAL_OPTION,
+  validateInitTerminalSelection,
+} from "../src/init-payment-options.js";
 import * as path from "path";
 import * as fs from "fs";
 import http from "http";
 import { AddressInfo } from "net";
+import zlib from "zlib";
 
 const TEMP_BUYER_DB = path.resolve(__dirname, "../../data-test/buyer-cache-test.db");
 const TEMP_STORE_ROOT = path.resolve(__dirname, "../../data-test/buyer-store-test");
@@ -125,6 +136,47 @@ describe("BuyerStore safe SQLite persistence", () => {
     expect(store.listPendingPurchases()).toEqual([]);
     expect(store.listPurchaseLedger()).toEqual([]);
     expect(store.listInferenceLedger()).toEqual([]);
+    expect(store.summary()).toMatchObject({
+      providerRuntimeConfigCount: 0,
+      daemonRuntimeConfigCount: 0,
+    });
+  });
+
+  test("stores provider runtime config and daemon routing config in the buyer store", () => {
+    store.saveProviderRuntimeConfig("opencode", {
+      selectionKind: "single-model",
+      protocolPreference: "responses",
+      defaultModel: "gpt-5.5",
+      sellerId: "seller-a",
+    });
+    store.saveDaemonRuntimeConfig("routing", {
+      mode: "fixed",
+      sellerId: "seller-a",
+    });
+
+    expect(store.getProviderRuntimeConfig("opencode")).toMatchObject({
+      providerId: "opencode",
+      config: expect.objectContaining({
+        defaultModel: "gpt-5.5",
+        sellerId: "seller-a",
+      }),
+    });
+    expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
+      configKey: "routing",
+      config: expect.objectContaining({
+        mode: "fixed",
+        sellerId: "seller-a",
+      }),
+    });
+    expect(store.summary()).toMatchObject({
+      providerRuntimeConfigCount: 1,
+      daemonRuntimeConfigCount: 1,
+    });
+
+    expect(store.removeProviderRuntimeConfig("opencode")).toBe(true);
+    expect(store.removeDaemonRuntimeConfig("routing")).toBe(true);
+    expect(store.getProviderRuntimeConfig("opencode")).toBeUndefined();
+    expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
   });
 
   test("stores payment config and pending purchases with safe references", () => {
@@ -374,31 +426,201 @@ describe("TokenBuddy payment CLI", () => {
   });
 });
 
+describe("TokenBuddy init payment options", () => {
+  test("init hides mock payment and shows coming-soon agent wallets as unavailable", () => {
+    const noteMessages: string[] = [];
+    noteInitComingSoonPayments((message?: string) => {
+      noteMessages.push(String(message || ""));
+    });
+
+    expect(INIT_PAYMENT_OPTIONS).toEqual([
+      expect.objectContaining({ value: "clawtip" })
+    ]);
+    expect(INIT_PAYMENT_OPTIONS.map((option) => option.value)).not.toContain("mock");
+
+    const notes = noteMessages.join("\n");
+    expect(INIT_COMING_SOON_PAYMENT_OPTIONS).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: "wechat-pay", label: "WeChat Pay" }),
+      expect.objectContaining({ id: "alipay-agent-payment", label: "Alipay Agent Payment" }),
+      expect.objectContaining({ id: "coinbase-smart-wallet", label: "Coinbase Smart Wallet" })
+    ]));
+    expect(notes).toContain("WeChat Pay（接入中）");
+    expect(notes).toContain("Alipay Agent Payment（接入中）");
+    expect(notes).toContain("Coinbase Smart Wallet（接入中）");
+  });
+
+  test("detects an existing local clawtip binding from saved payment config", () => {
+    const binding = detectExistingClawtipBinding({
+      method: "clawtip",
+      enabled: false,
+      isDefault: false,
+      updatedAt: "2026-05-30T00:00:00.000Z",
+      config: {
+        orderNo: "order_123",
+        resourceUrl: "https://example.test/pay"
+      }
+    });
+
+    expect(binding).toEqual(expect.objectContaining({
+      orderNo: "order_123",
+      resourceUrl: "https://example.test/pay",
+      config: expect.objectContaining({
+        orderNo: "order_123",
+        resourceUrl: "https://example.test/pay"
+      })
+    }));
+  });
+
+  test("builds a clear init success message with summary lines", () => {
+    const message = buildInitSuccessMessage([
+      "2 programming terminals configured for TokenBuddy.",
+      "ClawTip wallet already bound locally; activation skipped."
+    ]);
+
+    expect(message).toContain("✅ TokenBuddy setup completed successfully.");
+    expect(message).toContain("- 2 programming terminals configured for TokenBuddy.");
+    expect(message).toContain("- ClawTip wallet already bound locally; activation skipped.");
+    expect(message).toContain("Run `tb doctor` to audit status anytime.");
+  });
+
+  test("builds terminal options with configured entries marked as already installed", () => {
+    const options = buildInitTerminalOptions([
+      {
+        id: "codex",
+        name: "Codex CLI",
+        detected: true,
+        configured: true,
+        status: "configured",
+        configPath: "/tmp/codex.toml",
+        reason: "Configured at ~/.codex/config.toml"
+      },
+      {
+        id: "hermes",
+        name: "Hermes Terminal",
+        detected: true,
+        configured: false,
+        status: "installed",
+        configPath: "/tmp/hermes.json",
+        reason: "Installed, TokenBuddy config missing"
+      }
+    ]);
+
+    expect(options).toEqual([
+      expect.objectContaining({
+        value: "codex:installed",
+        label: "Codex CLI（已安装）"
+      }),
+      expect.objectContaining({
+        value: "hermes",
+        label: "Hermes Terminal"
+      }),
+      expect.objectContaining({
+        value: OTHER_TERMINAL_OPTION.value,
+        label: OTHER_TERMINAL_OPTION.label
+      })
+    ]);
+  });
+
+  test("requires at least one actionable terminal choice", () => {
+    expect(validateInitTerminalSelection([])).toBe("Select at least one terminal or choose Other.");
+    expect(validateInitTerminalSelection(["codex:installed"])).toBe(
+      "Installed terminals are already configured. Select another terminal or choose Other."
+    );
+    expect(validateInitTerminalSelection(["other"])).toBeUndefined();
+    expect(validateInitTerminalSelection(["hermes"])).toBeUndefined();
+  });
+});
+
 describe("TokenBuddy JSON inspection commands", () => {
   let controlServer: http.Server;
+  let proxyServer: http.Server;
   let controlPort: number;
+  let proxyPort: number;
   let previousControlPort: string | undefined;
   let previousProxyPort: string | undefined;
 
   beforeEach((done) => {
     previousControlPort = process.env.TB_PROXYD_CONTROL_PORT;
     previousProxyPort = process.env.TB_PROXYD_PROXY_PORT;
+    proxyServer = http.createServer((req, res) => {
+      res.setHeader("Content-Type", "application/json");
+      if (req.url === "/v1/models") {
+        res.end(JSON.stringify({
+          object: "list",
+          data: [
+            { id: "gpt-4", sellerId: "json-test-seller" }
+          ]
+        }));
+        return;
+      }
+      res.statusCode = 404;
+      res.end(JSON.stringify({ error: "not_found" }));
+    });
     controlServer = http.createServer((req, res) => {
       res.setHeader("Content-Type", "application/json");
+      if (req.url === "/health") {
+        res.end(JSON.stringify({
+          status: "ok",
+          controlPort,
+          proxyPort
+        }));
+        return;
+      }
       if (req.url === "/status") {
         res.end(JSON.stringify({
           status: "running",
           pid: 12345,
           controlPort,
-          proxyPort: 45678
+          proxyPort
+        }));
+        return;
+      }
+      if (req.url === "/sellers") {
+        res.end(JSON.stringify({
+          registryUrl: "https://example.test/registry/sellers",
+          version: 7,
+          defaultSeller: "json-test-seller",
+          sellers: [
+            {
+              id: "json-test-seller",
+              name: "JSON Seller",
+              url: "https://seller.example.test",
+              supportedProtocols: ["responses"],
+              paymentMethods: ["mock"],
+              discountRatio: 0.25,
+              status: "configured"
+            }
+          ]
         }));
         return;
       }
       if (req.url === "/models") {
         res.end(JSON.stringify({
           object: "list",
+          registryUrl: "https://example.test/registry/sellers",
           data: [
-            { id: "gpt-4", sellerId: "json-test-seller" }
+            {
+              id: "gpt-4",
+              sellerId: "json-test-seller",
+              sellerName: "JSON Seller",
+              sellerUrl: "https://seller.example.test",
+              supportedProtocols: ["responses"],
+              paymentMethods: ["mock"],
+              inputPriceMicrosPer1m: 1000000,
+              outputPriceMicrosPer1m: 3000000
+            }
+          ],
+          sellers: [
+            {
+              id: "json-test-seller",
+              name: "JSON Seller",
+              url: "https://seller.example.test",
+              supportedProtocols: ["responses"],
+              paymentMethods: ["mock"],
+              discountRatio: 0.25,
+              status: "ok",
+              modelCount: 1
+            }
           ]
         }));
         return;
@@ -406,11 +628,14 @@ describe("TokenBuddy JSON inspection commands", () => {
       res.statusCode = 404;
       res.end(JSON.stringify({ error: "not_found" }));
     });
-    controlServer.listen(0, "127.0.0.1", () => {
-      controlPort = (controlServer.address() as AddressInfo).port;
-      process.env.TB_PROXYD_CONTROL_PORT = String(controlPort);
-      process.env.TB_PROXYD_PROXY_PORT = "45678";
-      done();
+    proxyServer.listen(0, "127.0.0.1", () => {
+      proxyPort = (proxyServer.address() as AddressInfo).port;
+      controlServer.listen(0, "127.0.0.1", () => {
+        controlPort = (controlServer.address() as AddressInfo).port;
+        process.env.TB_PROXYD_CONTROL_PORT = String(controlPort);
+        process.env.TB_PROXYD_PROXY_PORT = String(proxyPort);
+        done();
+      });
     });
   });
 
@@ -426,7 +651,7 @@ describe("TokenBuddy JSON inspection commands", () => {
       process.env.TB_PROXYD_PROXY_PORT = previousProxyPort;
     }
     jest.restoreAllMocks();
-    controlServer.close(done);
+    controlServer.close(() => proxyServer.close(done));
   });
 
   test("doctor --json reports daemon and provider state", async () => {
@@ -442,7 +667,7 @@ describe("TokenBuddy JSON inspection commands", () => {
     expect(parsed.daemon).toMatchObject({
       running: true,
       controlPort,
-      proxyPort: 45678,
+      proxyPort,
       fixAvailable: true
     });
     expect(parsed.repair).toMatchObject({
@@ -450,12 +675,46 @@ describe("TokenBuddy JSON inspection commands", () => {
       attempted: false,
       fixed: false
     });
+    expect(parsed.access).toMatchObject({
+      token: "TOKENBUDDY_PROXY",
+      controlBaseUrl: `http://127.0.0.1:${controlPort}`,
+      proxyBaseUrl: `http://127.0.0.1:${proxyPort}`,
+    });
+    expect(parsed.access.endpoints).toEqual(expect.arrayContaining([
+      expect.objectContaining({ id: "control.health", available: true }),
+      expect.objectContaining({ id: "proxy.openai", available: true, token: "TOKENBUDDY_PROXY" })
+    ]));
+    expect(parsed.sellers).toMatchObject({
+      available: true,
+      registryUrl: "https://example.test/registry/sellers",
+      defaultSeller: "json-test-seller",
+    });
+    expect(parsed.models).toMatchObject({
+      available: true,
+      count: 1,
+      registryUrl: "https://example.test/registry/sellers",
+    });
     expect(parsed.providers).toEqual(expect.arrayContaining([
       expect.objectContaining({ id: "codex" }),
       expect.objectContaining({ id: "claude-code" })
     ]));
   });
 
+  test("doctor prints progress messages without repeating the model list", async () => {
+    const output: string[] = [];
+    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
+      output.push(String(message));
+    });
+
+    await buildCli().parseAsync(["node", "tb", "doctor"]);
+
+    const joined = output.join("\n");
+    expect(joined).toContain("Checking local control plane and proxy endpoints...");
+    expect(joined).toContain("Refreshing seller registry...");
+    expect(joined).toContain("Model catalog hidden in `tb doctor`. Run `tb models` for the current model summary.");
+    expect(joined).not.toContain("Unique models:");
+  });
+
   test("models --json returns daemon model data", async () => {
     const output: string[] = [];
     jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
@@ -466,47 +725,127 @@ describe("TokenBuddy JSON inspection commands", () => {
 
     expect(output).toHaveLength(1);
     const parsed = JSON.parse(output[0]) as any;
-    expect(parsed.data).toEqual([
-      { id: "gpt-4", sellerId: "json-test-seller" }
+    expect(parsed.grouped).toEqual([
+      expect.objectContaining({
+        id: "gpt-4",
+        sellerCount: 1,
+        discountRange: "0.25",
+        priceRange: "in $1 / out $3"
+      })
     ]);
   });
+
+  test("models prints the doctor-style grouped model summary", async () => {
+    const output: string[] = [];
+    jest.spyOn(console, "log").mockImplementation((message?: unknown) => {
+      output.push(String(message));
+    });
+
+    await buildCli().parseAsync(["node", "tb", "models"]);
+
+    const joined = output.join("\n");
+    expect(joined).toContain("Model catalog refresh complete.");
+    expect(joined).toContain("Unique models: 1");
+    expect(joined).toContain("Seller offers: 1");
+    expect(joined).toContain("Model ID");
+    expect(joined).toContain("Seller Count");
+    expect(joined).toContain("Discount Range");
+    expect(joined).toContain("Price Range");
+    expect(joined).toContain("gpt-4");
+    expect(joined).toContain("0.25");
+    expect(joined).toContain("$1");
+    expect(joined).toContain("$3");
+  });
 });
 
 describe("Provider install planning", () => {
   const PROVIDER_HOME = path.resolve(__dirname, "../../data-test/provider-home");
   const PROVIDER_STORE_ROOT = path.resolve(__dirname, "../../data-test/provider-store");
+  const PROVIDER_BIN_ROOT = path.resolve(__dirname, "../../data-test/provider-bin");
   const proxyUrl = "http://127.0.0.1:17821";
+  let previousPath: string | undefined;
+
+  function writeExecutable(name: string): void {
+    const executablePath = path.join(PROVIDER_BIN_ROOT, name);
+    fs.writeFileSync(executablePath, "#!/bin/sh\nexit 0\n", "utf8");
+    fs.chmodSync(executablePath, 0o755);
+  }
 
   beforeEach(() => {
     rmDir(PROVIDER_HOME);
     rmDir(PROVIDER_STORE_ROOT);
+    rmDir(PROVIDER_BIN_ROOT);
     fs.mkdirSync(path.join(PROVIDER_HOME, ".codex"), { recursive: true });
     fs.mkdirSync(path.join(PROVIDER_HOME, ".claude"), { recursive: true });
     fs.mkdirSync(path.join(PROVIDER_HOME, ".openclaw"), { recursive: true });
+    fs.mkdirSync(path.join(PROVIDER_HOME, ".config", "opencode"), { recursive: true });
+    fs.mkdirSync(PROVIDER_BIN_ROOT, { recursive: true });
+    writeExecutable("codex");
+    writeExecutable("claude");
+    writeExecutable("openclaw");
+    writeExecutable("opencode");
+    writeExecutable("hermes");
+    previousPath = process.env.PATH;
+    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, ".config", "opencode", "opencode.json"), JSON.stringify({ share: "disabled" }, null, 2), "utf8");
   });
 
   afterEach(() => {
     rmDir(PROVIDER_HOME);
     rmDir(PROVIDER_STORE_ROOT);
+    rmDir(PROVIDER_BIN_ROOT);
+    if (previousPath === undefined) {
+      delete process.env.PATH;
+    } else {
+      process.env.PATH = previousPath;
+    }
   });
 
   test("detects providers and previews without mutating files", () => {
     const codexBefore = fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8");
     const providers = detectProviders({ home: PROVIDER_HOME });
     expect(providers).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: "codex", detected: true }),
-      expect.objectContaining({ id: "claude-code", detected: true }),
-      expect.objectContaining({ id: "openclaw", detected: true }),
-      expect.objectContaining({ id: "hermes", detected: false })
+      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: "hermes", status: "installed", configured: false })
     ]));
 
     const changes = previewProviderInstall({
       providers: ["codex", "claude-code", "openclaw", "hermes"],
       proxyUrl,
-      model: "gpt-4",
+      providerSelections: {
+        codex: {
+          selectionKind: "single-model",
+          protocolPreference: "responses",
+          defaultModel: "gpt-4",
+        },
+        "claude-code": {
+          selectionKind: "claude-role-mapping",
+          protocolPreference: "messages",
+          fallbackModel: "MiniMax-M2.7-highspeed",
+          roles: {
+            sonnet: {
+              upstreamModel: "MiniMax-M2.7-highspeed",
+              displayName: "MiniMax-M2.7-highspeed",
+              declareOneM: true,
+            },
+          },
+        },
+        openclaw: {
+          selectionKind: "single-model",
+          protocolPreference: "chat_completions",
+          defaultModel: "gpt-4",
+        },
+        hermes: {
+          selectionKind: "single-model",
+          protocolPreference: "chat_completions",
+          defaultModel: "gpt-4",
+        },
+      },
       home: PROVIDER_HOME
     });
 
@@ -517,13 +856,89 @@ describe("Provider install planning", () => {
     expect(fs.readFileSync(path.join(PROVIDER_HOME, ".codex", "config.toml"), "utf8")).toBe(codexBefore);
   });
 
+  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.mkdirSync(path.join(PROVIDER_HOME, ".hermes"), { recursive: true });
+    fs.writeFileSync(path.join(PROVIDER_HOME, ".hermes", "config.yaml"), "model: gpt-4\n", "utf8");
+
+    const providers = detectProviders({ home: PROVIDER_HOME });
+    expect(providers).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        id: "openclaw",
+        status: "installed",
+        configured: false,
+        executablePath: expect.stringContaining(path.join("provider-bin", "openclaw")),
+        observedPaths: expect.arrayContaining([path.join(PROVIDER_HOME, ".openclaw", "openclaw.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")]),
+      }),
+    ]));
+  });
+
   test("applies provider config and rolls back existing and created files", () => {
     const store = new BuyerStore({ root: PROVIDER_STORE_ROOT });
     try {
       const applied = applyProviderInstall({
-        providers: ["codex", "claude-code", "openclaw", "hermes"],
+        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
         proxyUrl,
-        model: "gpt-4",
+        providerSelections: {
+          codex: {
+            selectionKind: "single-model",
+            protocolPreference: "responses",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+          "claude-code": {
+            selectionKind: "claude-role-mapping",
+            protocolPreference: "messages",
+            fallbackModel: "MiniMax-M2.7-highspeed",
+            roles: {
+              sonnet: {
+                upstreamModel: "MiniMax-M2.7-highspeed",
+                displayName: "MiniMax-M2.7-highspeed",
+                declareOneM: true,
+              },
+              opus: {
+                upstreamModel: "MiniMax-M2.7-highspeed",
+                displayName: "MiniMax-M2.7-highspeed",
+                declareOneM: true,
+              },
+              haiku: {
+                upstreamModel: "MiniMax-M2.7-highspeed",
+                displayName: "MiniMax-M2.7-highspeed",
+                declareOneM: false,
+              },
+            },
+          },
+          openclaw: {
+            selectionKind: "single-model",
+            protocolPreference: "chat_completions",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+          opencode: {
+            selectionKind: "single-model",
+            protocolPreference: "responses",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+          hermes: {
+            selectionKind: "single-model",
+            protocolPreference: "chat_completions",
+            defaultModel: "gpt-4",
+            sellerId: "seller-one",
+          },
+        },
+        sellerRouting: {
+          mode: "fixed",
+          sellerId: "seller-one",
+        },
         home: PROVIDER_HOME
       }, store);
       expect(applied).toEqual(expect.arrayContaining([
@@ -539,15 +954,30 @@ describe("Provider install planning", () => {
       const claude = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".claude", "settings.json"), "utf8"));
       expect(claude.theme).toBe("dark");
       expect(claude.env.ANTHROPIC_BASE_URL).toBe(proxyUrl);
+      expect(claude.env.ANTHROPIC_DEFAULT_SONNET_MODEL).toBe("claude-sonnet-4-6[1M]");
+      expect(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL).toBe("claude-opus-4-7[1M]");
+      expect(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL).toBe("claude-haiku-4-5");
+      expect(claude.env.ANTHROPIC_DEFAULT_SONNET_MODEL_NAME).toBe("MiniMax-M2.7-highspeed");
+      expect(store.getProviderRuntimeConfig("claude-code")).toBeDefined();
+      expect(store.getDaemonRuntimeConfig("routing")).toMatchObject({
+        config: expect.objectContaining({
+          mode: "fixed",
+          sellerId: "seller-one",
+        }),
+      });
 
       const openclaw = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".openclaw", "config.json"), "utf8"));
       expect(openclaw.keep).toBe("field");
       expect(openclaw.api_url).toBe(proxyUrl);
+      const opencode = JSON.parse(fs.readFileSync(path.join(PROVIDER_HOME, ".config", "opencode", "opencode.json"), "utf8"));
+      expect(opencode.share).toBe("disabled");
+      expect(opencode.provider.tokenbuddy.options.baseURL).toBe(`${proxyUrl}/v1`);
+      expect(opencode.provider.tokenbuddy.models["gpt-4"].name).toBe("gpt-4");
       expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(true);
       expect(store.getProviderInstallSnapshot("codex")).toBeDefined();
 
       const rolledBack = rollbackProviderInstall({
-        providers: ["codex", "claude-code", "openclaw", "hermes"],
+        providers: ["codex", "claude-code", "openclaw", "opencode", "hermes"],
         home: PROVIDER_HOME
       }, store);
 
@@ -557,8 +987,11 @@ describe("Provider install planning", () => {
       ]));
       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, ".config", "opencode", "opencode.json"), "utf8"))).toEqual({ share: "disabled" });
       expect(fs.existsSync(path.join(PROVIDER_HOME, ".hermes", "settings.json"))).toBe(false);
       expect(store.getProviderInstallSnapshot("codex")).toBeUndefined();
+      expect(store.getProviderRuntimeConfig("claude-code")).toBeUndefined();
+      expect(store.getDaemonRuntimeConfig("routing")).toBeUndefined();
     } finally {
       store.close();
     }
@@ -703,6 +1136,29 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
           idempotencyKey: req.headers["idempotency-key"] as string | undefined,
           body
         });
+        if (body.requestId === "responses_req_stream_shape") {
+          res.writeHead(200, { "Content-Type": "text/event-stream" });
+          res.write('event: response.created\ndata: {"type":"response.created","response":{"id":"resp_stream_shape","object":"response","model":"gpt-4.1-mini","status":"in_progress","output":[]}}\n\n');
+          res.write('event: response.output_item.added\ndata: {"type":"response.output_item.added","item":{"type":"message","id":"item_stream_shape","role":"assistant","status":"in_progress"},"sequence_number":1}\n\n');
+          res.write('event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"hello","item_id":"item_stream_shape","sequence_number":2}\n\n');
+          res.write('event: response.output_text.done\ndata: {"type":"response.output_text.done","item_id":"item_stream_shape","sequence_number":3}\n\n');
+          res.write('event: response.output_item.done\ndata: {"type":"response.output_item.done","item":{"type":"message","id":"item_stream_shape","status":"completed"},"sequence_number":4}\n\n');
+          res.end('event: response.completed\ndata: {"type":"response.completed","response":{"id":"resp_stream_shape","object":"response","model":"gpt-4.1-mini","status":"completed","output":[],"usage":{"input_tokens":10,"output_tokens":1,"total_tokens":11}},"sequence_number":5}\n\n');
+          return;
+        }
+        if (body.requestId === "responses_req_br") {
+          const compressed = zlib.brotliCompressSync(Buffer.from(JSON.stringify({
+            id: "resp-br",
+            usage: { input_tokens: 7, output_tokens: 9 }
+          })));
+          res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Content-Encoding": "br",
+            "Content-Length": compressed.byteLength
+          });
+          res.end(compressed);
+          return;
+        }
         res.end(JSON.stringify({
           id: "resp-mock",
           usage: { input_tokens: 7, output_tokens: 9 }
@@ -772,6 +1228,28 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
       prompt: "raw control prompt",
       response: "raw control response"
     });
+    seedStore.saveProviderRuntimeConfig("claude-code", {
+      selectionKind: "claude-role-mapping",
+      protocolPreference: "messages",
+      fallbackModel: "claude-3-5-sonnet",
+      roles: {
+        sonnet: {
+          upstreamModel: "claude-3-5-sonnet",
+          displayName: "Claude Sonnet Mock",
+          declareOneM: true
+        },
+        opus: {
+          upstreamModel: "claude-3-5-sonnet",
+          displayName: "Claude Opus Mock",
+          declareOneM: true
+        },
+        haiku: {
+          upstreamModel: "claude-3-5-sonnet",
+          displayName: "Claude Haiku Mock",
+          declareOneM: false
+        }
+      }
+    });
     seedStore.close();
 
     daemon = new TokenbuddyDaemon({
@@ -954,6 +1432,19 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     expect(largeResponses.ok).toBe(true);
     expect((await largeResponses.json() as any).id).toBe("resp-mock");
 
+    const compressedResponses = await fetch(`${proxyUrl}/v1/responses`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4.1-mini",
+        input: "raw compressed responses prompt secret",
+        requestId: "responses_req_br"
+      })
+    });
+    expect(compressedResponses.ok).toBe(true);
+    expect(compressedResponses.headers.get("content-encoding")).toBeNull();
+    expect((await compressedResponses.json() as any).id).toBe("resp-br");
+
     for (const endpoint of ["/v1/messages", "/messages"]) {
       const message = await fetch(`${proxyUrl}${endpoint}`, {
         method: "POST",
@@ -985,6 +1476,30 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     expect(publicOutput).not.toContain("raw anthropic prompt secret");
   });
 
+  test("maps Claude role aliases to upstream models before message routing", async () => {
+    for (const model of ["sonnet", "claude-sonnet-4-6[1M]"]) {
+      const message = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/messages`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: "role mapping request" }]
+        })
+      });
+      expect(message.ok).toBe(true);
+      expect((await message.json() as any).id).toBe("msg-mock");
+    }
+
+    const messageRequests = sellerRequests.filter((request) => request.url === "/v1/messages");
+    expect(messageRequests).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        body: expect.objectContaining({
+          model: "claude-3-5-sonnet"
+        })
+      })
+    ]));
+  });
+
   test("passes through streaming chat responses and records safe ledger metadata", async () => {
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
       method: "POST",
@@ -1016,6 +1531,28 @@ describe("TokenBuddy CLI and Daemon Integration Tests", () => {
     expect(publicOutput).not.toContain("chatcmpl-stream");
   });
 
+  test("normalizes responses SSE shape for OpenCode-compatible consumers", async () => {
+    const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/responses`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4.1-mini",
+        input: "shape normalization",
+        requestId: "responses_req_stream_shape",
+        stream: true
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    const body = await response.text();
+    expect(body).toContain("response.content_part.added");
+    expect(body).toContain("response.content_part.done");
+    expect(body).toContain("\"item_id\":\"item_stream_shape\"");
+    expect(body).toContain("\"output_text\":\"hello\"");
+    expect(body).toContain("\"content\":[{\"type\":\"output_text\",\"text\":\"hello\",\"annotations\":[]}]");
+  });
+
   test("fails closed when no compatible seller can serve the requested model", async () => {
     const response = await fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
       method: "POST",
@@ -1108,6 +1645,41 @@ describe("TokenBuddy manual routing mode", () => {
         return;
       }
 
+      if (req.url === "/backup/purchase/create") {
+        expect(body.paymentMethod).toBe("mock");
+        events.push({ seller: "backup-seller", url: req.url });
+        res.end(JSON.stringify({
+          purchaseId: "pur_backup_123",
+          status: "pending",
+          creditMicros: 2000000,
+          currency: "USD",
+          expiresAt: new Date(Date.now() + 86400 * 1000).toISOString()
+        }));
+        return;
+      }
+
+      if (req.url === "/backup/purchase/complete") {
+        events.push({ seller: "backup-seller", url: req.url });
+        res.end(JSON.stringify({
+          purchaseId: "pur_backup_123",
+          status: "active",
+          accessToken: "tok_backup_token_abc",
+          tokenClass: "model:gpt-manual",
+          creditMicros: 2000000,
+          currency: "USD"
+        }));
+        return;
+      }
+
+      if (req.url === "/backup/v1/chat/completions") {
+        events.push({ seller: "backup-seller", url: req.url });
+        res.end(JSON.stringify({
+          id: "backup-chat",
+          usage: { prompt_tokens: 4, completion_tokens: 5 }
+        }));
+        return;
+      }
+
       if (req.url?.startsWith("/backup/")) {
         events.push({ seller: "backup-seller", url: req.url });
         res.end(JSON.stringify({ id: "backup-should-not-run" }));
@@ -1183,4 +1755,41 @@ describe("TokenBuddy manual routing mode", () => {
     expect(purchases.purchases.some((entry: any) => entry.sellerKey === "backup-seller")).toBe(false);
     expect(inferences.inferences.some((entry: any) => entry.sellerKey === "backup-seller")).toBe(false);
   });
+
+  test("pins manual routing to the configured seller id when selectedSellerId is set", async () => {
+    daemon.stop();
+    events.length = 0;
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0,
+      proxyPort: 0,
+      dbPath,
+      sellerRegistryUrl: `http://127.0.0.1:${sellerPort}/registry/sellers`,
+      selectionMode: "manual",
+      selectedSellerId: "backup-seller"
+    });
+    daemon.start();
+    daemonControlPort = ((daemon as any).controlServer.address() as AddressInfo).port;
+    daemonProxyPort = ((daemon as any).proxyServer.address() as AddressInfo).port;
+
+    const status = await (await fetch(`http://127.0.0.1:${daemonControlPort}/status`)).json() as any;
+    expect(status.selectionMode).toBe("manual");
+    expect(status.selectedSellerId).toBe("backup-seller");
+
+    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: "manual selected seller should stay pinned" }]
+      })
+    });
+
+    expect(response.ok).toBe(true);
+    expect(events).toEqual([
+      { seller: "backup-seller", url: "/backup/manifest" },
+      { seller: "backup-seller", url: "/backup/purchase/create" },
+      { seller: "backup-seller", url: "/backup/purchase/complete" },
+      { seller: "backup-seller", url: "/backup/v1/chat/completions" }
+    ]);
+  });
 });