@tokenbuddy/tokenbuddy 1.0.4 → 1.0.6

package/src/doctor-diagnostics.ts

@@ -0,0 +1,850 @@
+import { BuyerStore } from "./buyer-store.js";
+import Table from "cli-table3";
+import {
+  detectProviders,
+  PROXY_ACCESS_TOKEN_PLACEHOLDER,
+  SUPPORTED_PROVIDER_IDS,
+  type ProviderCandidate,
+  type ProviderId,
+  type ProviderRuntimeConfig,
+} from "./provider-install.js";
+import {
+  discoverSellerBackedModels,
+  type ModelCatalogEntry,
+  type SellerCatalogEntry,
+} from "./seller-catalog.js";
+
+export interface DoctorProviderView extends ProviderCandidate {
+  runtimeConfig?: ProviderRuntimeConfig;
+  runtimeConfigUpdatedAt?: string;
+}
+
+export interface DoctorSellerEntry {
+  id: string;
+  name?: string;
+  url: string;
+  status: string;
+  discountRatio?: number;
+  supportedProtocols?: string[];
+  paymentMethods?: string[];
+  manifestSellerId?: string;
+  modelCount?: number;
+  errorMessage?: string;
+}
+
+export interface DoctorDiagnostics {
+  access: DoctorAccessSummary;
+  models: DoctorModelsSummary;
+  providers: DoctorProviderView[];
+  sellers: DoctorSellersSummary;
+}
+
+interface RemoteJsonResult<T> {
+  url: string;
+  available: boolean;
+  statusCode?: number;
+  data?: T;
+  error?: string;
+}
+
+interface DoctorEndpointStatus {
+  id: string;
+  name: string;
+  url: string;
+  probeUrl?: string;
+  available: boolean;
+  requiresToken: boolean;
+  token?: string;
+  error?: string;
+}
+
+interface DoctorSellerResponse {
+  registryUrl?: string;
+  version?: number;
+  defaultSeller?: string;
+  sellers: DoctorSellerEntry[];
+}
+
+interface DoctorRegistryDocument {
+  version?: number;
+  defaultSeller?: string;
+  sellers: Array<{
+    id: string;
+    name?: string;
+    url: string;
+    supportedProtocols?: string[];
+    paymentMethods?: string[];
+  }>;
+}
+
+interface DoctorModelsResponse {
+  object?: string;
+  registryUrl?: string;
+  data: ModelCatalogEntry[];
+  sellers?: DoctorSellerEntry[];
+}
+
+export interface DoctorModelSummaryEntry {
+  id: string;
+  sellerCount: number;
+  discountMin?: number;
+  discountMax?: number;
+  discountRange: string;
+  inputPriceMinMicrosPer1m?: number;
+  inputPriceMaxMicrosPer1m?: number;
+  outputPriceMinMicrosPer1m?: number;
+  outputPriceMaxMicrosPer1m?: number;
+  priceRange: string;
+}
+
+interface DoctorFetchResults {
+  healthResult: RemoteJsonResult<Record<string, unknown>>;
+  sellersResult: RemoteJsonResult<DoctorSellerResponse>;
+  modelsResult: RemoteJsonResult<DoctorModelsResponse>;
+  proxyModelsResult: RemoteJsonResult<{ object?: string; data?: Array<{ id?: string }> }>;
+  registryResult: RemoteJsonResult<DoctorRegistryDocument>;
+}
+
+interface DoctorFetchPromises {
+  healthResult: Promise<RemoteJsonResult<Record<string, unknown>>>;
+  sellersResult: Promise<RemoteJsonResult<DoctorSellerResponse>>;
+  modelsResult: Promise<RemoteJsonResult<DoctorModelsResponse>>;
+  proxyModelsResult: Promise<RemoteJsonResult<{ object?: string; data?: Array<{ id?: string }> }>>;
+  registryResult: Promise<RemoteJsonResult<DoctorRegistryDocument>>;
+}
+
+interface DoctorAccessAvailability {
+  sellersAvailable?: boolean;
+  sellersError?: string;
+  modelsAvailable?: boolean;
+  modelsError?: string;
+}
+
+interface DoctorRenderOptions {
+  controlPort: number;
+  proxyPort: number;
+  daemonRunning: boolean;
+  daemonError?: string;
+  sellerRegistryUrl?: string;
+  providers: DoctorProviderView[];
+  writeLine?: (line: string) => void;
+}
+
+interface DoctorCollectOptions {
+  controlPort: number;
+  proxyPort: number;
+  daemonRunning: boolean;
+  daemonError?: string;
+  sellerRegistryUrl?: string;
+  providers: DoctorProviderView[];
+}
+
+type DoctorAccessSummary = {
+  controlBaseUrl: string;
+  proxyBaseUrl: string;
+  openAiBaseUrl: string;
+  anthropicBaseUrl: string;
+  token: string;
+  endpoints: DoctorEndpointStatus[];
+};
+
+type DoctorSellersSummary = {
+  available: boolean;
+  registryUrl?: string;
+  version?: number;
+  defaultSeller?: string;
+  sellers: DoctorSellerEntry[];
+  error?: string;
+};
+
+export type DoctorModelsSummary = {
+  available: boolean;
+  count: number;
+  uniqueCount: number;
+  registryUrl?: string;
+  data: ModelCatalogEntry[];
+  grouped: DoctorModelSummaryEntry[];
+  sellers: DoctorSellerEntry[];
+  error?: string;
+};
+
+function parseJsonText(text: string): unknown {
+  if (!text.trim()) {
+    return undefined;
+  }
+  return JSON.parse(text) as unknown;
+}
+
+function extractRemoteError(payload: unknown, fallback: string): string {
+  if (payload && typeof payload === "object") {
+    if ("error" in payload) {
+      const error = (payload as { error?: unknown }).error;
+      if (typeof error === "string" && error.trim()) {
+        return error;
+      }
+      if (error && typeof error === "object" && "message" in error && typeof error.message === "string" && error.message.trim()) {
+        return error.message;
+      }
+    }
+    if ("message" in payload && typeof (payload as { message?: unknown }).message === "string" && (payload as { message: string }).message.trim()) {
+      return (payload as { message: string }).message;
+    }
+  }
+  return fallback;
+}
+
+async function fetchJsonDocument<T>(url: string): Promise<RemoteJsonResult<T>> {
+  try {
+    const response = await fetch(url);
+    const text = await response.text();
+    const payload = text ? parseJsonText(text) : undefined;
+    if (!response.ok) {
+      return {
+        url,
+        available: false,
+        statusCode: response.status,
+        error: extractRemoteError(payload, `HTTP ${response.status}`),
+      };
+    }
+    return {
+      url,
+      available: true,
+      statusCode: response.status,
+      data: payload as T,
+    };
+  } catch (error: unknown) {
+    return {
+      url,
+      available: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function providerRuntimeSummary(runtimeConfig?: ProviderRuntimeConfig): string | undefined {
+  if (!runtimeConfig) {
+    return undefined;
+  }
+  if (runtimeConfig.selectionKind === "single-model") {
+    return [
+      runtimeConfig.protocolPreference,
+      runtimeConfig.defaultModel,
+      runtimeConfig.sellerId ? `seller=${runtimeConfig.sellerId}` : undefined,
+    ].filter(Boolean).join(" · ");
+  }
+
+  const bindings = [
+    runtimeConfig.roles.haiku?.upstreamModel ? `haiku=${runtimeConfig.roles.haiku.upstreamModel}` : undefined,
+    runtimeConfig.roles.sonnet?.upstreamModel ? `sonnet=${runtimeConfig.roles.sonnet.upstreamModel}` : undefined,
+    runtimeConfig.roles.opus?.upstreamModel ? `opus=${runtimeConfig.roles.opus.upstreamModel}` : undefined,
+    runtimeConfig.fallbackModel ? `fallback=${runtimeConfig.fallbackModel}` : undefined,
+  ].filter(Boolean);
+  return [runtimeConfig.protocolPreference, ...bindings].join(" · ");
+}
+
+function mergeDoctorSellerEntries(
+  configuredSellers: DoctorSellerEntry[],
+  probedSellers: DoctorSellerEntry[],
+): DoctorSellerEntry[] {
+  const configuredById = new Map(configuredSellers.map((seller) => [seller.id, seller]));
+  const merged: DoctorSellerEntry[] = [];
+
+  for (const seller of probedSellers) {
+    const configured = configuredById.get(seller.id);
+    merged.push({
+      ...configured,
+      ...seller,
+      discountRatio: seller.discountRatio ?? configured?.discountRatio,
+      supportedProtocols: seller.supportedProtocols || configured?.supportedProtocols,
+      paymentMethods: seller.paymentMethods || configured?.paymentMethods,
+      modelCount: seller.modelCount ?? configured?.modelCount,
+      errorMessage: seller.errorMessage || configured?.errorMessage,
+    });
+    configuredById.delete(seller.id);
+  }
+
+  for (const seller of configuredById.values()) {
+    merged.push(seller);
+  }
+
+  return merged;
+}
+
+function registrySellersToDoctorEntries(registry?: DoctorRegistryDocument): DoctorSellerEntry[] {
+  if (!registry?.sellers) {
+    return [];
+  }
+  return registry.sellers.map((seller) => ({
+    id: seller.id,
+    name: seller.name,
+    url: seller.url,
+    status: "configured",
+    supportedProtocols: seller.supportedProtocols || [],
+    paymentMethods: seller.paymentMethods || [],
+  }));
+}
+
+function sellerCatalogEntriesToDoctorEntries(sellers: SellerCatalogEntry[]): DoctorSellerEntry[] {
+  return sellers.map((seller) => ({
+    id: seller.id,
+    name: seller.name,
+    url: seller.url,
+    status: seller.status,
+    discountRatio: seller.discountRatio,
+    supportedProtocols: seller.supportedProtocols,
+    paymentMethods: seller.paymentMethods,
+    manifestSellerId: seller.manifestSellerId,
+    modelCount: seller.modelCount,
+    errorMessage: seller.errorMessage,
+  }));
+}
+
+function discountRatioFromSeller(seller: DoctorSellerEntry): number | undefined {
+  if (typeof seller.discountRatio === "number") {
+    return seller.discountRatio;
+  }
+  const match = seller.name?.match(/([0-9]+(?:\.[0-9]+)?)\s+discount/i);
+  if (!match) {
+    return undefined;
+  }
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function formatDiscountRatio(value: number): string {
+  return value.toFixed(2).replace(/\.?0+$/, "");
+}
+
+function formatUsdPer1m(microsPer1m: number): string {
+  const usd = microsPer1m / 1_000_000;
+  return `$${usd.toFixed(2).replace(/\.?0+$/, "")}`;
+}
+
+function formatPriceRange(minMicros?: number, maxMicros?: number): string {
+  if (minMicros == null || maxMicros == null) {
+    return "-";
+  }
+  if (minMicros === maxMicros) {
+    return formatUsdPer1m(minMicros);
+  }
+  return `${formatUsdPer1m(minMicros)}~${formatUsdPer1m(maxMicros)}`;
+}
+
+function modelsHaveExplicitPriceData(models: ModelCatalogEntry[]): boolean {
+  return models.some((model) =>
+    typeof model.inputPriceMicrosPer1m === "number" ||
+    typeof model.outputPriceMicrosPer1m === "number"
+  );
+}
+
+function buildDoctorModelSummaryEntries(
+  models: ModelCatalogEntry[],
+  sellers: DoctorSellerEntry[],
+): DoctorModelSummaryEntry[] {
+  const grouped = new Map<string, {
+    sellerIds: Set<string>;
+    discounts: number[];
+    inputPrices: number[];
+    outputPrices: number[];
+  }>();
+  const discountBySellerId = new Map(
+    sellers
+      .map((seller) => [seller.id, discountRatioFromSeller(seller)] as const)
+      .filter((entry): entry is readonly [string, number] => typeof entry[1] === "number")
+  );
+
+  for (const model of models) {
+    const entry = grouped.get(model.id) || {
+      sellerIds: new Set<string>(),
+      discounts: [],
+      inputPrices: [],
+      outputPrices: [],
+    };
+    if (!entry.sellerIds.has(model.sellerId)) {
+      entry.sellerIds.add(model.sellerId);
+      const discount = discountBySellerId.get(model.sellerId);
+      if (typeof discount === "number") {
+        entry.discounts.push(discount);
+      }
+      if (typeof model.inputPriceMicrosPer1m === "number") {
+        entry.inputPrices.push(model.inputPriceMicrosPer1m);
+      }
+      if (typeof model.outputPriceMicrosPer1m === "number") {
+        entry.outputPrices.push(model.outputPriceMicrosPer1m);
+      }
+    }
+    grouped.set(model.id, entry);
+  }
+
+  return Array.from(grouped.entries())
+    .map(([id, entry]) => {
+      const discountMin = entry.discounts.length > 0 ? Math.min(...entry.discounts) : undefined;
+      const discountMax = entry.discounts.length > 0 ? Math.max(...entry.discounts) : undefined;
+      const inputPriceMinMicrosPer1m = entry.inputPrices.length > 0 ? Math.min(...entry.inputPrices) : undefined;
+      const inputPriceMaxMicrosPer1m = entry.inputPrices.length > 0 ? Math.max(...entry.inputPrices) : undefined;
+      const outputPriceMinMicrosPer1m = entry.outputPrices.length > 0 ? Math.min(...entry.outputPrices) : undefined;
+      const outputPriceMaxMicrosPer1m = entry.outputPrices.length > 0 ? Math.max(...entry.outputPrices) : undefined;
+      const discountRange = discountMin == null || discountMax == null
+        ? "-"
+        : discountMin === discountMax
+          ? formatDiscountRatio(discountMin)
+          : `${formatDiscountRatio(discountMin)}~${formatDiscountRatio(discountMax)}`;
+      const priceRange = inputPriceMinMicrosPer1m == null || outputPriceMinMicrosPer1m == null
+        ? "-"
+        : `in ${formatPriceRange(inputPriceMinMicrosPer1m, inputPriceMaxMicrosPer1m)} / out ${formatPriceRange(outputPriceMinMicrosPer1m, outputPriceMaxMicrosPer1m)}`;
+      return {
+        id,
+        sellerCount: entry.sellerIds.size,
+        discountMin,
+        discountMax,
+        discountRange,
+        inputPriceMinMicrosPer1m,
+        inputPriceMaxMicrosPer1m,
+        outputPriceMinMicrosPer1m,
+        outputPriceMaxMicrosPer1m,
+        priceRange,
+      };
+    })
+    .sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function startDoctorFetches(
+  controlPort: number,
+  proxyPort: number,
+  daemonRunning: boolean,
+  daemonError: string | undefined,
+  sellerRegistryUrl?: string,
+): DoctorFetchPromises {
+  const controlBaseUrl = `http://127.0.0.1:${controlPort}`;
+  const openAiBaseUrl = `http://127.0.0.1:${proxyPort}/v1`;
+  const unavailableMessage = daemonError || "tb-proxyd is not running";
+
+  if (!daemonRunning) {
+    return {
+      healthResult: Promise.resolve({ url: `${controlBaseUrl}/health`, available: false, error: unavailableMessage }),
+      sellersResult: Promise.resolve({ url: `${controlBaseUrl}/sellers`, available: false, error: unavailableMessage }),
+      modelsResult: Promise.resolve({ url: `${controlBaseUrl}/models`, available: false, error: unavailableMessage }),
+      proxyModelsResult: Promise.resolve({ url: `${openAiBaseUrl}/models`, available: false, error: unavailableMessage }),
+      registryResult: Promise.resolve({ url: sellerRegistryUrl || "", available: false, error: unavailableMessage }),
+    };
+  }
+
+  return {
+    healthResult: fetchJsonDocument<Record<string, unknown>>(`${controlBaseUrl}/health`),
+    sellersResult: fetchJsonDocument<DoctorSellerResponse>(`${controlBaseUrl}/sellers`),
+    modelsResult: fetchJsonDocument<DoctorModelsResponse>(`${controlBaseUrl}/models`),
+    proxyModelsResult: fetchJsonDocument<{ object?: string; data?: Array<{ id?: string }> }>(`${openAiBaseUrl}/models`),
+    registryResult: sellerRegistryUrl
+      ? fetchJsonDocument<DoctorRegistryDocument>(sellerRegistryUrl)
+      : Promise.resolve({ url: "", available: false, error: "registry url unavailable" }),
+  };
+}
+
+async function resolveDoctorFetches(fetches: DoctorFetchPromises): Promise<DoctorFetchResults> {
+  const [
+    healthResult,
+    sellersResult,
+    modelsResult,
+    proxyModelsResult,
+    registryResult,
+  ] = await Promise.all([
+    fetches.healthResult,
+    fetches.sellersResult,
+    fetches.modelsResult,
+    fetches.proxyModelsResult,
+    fetches.registryResult,
+  ]);
+  return {
+    healthResult,
+    sellersResult,
+    modelsResult,
+    proxyModelsResult,
+    registryResult,
+  };
+}
+
+function buildDoctorSellerSummary(
+  sellersResult: RemoteJsonResult<DoctorSellerResponse>,
+  registryResult: RemoteJsonResult<DoctorRegistryDocument>,
+  sellerRegistryUrl?: string,
+  probedSellers: DoctorSellerEntry[] = [],
+): DoctorSellersSummary {
+  const sellersData = sellersResult.data;
+  const configuredSellers = mergeDoctorSellerEntries(
+    registrySellersToDoctorEntries(registryResult.data),
+    sellersData?.sellers || [],
+  );
+  const mergedSellers = probedSellers.length > 0
+    ? mergeDoctorSellerEntries(configuredSellers, probedSellers)
+    : configuredSellers;
+
+  return {
+    available: sellersResult.available || registryResult.available || mergedSellers.length > 0,
+    registryUrl: sellersData?.registryUrl || sellerRegistryUrl,
+    version: sellersData?.version || registryResult.data?.version,
+    defaultSeller: sellersData?.defaultSeller || registryResult.data?.defaultSeller,
+    sellers: mergedSellers,
+    error: sellersResult.error || registryResult.error,
+  };
+}
+
+function buildDoctorAccessSummary(
+  controlPort: number,
+  proxyPort: number,
+  healthResult: RemoteJsonResult<Record<string, unknown>>,
+  proxyModelsResult: RemoteJsonResult<{ object?: string; data?: Array<{ id?: string }> }>,
+  availability: DoctorAccessAvailability = {},
+): DoctorAccessSummary {
+  const controlBaseUrl = `http://127.0.0.1:${controlPort}`;
+  const proxyBaseUrl = `http://127.0.0.1:${proxyPort}`;
+  const openAiBaseUrl = `${proxyBaseUrl}/v1`;
+  const anthropicBaseUrl = proxyBaseUrl;
+
+  return {
+    controlBaseUrl,
+    proxyBaseUrl,
+    openAiBaseUrl,
+    anthropicBaseUrl,
+    token: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+    endpoints: [
+      {
+        id: "control.health",
+        name: "Control Plane Health",
+        url: `${controlBaseUrl}/health`,
+        available: healthResult.available,
+        requiresToken: false,
+        error: healthResult.error,
+      },
+      {
+        id: "control.sellers",
+        name: "Seller Registry",
+        url: `${controlBaseUrl}/sellers`,
+        available: availability.sellersAvailable ?? true,
+        requiresToken: false,
+        error: availability.sellersError,
+      },
+      {
+        id: "control.models",
+        name: "Seller-backed Models",
+        url: `${controlBaseUrl}/models`,
+        available: availability.modelsAvailable ?? true,
+        requiresToken: false,
+        error: availability.modelsError,
+      },
+      {
+        id: "proxy.openai",
+        name: "OpenAI-compatible Proxy",
+        url: openAiBaseUrl,
+        probeUrl: `${openAiBaseUrl}/models`,
+        available: proxyModelsResult.available,
+        requiresToken: true,
+        token: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+        error: proxyModelsResult.error,
+      },
+      {
+        id: "proxy.anthropic",
+        name: "Anthropic-compatible Proxy",
+        url: anthropicBaseUrl,
+        probeUrl: `${openAiBaseUrl}/models`,
+        available: proxyModelsResult.available,
+        requiresToken: true,
+        token: PROXY_ACCESS_TOKEN_PLACEHOLDER,
+        error: proxyModelsResult.error,
+      },
+    ],
+  };
+}
+
+function buildDoctorModelsSummary(
+  modelsResult: RemoteJsonResult<DoctorModelsResponse>,
+  sellers: DoctorSellerEntry[],
+): DoctorModelsSummary {
+  const modelsData = modelsResult.data;
+  const grouped = buildDoctorModelSummaryEntries(modelsData?.data || [], sellers);
+  return {
+    available: modelsResult.available,
+    count: modelsData?.data?.length || 0,
+    uniqueCount: grouped.length,
+    registryUrl: modelsData?.registryUrl,
+    data: modelsData?.data || [],
+    grouped,
+    sellers,
+    error: modelsResult.error,
+  };
+}
+
+function providerStatusIcon(status: DoctorProviderView["status"]): string {
+  if (status === "configured") {
+    return "✅";
+  }
+  if (status === "installed") {
+    return "🟡";
+  }
+  return "🔘";
+}
+
+function remoteStatusIcon(available: boolean): string {
+  return available ? "✅" : "❌";
+}
+
+function formatList(values?: string[]): string {
+  return values && values.length > 0 ? values.join(", ") : "-";
+}
+
+function defaultWriter(line: string): void {
+  console.log(line);
+}
+
+function printDoctorAccess(access: DoctorAccessSummary, writeLine: (line: string) => void): void {
+  writeLine("Access check complete.");
+  writeLine(`Proxy token: ${access.token}`);
+  for (const endpoint of access.endpoints) {
+    writeLine(`${remoteStatusIcon(endpoint.available)} ${endpoint.name}`);
+    writeLine(`   URL: ${endpoint.url}`);
+    if (endpoint.probeUrl) {
+      writeLine(`   Probe: ${endpoint.probeUrl}`);
+    }
+    if (endpoint.requiresToken && endpoint.token) {
+      writeLine(`   Token: ${endpoint.token}`);
+    }
+    if (!endpoint.available && endpoint.error) {
+      writeLine(`   Error: ${endpoint.error}`);
+    }
+  }
+}
+
+function printDoctorSellers(sellers: DoctorSellersSummary, writeLine: (line: string) => void): void {
+  writeLine("Seller registry refresh complete.");
+  if (!sellers.available) {
+    writeLine(`❌ Seller registry unavailable: ${sellers.error || "unknown error"}`);
+    return;
+  }
+  writeLine(`Registry: ${sellers.registryUrl || "-"}`);
+  writeLine(`Default seller: ${sellers.defaultSeller || "-"}`);
+  for (const seller of sellers.sellers) {
+    const label = seller.name ? `${seller.name} (${seller.id})` : seller.id;
+    const icon = seller.status === "ok" || seller.status === "configured"
+      ? "✅"
+      : seller.status === "failed"
+        ? "❌"
+        : "🔘";
+    writeLine(`${icon} ${label} [${seller.status}]`);
+    writeLine(`   URL: ${seller.url}`);
+    writeLine(`   Protocols: ${formatList(seller.supportedProtocols)}`);
+    writeLine(`   Payments: ${formatList(seller.paymentMethods)}`);
+    if (seller.modelCount != null) {
+      writeLine(`   Models: ${seller.modelCount}`);
+    }
+    if (seller.errorMessage) {
+      writeLine(`   Error: ${seller.errorMessage}`);
+    }
+  }
+}
+
+export function printDoctorModelsSummary(
+  models: DoctorModelsSummary,
+  writeLine: (line: string) => void = defaultWriter,
+): void {
+  writeLine("Model catalog refresh complete.");
+  if (!models.available) {
+    writeLine(`❌ Model catalog unavailable: ${models.error || "unknown error"}`);
+    return;
+  }
+  writeLine(`Unique models: ${models.uniqueCount}`);
+  writeLine(`Seller offers: ${models.count}`);
+
+  const table = new Table({
+    head: ["Model ID", "Seller Count", "Discount Range", "Price Range"],
+    style: {
+      head: []
+    }
+  });
+  for (const entry of models.grouped) {
+    table.push([
+      entry.id,
+      String(entry.sellerCount),
+      entry.discountRange,
+      entry.priceRange
+    ]);
+  }
+  writeLine(table.toString());
+}
+
+export function readDoctorProviders(): DoctorProviderView[] {
+  const store = new BuyerStore();
+  try {
+    const runtimeConfigByProvider = new Map<ProviderId, { config: ProviderRuntimeConfig; updatedAt: string }>();
+    for (const providerId of SUPPORTED_PROVIDER_IDS) {
+      const record = store.getProviderRuntimeConfig<ProviderRuntimeConfig>(providerId);
+      if (record) {
+        runtimeConfigByProvider.set(providerId, {
+          config: record.config,
+          updatedAt: record.updatedAt,
+        });
+      }
+    }
+
+    return detectProviders().map((provider) => {
+      const runtime = runtimeConfigByProvider.get(provider.id);
+      return {
+        ...provider,
+        runtimeConfig: runtime?.config,
+        runtimeConfigUpdatedAt: runtime?.updatedAt,
+      };
+    });
+  } finally {
+    store.close();
+  }
+}
+
+export function printDoctorProviders(
+  providers: DoctorProviderView[],
+  writeLine: (line: string) => void = defaultWriter,
+): void {
+  writeLine("\n--- Programming Terminals ---");
+  for (const provider of providers) {
+    writeLine(`${providerStatusIcon(provider.status)} ${provider.name} [${provider.status}]`);
+    if (provider.commandName) {
+      writeLine(`   Command: ${provider.commandName}${provider.executablePath ? ` -> ${provider.executablePath}` : " (not found in PATH)"}`);
+    }
+    writeLine(`   Config: ${provider.configPath}`);
+    if (provider.observedPaths && provider.observedPaths.length > 0) {
+      writeLine(`   Native hints: ${provider.observedPaths.join(", ")}`);
+    }
+    const runtimeSummary = providerRuntimeSummary(provider.runtimeConfig);
+    if (runtimeSummary) {
+      writeLine(`   Runtime: ${runtimeSummary}`);
+    }
+    writeLine(`   Notes: ${provider.reason}`);
+  }
+}
+
+export async function collectDoctorDiagnostics(options: DoctorCollectOptions): Promise<DoctorDiagnostics> {
+  const fetches = startDoctorFetches(
+    options.controlPort,
+    options.proxyPort,
+    options.daemonRunning,
+    options.daemonError,
+    options.sellerRegistryUrl,
+  );
+  const results = await resolveDoctorFetches(fetches);
+  const sellers = buildDoctorSellerSummary(
+    results.sellersResult,
+    results.registryResult,
+    options.sellerRegistryUrl,
+    results.modelsResult.data?.sellers || [],
+  );
+  const models = buildDoctorModelsSummary(results.modelsResult, sellers.sellers);
+
+  return {
+    access: buildDoctorAccessSummary(
+      options.controlPort,
+      options.proxyPort,
+      results.healthResult,
+      results.proxyModelsResult,
+      {
+        sellersAvailable: sellers.available,
+        sellersError: sellers.error,
+        modelsAvailable: models.available,
+        modelsError: models.error,
+      },
+    ),
+    models,
+    providers: options.providers,
+    sellers,
+  };
+}
+
+export async function collectDoctorModelsSummary(options: Omit<DoctorCollectOptions, "providers">): Promise<DoctorModelsSummary> {
+  const diagnostics = await collectDoctorDiagnostics({
+    ...options,
+    providers: [],
+  });
+  if (modelsHaveExplicitPriceData(diagnostics.models.data) || !options.sellerRegistryUrl) {
+    return diagnostics.models;
+  }
+
+  try {
+    const catalog = await discoverSellerBackedModels(options.sellerRegistryUrl);
+    const sellers = sellerCatalogEntriesToDoctorEntries(catalog.sellers);
+    return buildDoctorModelsSummary({
+      url: options.sellerRegistryUrl,
+      available: true,
+      data: {
+        object: "list",
+        registryUrl: catalog.registryUrl,
+        data: catalog.models,
+      },
+    }, sellers);
+  } catch {
+    return diagnostics.models;
+  }
+
+}
+
+export async function renderDoctorDiagnosticsProgressively(options: DoctorRenderOptions): Promise<DoctorDiagnostics> {
+  const writeLine = options.writeLine || defaultWriter;
+  const fetches = startDoctorFetches(
+    options.controlPort,
+    options.proxyPort,
+    options.daemonRunning,
+    options.daemonError,
+    options.sellerRegistryUrl,
+  );
+
+  writeLine("\n--- Access Interfaces ---");
+  writeLine("Checking local control plane and proxy endpoints...");
+  const [healthResult, proxyModelsResult] = await Promise.all([
+    fetches.healthResult,
+    fetches.proxyModelsResult,
+  ]);
+  const access = buildDoctorAccessSummary(
+    options.controlPort,
+    options.proxyPort,
+    healthResult,
+    proxyModelsResult,
+  );
+  printDoctorAccess(access, writeLine);
+
+  writeLine("\n--- Sellers ---");
+  writeLine("Refreshing seller registry...");
+  const [sellersResult, registryResult] = await Promise.all([
+    fetches.sellersResult,
+    fetches.registryResult,
+  ]);
+  const partialSellers = buildDoctorSellerSummary(
+    sellersResult,
+    registryResult,
+    options.sellerRegistryUrl,
+  );
+  printDoctorSellers(partialSellers, writeLine);
+
+  const modelsResult = await fetches.modelsResult;
+  const finalSellers = buildDoctorSellerSummary(
+    sellersResult,
+    registryResult,
+    options.sellerRegistryUrl,
+    modelsResult.data?.sellers || [],
+  );
+  const models = buildDoctorModelsSummary(modelsResult, finalSellers.sellers);
+  access.endpoints = buildDoctorAccessSummary(
+    options.controlPort,
+    options.proxyPort,
+    healthResult,
+    proxyModelsResult,
+    {
+      sellersAvailable: finalSellers.available,
+      sellersError: finalSellers.error,
+      modelsAvailable: models.available,
+      modelsError: models.error,
+    },
+  ).endpoints;
+  writeLine("\nModel catalog hidden in `tb doctor`. Run `tb models` for the current model summary.");
+
+  return {
+    access,
+    models,
+    providers: options.providers,
+    sellers: finalSellers,
+  };
+}