@tokenbuddy/tb-admin 1.0.15 → 1.0.28

package/src/ui-actions.ts

@@ -84,17 +84,20 @@ export class UiActions {
   }
 
   public async updateSellerConfig(id: string, patch: ConfigPatch): Promise<UiActionResult> {
-    const { profileName, config } = await this.state.rawSellerConfig(id);
-    if (!profileName) {
-      throw new Error(`seller \`${id}\` has no local profile for seller-config put`);
-    }
+    const { entry, profileName, config } = await this.state.rawSellerConfig(id);
     const next = mergeSellerConfigPatch(config, patch);
     return this.withTempYaml(next, async (filePath) => {
-      const validate = await this.runAdmin(profileArgs(this.options, profileName, ["seller-config", "validate", "--file", filePath]), 30000);
+      const validateArgs = profileName
+        ? profileArgs(this.options, profileName, ["seller-config", "validate", "--file", filePath])
+        : sellerOperatorArgs(this.options, entry, ["seller-config", "validate", "--file", filePath]);
+      const validate = await this.runAdmin(validateArgs, 30000);
       if (!validate.ok) {
         return validate;
       }
-      return this.runAdmin(profileArgs(this.options, profileName, ["seller-config", "put", "--file", filePath]), 30000);
+      const putArgs = profileName
+        ? profileArgs(this.options, profileName, ["seller-config", "put", "--file", filePath])
+        : sellerOperatorArgs(this.options, entry, ["seller-config", "put", "--file", filePath]);
+      return this.runAdmin(putArgs, 30000);
     });
   }
 
