@tokenbuddy/tokenbuddy 1.0.4 → 1.0.6

package/src/seller-catalog.ts

@@ -0,0 +1,222 @@
+import { createModuleLogger } from "@tokenbuddy/logging";
+
+const logger = createModuleLogger("tb-proxyd");
+
+export type ProtocolPreference = "chat_completions" | "responses" | "messages";
+
+export interface RegistrySeller {
+  id: string;
+  name?: string;
+  url: string;
+  supportedProtocols?: string[];
+  paymentMethods?: string[];
+}
+
+export interface SellerRegistryDocument {
+  version: number;
+  defaultSeller?: string;
+  sellers: RegistrySeller[];
+}
+
+export interface SellerManifest {
+  sellerId?: string;
+  seller_id?: string;
+  supportedProtocols?: string[];
+  supported_protocols?: string[];
+  paymentMethods?: string[];
+  payment_methods?: string[];
+  models?: ManifestModelRecord[];
+  selection?: {
+    discountRatio?: number;
+    discount_ratio?: number;
+  };
+}
+
+export interface ManifestModelRecord {
+  id: string;
+  inputPriceMicrosPer1m?: number;
+  outputPriceMicrosPer1m?: number;
+  input_price_micros_per_1m?: number;
+  output_price_micros_per_1m?: number;
+  [key: string]: unknown;
+}
+
+export interface ModelCatalogEntry {
+  id: string;
+  sellerId: string;
+  sellerName?: string;
+  sellerUrl: string;
+  supportedProtocols: string[];
+  paymentMethods: string[];
+  inputPriceMicrosPer1m?: number;
+  outputPriceMicrosPer1m?: number;
+}
+
+export interface SellerCatalogEntry {
+  id: string;
+  name?: string;
+  url: string;
+  status: string;
+  manifestSellerId?: string;
+  discountRatio?: number;
+  modelCount?: number;
+  supportedProtocols?: string[];
+  paymentMethods?: string[];
+  errorMessage?: string;
+}
+
+export interface SellerCatalogResult {
+  registryUrl: string;
+  version: number;
+  defaultSeller?: string;
+  models: ModelCatalogEntry[];
+  sellers: SellerCatalogEntry[];
+}
+
+export type SellerRoutingMode = "auto" | "fixed";
+
+export interface SellerRoutingPreference {
+  mode: SellerRoutingMode;
+  sellerId?: string;
+}
+
+export function normalizeSellerUrl(seller: RegistrySeller): string {
+  return seller.url.replace(/\/+$/, "");
+}
+
+export function manifestProtocols(manifest: SellerManifest, seller: RegistrySeller): string[] {
+  const protocols = manifest.supportedProtocols || manifest.supported_protocols || seller.supportedProtocols || [];
+  return protocols.includes("anthropic_messages") && !protocols.includes("messages")
+    ? [...protocols, "messages"]
+    : protocols;
+}
+
+export function manifestPaymentMethods(manifest: SellerManifest, seller: RegistrySeller): string[] {
+  return manifest.paymentMethods || manifest.payment_methods || seller.paymentMethods || [];
+}
+
+export function manifestModelIds(manifest: SellerManifest): string[] {
+  return (manifest.models || [])
+    .map((model) => model.id)
+    .filter((id): id is string => typeof id === "string" && id.trim().length > 0)
+    .map((id) => id.trim());
+}
+
+function numericPriceField(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function manifestModels(manifest: SellerManifest): ManifestModelRecord[] {
+  return (manifest.models || [])
+    .filter((model): model is ManifestModelRecord => Boolean(model?.id && typeof model.id === "string"));
+}
+
+export async function fetchSellerRegistry(registryUrl: string): Promise<SellerRegistryDocument> {
+  const response = await fetch(registryUrl);
+  if (!response.ok) {
+    throw new Error(`registry returned ${response.status}`);
+  }
+  const data = await response.json() as SellerRegistryDocument;
+  if (!data || !Array.isArray(data.sellers)) {
+    throw new Error("registry response missing sellers");
+  }
+  return data;
+}
+
+export async function fetchSellerManifest(seller: RegistrySeller): Promise<SellerManifest> {
+  const response = await fetch(`${normalizeSellerUrl(seller)}/manifest`);
+  if (!response.ok) {
+    throw new Error(`manifest returned ${response.status}`);
+  }
+  return await response.json() as SellerManifest;
+}
+
+export async function discoverSellerBackedModels(registryUrl: string): Promise<SellerCatalogResult> {
+  const registry = await fetchSellerRegistry(registryUrl);
+  const sellerResults = await Promise.all(registry.sellers.map(async (seller) => {
+    try {
+      const manifest = await fetchSellerManifest(seller);
+      const protocols = manifestProtocols(manifest, seller);
+      const paymentMethods = manifestPaymentMethods(manifest, seller);
+      const models = manifestModels(manifest).map((model) => ({
+        id: model.id.trim(),
+        sellerId: seller.id,
+        sellerName: seller.name,
+        sellerUrl: seller.url,
+        supportedProtocols: protocols,
+        paymentMethods,
+        inputPriceMicrosPer1m: numericPriceField(model.inputPriceMicrosPer1m) ?? numericPriceField(model.input_price_micros_per_1m),
+        outputPriceMicrosPer1m: numericPriceField(model.outputPriceMicrosPer1m) ?? numericPriceField(model.output_price_micros_per_1m),
+      }));
+      return {
+        seller: {
+          id: seller.id,
+          name: seller.name,
+          url: seller.url,
+          status: "ok",
+          manifestSellerId: manifest.sellerId || manifest.seller_id || seller.id,
+          discountRatio: manifest.selection?.discountRatio ?? manifest.selection?.discount_ratio,
+          modelCount: models.length,
+          supportedProtocols: protocols,
+          paymentMethods,
+        },
+        models
+      };
+    } catch (error: unknown) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.warn("models.refresh.seller_failed", "seller manifest refresh failed", {
+        sellerId: seller.id,
+        errorMessage
+      });
+      return {
+        seller: {
+          id: seller.id,
+          name: seller.name,
+          url: seller.url,
+          status: "failed",
+          errorMessage
+        },
+        models: [] as ModelCatalogEntry[]
+      };
+    }
+  }));
+
+  return {
+    registryUrl,
+    version: registry.version,
+    defaultSeller: registry.defaultSeller,
+    models: sellerResults.flatMap((entry) => entry.models),
+    sellers: sellerResults.map((entry) => entry.seller)
+  };
+}
+
+export function filterCatalogByProtocol(
+  models: ModelCatalogEntry[],
+  protocol: ProtocolPreference
+): ModelCatalogEntry[] {
+  return models.filter((entry) => entry.supportedProtocols.includes(protocol));
+}
+
+export function filterCatalogBySeller(
+  models: ModelCatalogEntry[],
+  sellerId: string | undefined
+): ModelCatalogEntry[] {
+  if (!sellerId) {
+    return models;
+  }
+  return models.filter((entry) => entry.sellerId === sellerId);
+}
+
+export function dedupeCatalogEntries(models: ModelCatalogEntry[]): ModelCatalogEntry[] {
+  const seen = new Set<string>();
+  const output: ModelCatalogEntry[] = [];
+  for (const entry of models) {
+    const key = `${entry.sellerId}:${entry.id}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(entry);
+  }
+  return output;
+}

package/src/tb-proxyd.ts

@@ -9,13 +9,15 @@ const controlPort = parsePortEnv("TB_PROXYD_CONTROL_PORT", 17820);
 const proxyPort = parsePortEnv("TB_PROXYD_PROXY_PORT", 17821);
 const sellerRegistryUrl = process.env.TB_PROXYD_SELLER_REGISTRY_URL || "https://tb-wallet-bootstrap.fly.dev/registry/sellers";
 const selectionMode = parseSelectionModeEnv();
+const selectedSellerId = parseSelectedSellerIdEnv();
 
 const daemon = new TokenbuddyDaemon({
   controlPort,
   proxyPort,
   dbPath,
   sellerRegistryUrl,
-  selectionMode
+  selectionMode,
+  selectedSellerId
 });
 
 logger.info("proxy.process.initializing", "tb-proxyd process initializing", {
@@ -23,7 +25,8 @@ logger.info("proxy.process.initializing", "tb-proxyd process initializing", {
   controlPort,
   proxyPort,
   sellerRegistryUrl,
-  selectionMode
+  selectionMode,
+  selectedSellerId
 });
 daemon.start();
 
@@ -58,3 +61,12 @@ function parseSelectionModeEnv(): "auto" | "manual" {
   }
   throw new Error("TB_PROXYD_SELECTION_MODE must be auto or manual");
 }
+
+function parseSelectedSellerIdEnv(): string | undefined {
+  const rawValue = process.env.TB_PROXYD_SELECTED_SELLER_ID;
+  if (!rawValue) {
+    return undefined;
+  }
+  const trimmed = rawValue.trim();
+  return trimmed || undefined;
+}

package/tests/e2e.test.ts

@@ -1,6 +1,7 @@
 import { buildApp as buildBootstrapApp } from "../../wallet-bootstrap/src/server.js";
 import { buildSellerApp } from "../../seller/src/server.js";
 import { TokenbuddyDaemon } from "../src/daemon.js";
+import { BuyerStore } from "../src/buyer-store.js";
 import { AdminClient } from "../../admin-cli/src/client.js";
 import * as path from "path";
 import * as fs from "fs";
@@ -39,6 +40,14 @@ describe("TokenBuddy Full End-to-End Integration Flow Tests", () => {
     if (fs.existsSync(TEMP_BUYER_DB)) {
       try { fs.unlinkSync(TEMP_BUYER_DB); } catch (e) {}
     }
+    const buyerStore = new BuyerStore({ dbPath: TEMP_BUYER_DB });
+    buyerStore.savePayment({
+      method: "mock",
+      enabled: true,
+      isDefault: true,
+      config: { channel: "e2e-test" }
+    });
+    buyerStore.close();
 
     // 1. Launch Mock Upstream OpenAI completions server
     upstreamServer = http.createServer((req, res) => {