@@ -210,15 +213,7 @@ export class UiActions {
         });
         if (configPut.ok) {
           report({ stepId: "refresh_models", status: "running", title: "Refresh upstream models", message: `Refreshing model catalog from ${sellerOperatorUrl(appName)}.` });
-          modelsRefresh = await this.runAdmin(globalArgs(
-            {
-              ...this.options,
-              profile: undefined,
-              url: sellerOperatorUrl(appName),
-              token: operatorSecret
-            },
-            ["upstreams", "refresh", "--auto-models"]
-          ), 30000);
+          modelsRefresh = await this.refreshSellerModelsWithRetry(appName, operatorSecret, report);
           report({
             stepId: "refresh_models",
             status: modelsRefresh.ok ? "succeeded" : "failed",
@@ -239,6 +234,12 @@ export class UiActions {
         enabled: Boolean(result.ok && !normalizedRequest.dryRun && readiness?.ok && configPut?.ok && modelsRefresh?.ok),
         report
       });
+      if (registryPublish?.ok) {
+        this.options.configManager.setProfile(appName, {
+          url: sellerOperatorUrl(appName),
+          token: operatorSecret
+        });
+      }
       return {
         result,
         configValidation,
@@ -258,18 +259,15 @@ export class UiActions {
     if (!target) {
       throw new Error(`seller \`${id}\` not found in bootstrap registry`);
     }
-    const next = {
-      ...registry,
-      updatedAt: new Date().toISOString(),
-      sellers: registry.sellers.map((seller) => seller === target ? { ...seller, status } : seller)
-    };
-    return this.withTempJson(next, async (filePath) => {
-      const validate = await this.runAdmin(globalArgs(this.options, ["bootstrap", "sellers", "validate", "--file", filePath]), 30000);
-      if (!validate.ok) {
-        return validate;
-      }
-      return this.runAdmin(globalArgs(this.options, ["bootstrap", "sellers", "put", "--file", filePath]), 30000);
-    });
+    return this.runAdmin(globalArgs(this.options, [
+      "bootstrap",
+      "sellers",
+      "status",
+      target.id,
+      status,
+      "--expect-version",
+      String(registry.version)
+    ]), 30000);
   }
 
   public async deleteDeployment(id: string, confirm: boolean): Promise<UiActionResult> {
@@ -365,6 +363,43 @@ export class UiActions {
     return failed;
   }
 
+  private async refreshSellerModelsWithRetry(appName: string, operatorSecret: string, report: UiActionProgressReporter): Promise<UiActionResult> {
+    const maxAttempts = 6;
+    const baseDelayMs = 3000;
+    let last: UiActionResult | undefined;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (attempt > 1) {
+        report({
+          stepId: "refresh_models",
+          status: "running",
+          title: "Refresh upstream models",
+          message: `Retrying model catalog refresh (${attempt}/${maxAttempts}).`
+        });
+      }
+      last = await this.runAdmin(globalArgs(
+        {
+          ...this.options,
+          profile: undefined,
+          url: sellerOperatorUrl(appName),
+          token: operatorSecret
+        },
+        ["upstreams", "refresh", "--auto-models"]
+      ), 45000);
+      if (last.ok) {
+        return last;
+      }
+      if (attempt < maxAttempts) {
+        await sleep(baseDelayMs * attempt);
+      }
+    }
+    return last || {
+      ok: false,
+      stdout: "",
+      stderr: "model catalog refresh did not run",
+      command: ["tb-admin", "upstreams", "refresh", "--auto-models"]
+    };
+  }
+
   private async publishCreatedSellerRegistryEntry(options: {
     registry: SellerRegistryDocument;
     request: CreateSellerRequest;
@@ -387,15 +422,16 @@ export class UiActions {
     report({
       stepId: "publish_registry",
       status: "running",
-      title: "Publish bootstrap registry",
-      message: `Publishing ${request.sellerName} to bootstrap registry.`
+      title: "Update bootstrap registry",
+      message: `Adding ${request.sellerName} to bootstrap registry.`
     });
 
-    let next: SellerRegistryDocument;
+    let entry: SellerRegistryEntry;
     try {
       const upstreams = await this.fetchSellerOperatorJson(appName, operatorSecret, "/operator/admin/upstreams");
       const service = await this.fetchSellerOperatorJson(appName, operatorSecret, "/operator/admin/service");
-      next = nextRegistryDocument(registry, request, appName, upstreams, service);
+      const manifest = await this.fetchSellerOperatorJsonOptional(appName, operatorSecret, "/manifest");
+      entry = registryEntryFromCreatedSeller(request, appName, upstreams, service, manifest);
     } catch (err: any) {
       const failed = {
         ok: false,
@@ -406,30 +442,27 @@ export class UiActions {
       report({
         stepId: "publish_registry",
         status: "failed",
-        title: "Publish bootstrap registry",
+        title: "Update bootstrap registry",
         message: "Failed to read seller metadata for bootstrap registry.",
         result: failed
       });
       return failed;
     }
-    return this.withTempJson(next, async (filePath) => {
-      const validate = await this.runAdmin(globalArgs(this.options, ["bootstrap", "sellers", "validate", "--file", filePath]), 30000);
-      if (!validate.ok) {
-        report({
-          stepId: "publish_registry",
-          status: "failed",
-          title: "Publish bootstrap registry",
-          message: "Generated bootstrap registry entry failed validation.",
-          result: validate
-        });
-        return validate;
-      }
-      const put = await this.runAdmin(globalArgs(this.options, ["bootstrap", "sellers", "put", "--file", filePath]), 30000);
+    return this.withTempJson(entry, async (filePath) => {
+      const put = await this.runAdmin(globalArgs(this.options, [
+        "bootstrap",
+        "sellers",
+        "add",
+        "--file",
+        filePath,
+        "--expect-version",
+        String(registry.version)
+      ]), 30000);
       report({
         stepId: "publish_registry",
         status: put.ok ? "succeeded" : "failed",
-        title: "Publish bootstrap registry",
-        message: put.ok ? "Bootstrap registry was published with the new seller." : "Bootstrap registry publish failed.",
+        title: "Update bootstrap registry",
+        message: put.ok ? "Bootstrap registry entry was added. Run registry publish to update R2." : "Bootstrap registry update failed.",
         result: put
       });
       return put;
@@ -446,47 +479,44 @@ export class UiActions {
     }
     return {};
   }
-}
 
-function nextRegistryDocument(
-  registry: SellerRegistryDocument,
-  request: CreateSellerRequest,
-  appName: string,
-  upstreams: Record<string, unknown>,
-  service: Record<string, unknown>
-): SellerRegistryDocument {
-  const entry = registryEntryFromCreatedSeller(request, appName, upstreams, service);
-  const sellers = registry.sellers.filter((seller) => {
-    return seller.id !== entry.id && seller.name !== entry.name && seller.app !== entry.app;
-  });
-  return {
-    ...registry,
-    version: Number(registry.version || 0) + 1,
-    updatedAt: new Date().toISOString(),
-    sellers: [...sellers, entry]
-  };
+  private async fetchSellerOperatorJsonOptional(appName: string, operatorSecret: string, pathName: string): Promise<Record<string, unknown>> {
+    try {
+      return await this.fetchSellerOperatorJson(appName, operatorSecret, pathName);
+    } catch {
+      return {};
+    }
+  }
 }
 
 function registryEntryFromCreatedSeller(
   request: CreateSellerRequest,
   appName: string,
   upstreams: Record<string, unknown>,
-  service: Record<string, unknown>
+  service: Record<string, unknown>,
+  manifest: Record<string, unknown>
 ): SellerRegistryEntry {
-  const models = modelIdsFrom(upstreams.models) || modelIdsFrom(service.models);
+  const wrappedUpstreams = upstreamPayload(upstreams);
+  const models = modelIdsFrom(upstreams.models)
+    || modelIdsFrom(wrappedUpstreams?.models)
+    || modelIdsFrom(service.models)
+    || modelIdsFrom(manifest.models);
   if (!models || models.length === 0) {
     throw new Error("seller operator upstreams did not return models for bootstrap registry");
   }
   const supportedProtocols = supportedProtocolsFrom(service.supportedProtocols)
     || supportedProtocolsFrom(upstreams.supportedProtocols)
+    || supportedProtocolsFrom(wrappedUpstreams?.supportedProtocols)
+    || supportedProtocolsFrom(manifest.supportedProtocols)
+    || supportedProtocolsFrom(manifest.supported_protocols)
     || ["chat_completions"];
   const paymentMethods = paymentMethodsFromRequest(request);
   return {
-    id: request.sellerName,
-    name: request.sellerName,
+    id: appName,
+    name: appName,
     app: appName,
     url: sellerOperatorUrl(appName),
-    status: "pending",
+    status: "active",
     region: stringValue(request.region),
     modelsCount: models.length || undefined,
     sampleModels: models.slice(0, 5),
@@ -513,6 +543,14 @@ function modelIdsFrom(value: unknown): string[] | undefined {
   }).filter((entry): entry is string => Boolean(entry))));
 }
 
+function upstreamPayload(value: Record<string, unknown>): Record<string, unknown> | undefined {
+  const wrapped = value.upstreams;
+  if (Array.isArray(wrapped)) {
+    return objectValue(wrapped[0]);
+  }
+  return objectValue(wrapped);
+}
+
 function supportedProtocolsFrom(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) {
     return undefined;
@@ -564,10 +602,14 @@ async function defaultFetchJson(url: string, init?: RequestInit): Promise<unknow
 
 function adminEntryPath(): string {
   const current = process.argv[1] || "";
-  if (current.endsWith("tb-admin.js")) {
+  if ((path.basename(current) === "tb-admin" || path.basename(current) === "tb-admin.js") && fs.existsSync(current)) {
     return current;
   }
-  return path.resolve(process.cwd(), "packages/admin-cli/bin/tb-admin.js");
+  const candidates = [
+    path.resolve(process.cwd(), "packages/admin-cli/bin/tb-admin.js"),
+    path.resolve(process.cwd(), "bin/tb-admin.js")
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[candidates.length - 1];
 }
 
 function globalArgs(options: UiActionsOptions, args: string[]): string[] {
@@ -592,6 +634,19 @@ function profileArgs(options: UiActionsOptions, profileName: string, args: strin
   return globalArgs({ ...options, profile: profileName, url: undefined, token: undefined }, args);
 }
 
+function sellerOperatorArgs(options: UiActionsOptions, entry: SellerRegistryEntry, args: string[]): string[] {
+  const operatorSecret = options.configManager.getSellerProvider("fly")?.operator_secret;
+  if (!operatorSecret) {
+    throw new Error(`seller \`${entry.id}\` has no local profile and seller_providers.fly.operator_secret is not configured`);
+  }
+  return globalArgs({
+    ...options,
+    profile: undefined,
+    url: entry.url,
+    token: operatorSecret
+  }, args);
+}
+
 function mergeSellerConfigPatch(config: Record<string, unknown>, patch: ConfigPatch): Record<string, unknown> {
   const next = { ...config };
   copyIfPresent(next, patch, "upstreamUrl");
@@ -672,6 +727,8 @@ function initialSellerConfig(request: CreateSellerRequest, masked: boolean): Rec
   const upstreamRechargeUrl = balanceProbeRechargeUrl(request);
   const paymentConfig = paymentConfigFromRequest(request, masked);
   return {
+    sellerId: request.app || request.sellerName,
+    manifestVersion: "manifest.v1",
     upstreamUrl: request.upstreamUrl,
     upstreamApiKey: masked ? "********" : request.upstreamApiKey,
     upstreamWebsite: request.upstreamWebsite,

package/src/ui-command.ts

@@ -18,7 +18,7 @@ export function bindAdminUiCommand(program: Command, configManager: ConfigManage
           openBrowser: Boolean(options.open),
           configManager,
           configPath: rootOptions.config,
-          profile: rootOptions.profile || process.env.TOKENBUDDY_ADMIN_PROFILE,
+          profile: rootOptions.profile || process.env.TOKENBUDDY_ADMIN_PROFILE || "bootstrap",
           url: rootOptions.url || process.env.TOKENBUDDY_ADMIN_URL,
           token: rootOptions.token || process.env.TOKENBUDDY_ADMIN_TOKEN
         });

package/src/ui-server.ts

@@ -23,7 +23,6 @@ export interface AdminUiServerOptions {
 export interface StartedAdminUiServer {
   server: http.Server;
   url: string;
-  sessionToken: string;
 }
 
 type UiJobStatus = "running" | "succeeded" | "failed";
@@ -44,13 +43,12 @@ export async function startAdminUiServer(options: AdminUiServerOptions): Promise
   assertSafeHost(options.host);
   assertSafePort(options.port);
 
-  const sessionToken = randomBytes(24).toString("hex");
   const state = new AdminUiState(options);
   const actions = new UiActions(options);
   const jobs = new Map<string, UiJob>();
   const server = http.createServer(async (req, res) => {
     try {
-      await routeRequest(req, res, sessionToken, state, actions, jobs);
+      await routeRequest(req, res, state, actions, jobs);
     } catch (err: any) {
       sendJson(res, 500, { error: err.message || "internal error" });
     }
@@ -66,17 +64,16 @@ export async function startAdminUiServer(options: AdminUiServerOptions): Promise
 
   const address = server.address();
   const actualPort = typeof address === "object" && address ? address.port : options.port;
-  const url = `http://${options.host}:${actualPort}/?session=${sessionToken}`;
+  const url = `http://${options.host}:${actualPort}/`;
   if (options.openBrowser) {
     openLocalBrowser(url).catch(() => undefined);
   }
-  return { server, url, sessionToken };
+  return { server, url };
 }
 
 async function routeRequest(
   req: http.IncomingMessage,
   res: http.ServerResponse,
-  sessionToken: string,
   state: AdminUiState,
   actions: UiActions,
   jobs: Map<string, UiJob>
@@ -91,8 +88,8 @@ async function routeRequest(
     res.end();
     return;
   }
-  if (!isValidSession(req, sessionToken)) {
-    sendJson(res, 401, { error: "invalid UI session" });
+  if (parsed.pathname.startsWith("/api/") && !isValidUiOrigin(req)) {
+    sendJson(res, 403, { error: "invalid UI origin" });
     return;
   }
 
@@ -252,8 +249,25 @@ function pruneJobs(jobs: Map<string, UiJob>): void {
   }
 }
 
-function isValidSession(req: http.IncomingMessage, sessionToken: string): boolean {
-  return req.headers["x-tokenbuddy-ui-session"] === sessionToken;
+function isValidUiOrigin(req: http.IncomingMessage): boolean {
+  const origin = headerValue(req.headers.origin);
+  if (!origin) {
+    return true;
+  }
+  const host = headerValue(req.headers.host);
+  if (!host) {
+    return false;
+  }
+  try {
+    const parsed = new URL(origin);
+    return parsed.protocol === "http:" && parsed.host === host;
+  } catch {
+    return false;
+  }
+}
+
+function headerValue(value: string | string[] | undefined): string | undefined {
+  return Array.isArray(value) ? value[0] : value;
 }
 
 function sendHtml(res: http.ServerResponse, html: string): void {

package/src/ui-state.ts

@@ -23,7 +23,8 @@ export interface SellerRow {
   region?: string;
   upstreamDomain: string;
   upstreamStatus: UpstreamStatus;
-  upstreamBalance?: string;
+  upstreamBalanceUsdMicros?: number;
+  upstreamBalanceCurrency?: string;
   upstreamBalanceSource?: string;
   upstreamBalanceFetchedAt?: string;
   upstreamBalanceError?: string;
@@ -34,7 +35,10 @@ export interface SellerRow {
   ttftMs?: number;
   avgInferenceMs?: number;
   lastInferenceMs?: number;
+  avgTokensPerSecond?: number;
+  lastTokensPerSecond?: number;
   latencySamples?: number;
+  lastSwitchAt?: string;
   modelsCount?: number;
   specs?: {
     memoryGb?: number;
@@ -52,6 +56,7 @@ export interface SellerModelRow {
   outputPrice?: string;
   ttftMs?: number;
   avgInferenceMs?: number;
+  avgTokensPerSecond?: number;
   latencySamples?: number;
 }
 
@@ -126,6 +131,7 @@ export interface AdminUiStateOptions {
 interface ProfileMatch {
   name?: string;
   profile?: AdminProfile;
+  localProfile?: boolean;
 }
 
 interface SellerSnapshot {
@@ -232,7 +238,7 @@ export class AdminUiState {
         upstreamUrl: stringValue(config.upstreamUrl || upstreams.upstreamUrl),
         upstreamApiKeyMasked: maskApiKey(config.upstreamApiKey || upstreams.upstreamApiKey),
         upstreamStatus: snapshot.row.upstreamStatus,
-        upstreamBalance: snapshot.row.upstreamBalance,
+        upstreamBalance: balanceString(snapshot.balance),
         upstreamBalanceSource: snapshot.row.upstreamBalanceSource,
         upstreamBalanceFetchedAt: snapshot.row.upstreamBalanceFetchedAt,
         upstreamBalanceError: snapshot.row.upstreamBalanceError,
@@ -262,9 +268,8 @@ export class AdminUiState {
     if (!match.profile) {
       throw new Error(`seller \`${entry.id}\` has no matching local admin profile`);
     }
-    const client = new AdminClient(match.profile.url, match.profile.token);
-    const response = await client.get("/operator/admin/config");
-    return { entry, profileName: match.name, config: response.config || response };
+    const response = await this.fetchSellerAdminJson(match.profile, "/operator/admin/config");
+    return { entry, profileName: match.localProfile ? match.name : undefined, config: response.config || response };
   }
 
   public async fetchRegistry(): Promise<SellerRegistryDocument> {
@@ -286,25 +291,27 @@ export class AdminUiState {
     if (this.options.url) {
       return {
         name: target,
-        profile: this.options.token ? { url: this.options.url, token: this.options.token } : undefined
+        profile: this.options.token ? { url: this.options.url, token: this.options.token } : undefined,
+        localProfile: false
       };
     }
     const config = this.configManager.load();
     const name = target || config.default_profile || Object.keys(config.profiles)[0];
     return {
       name,
-      profile: name ? config.profiles[name] : undefined
+      profile: name ? config.profiles[name] : undefined,
+      localProfile: Boolean(name && config.profiles[name])
     };
   }
 
   private matchSellerProfile(entry: SellerRegistryEntry): ProfileMatch {
     const config = this.configManager.load();
     if (entry.profile && config.profiles[entry.profile]) {
-      return { name: entry.profile, profile: config.profiles[entry.profile] };
+      return { name: entry.profile, profile: config.profiles[entry.profile], localProfile: true };
     }
     const byUrl = Object.entries(config.profiles).find(([, profile]) => trimSlash(profile.url) === trimSlash(entry.url));
     if (byUrl) {
-      return { name: byUrl[0], profile: byUrl[1] };
+      return { name: byUrl[0], profile: byUrl[1], localProfile: true };
     }
     const entryHost = hostName(entry.url);
     const near = Object.entries(config.profiles).find(([name, profile]) => {
@@ -312,7 +319,18 @@ export class AdminUiState {
       return [entry.id, entry.app, entryHost].some((value) => value && haystack.includes(value.toLowerCase()));
     });
     if (near) {
-      return { name: near[0], profile: near[1] };
+      return { name: near[0], profile: near[1], localProfile: true };
+    }
+    const provider = this.configManager.getSellerProvider("fly");
+    if (provider?.operator_secret) {
+      return {
+        name: entry.app || entry.id,
+        profile: {
+          url: entry.url,
+          token: provider.operator_secret
+        },
+        localProfile: false
+      };
     }
     return {};
   }
@@ -330,13 +348,12 @@ export class AdminUiState {
       };
     }
 
-    const client = new AdminClient(match.profile.url, match.profile.token);
     try {
       const [status, service, upstreams, config] = await Promise.all([
-        client.get("/operator/status").catch((err: any) => ({ error: err.message })),
-        client.get("/operator/admin/service").catch((err: any) => ({ error: err.message })),
-        client.get("/operator/admin/upstreams").catch((err: any) => ({ error: err.message })),
-        client.get("/operator/admin/config").catch((err: any) => ({ error: err.message }))
+        this.fetchSellerAdminJson(match.profile, "/operator/status").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/service").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/upstreams").catch((err: any) => ({ error: err.message })),
+        this.fetchSellerAdminJson(match.profile, "/operator/admin/config").catch((err: any) => ({ error: err.message }))
       ]);
       const configDocument = config?.config || config || {};
       const balance = await this.balanceSnapshot(configDocument, upstreams);
@@ -359,6 +376,15 @@ export class AdminUiState {
     }
   }
 
+  private async fetchSellerAdminJson(profile: AdminProfile, pathName: string): Promise<any> {
+    return this.fetchJson(`${trimSlash(profile.url)}${pathName}`, {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${profile.token}`
+      }
+    });
+  }
+
   private async balanceSnapshot(config: any, upstreams: any): Promise<BalanceSnapshot | undefined> {
     if (config?.error) {
       return undefined;
@@ -419,40 +445,45 @@ function mergeSellerRow(
   config: any,
   balance: BalanceSnapshot | undefined
 ): SellerRow {
+  const normalizedUpstreams = upstreamDocument(upstreams);
   const capacity = status?.capacity || service?.capacity || {};
-  const upstreamUrl = stringValue(config?.upstreamUrl || upstreams?.upstreamUrl || service?.upstreamUrl) || entry.url;
+  const upstreamUrl = stringValue(config?.upstreamUrl || normalizedUpstreams?.upstreamUrl || service?.upstreamUrl) || entry.url;
   const error = firstError(status, service, upstreams);
   return {
     ...base,
     nodeStatus: error ? "unknown" : nodeStatus(status?.status || entry.status),
     upstreamDomain: hostName(upstreamUrl) || base.upstreamDomain,
-    upstreamStatus: upstreamStatus(status?.upstream?.status || upstreams?.status),
-    discountRatio: numberValue(config?.discountRatio ?? upstreams?.discountRatio),
+    upstreamStatus: upstreamStatus(status?.upstream?.status || normalizedUpstreams?.status),
+    discountRatio: numberValue(config?.discountRatio ?? normalizedUpstreams?.discountRatio),
     capacityUsed: numberValue(capacity.activeConnections),
     capacityLimit: numberValue(capacity.maxConnections),
     ttftMs: numberValue(status?.latency?.ttftMs),
     avgInferenceMs: numberValue(status?.latency?.avgInferenceMs),
     lastInferenceMs: numberValue(status?.latency?.lastInferenceMs),
+    avgTokensPerSecond: numberValue(status?.latency?.avgTokensPerSecond),
+    lastTokensPerSecond: numberValue(status?.latency?.lastTokensPerSecond),
     latencySamples: numberValue(status?.latency?.sampleCount),
-    upstreamBalance: balanceString(balance),
+    upstreamBalanceUsdMicros: balance && Number.isFinite(balance.amountUsdMicros ?? NaN) ? (balance.amountUsdMicros as number) : undefined,
+    upstreamBalanceCurrency: typeof balance?.currency === "string" ? balance.currency : undefined,
     upstreamBalanceSource: balance?.source,
     upstreamBalanceFetchedAt: balance ? new Date(balance.fetchedAt).toISOString() : undefined,
     upstreamBalanceError: balance?.error?.message,
-    upstreamRechargeUrl: stringValue(config?.upstreamBalanceProbe?.rechargeUrl || config?.upstreamRechargeUrl || upstreams?.upstreamRechargeUrl),
-    modelsCount: numberValue(service?.modelsCount ?? upstreams?.models?.length ?? base.modelsCount),
+    upstreamRechargeUrl: stringValue(config?.upstreamBalanceProbe?.rechargeUrl || config?.upstreamRechargeUrl || normalizedUpstreams?.upstreamRechargeUrl),
+    modelsCount: numberValue(service?.modelsCount ?? normalizedUpstreams?.models?.length ?? base.modelsCount),
     specs: {
       ...base.specs,
       region: entry.region,
-      modelsCount: numberValue(service?.modelsCount ?? upstreams?.models?.length ?? base.modelsCount)
+      modelsCount: numberValue(service?.modelsCount ?? normalizedUpstreams?.models?.length ?? base.modelsCount)
     },
     error
   };
 }
 
 function modelRows(upstreams: any, config: any, status: any): SellerModelRow[] {
-  const aliases = config.modelAliases || upstreams.modelAliases || {};
-  const models = Array.isArray(upstreams.models)
-    ? upstreams.models
+  const normalizedUpstreams = upstreamDocument(upstreams);
+  const aliases = config.modelAliases || normalizedUpstreams.modelAliases || {};
+  const models = Array.isArray(normalizedUpstreams.models)
+    ? normalizedUpstreams.models
     : Array.isArray(config.models)
       ? config.models
       : [];
@@ -465,11 +496,19 @@ function modelRows(upstreams: any, config: any, status: any): SellerModelRow[] {
       outputPrice: priceString(model.outputPriceMicrosPer1m),
       ttftMs: numberValue(model.ttftMs ?? status?.latency?.ttftMs),
       avgInferenceMs: numberValue(model.avgInferenceMs ?? status?.latency?.avgInferenceMs),
+      avgTokensPerSecond: numberValue(model.avgTokensPerSecond ?? status?.latency?.avgTokensPerSecond),
       latencySamples: numberValue(model.latencySamples ?? status?.latency?.sampleCount)
     };
   });
 }
 
+function upstreamDocument(value: any): any {
+  if (Array.isArray(value?.upstreams)) {
+    return objectValue(value.upstreams[0]) || {};
+  }
+  return objectValue(value?.upstreams) || value || {};
+}
+
 function registryStatus(value: unknown): RegistryStatus {
   const normalized = String(value || "unknown").toLowerCase();
   if (normalized === "active" || normalized === "draining" || normalized === "offline" || normalized === "pending") {