@tokenbuddy/tokenbuddy 1.0.36 → 1.0.38

package/src/provider-routing-config.ts

@@ -1,410 +0,0 @@
-import type { SellerRoutingScorer } from "./seller-routing-strategy.js";
-
-export const PROVIDER_MODE_CONFIG_KEY = "provider-mode";
-export const MANUAL_PROVIDER_CONFIG_KEY = "manual-providers";
-export const AUTO_PROVIDER_CONFIG_KEY = "auto-provider";
-export const MANUAL_PROVIDER_OBSERVATIONS_CONFIG_KEY = "manual-provider-observations";
-
-export type ProviderMode = "manual" | "auto";
-export type ManualProviderKind = "openai-compatible";
-export type ProviderProtocol = "chat_completions" | "responses" | "messages" | "images_generations";
-export type AutoProviderRange = "recommended" | "custom";
-export type ManualProviderRoutingPolicy = "fallback" | "locked";
-
-export interface ProviderModeConfig {
-  mode: ProviderMode;
-  updatedAt: string;
-}
-
-export interface ManualProviderConfig {
-  id: string;
-  name: string;
-  kind: ManualProviderKind;
-  baseUrl: string;
-  apiKeyEnv?: string;
-  secretRef?: string;
-  models: string[];
-  supportedProtocols: ProviderProtocol[];
-  enabled: boolean;
-  notes?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface ManualProvidersConfig {
-  version: 1;
-  providers: ManualProviderConfig[];
-  routing: ManualProviderRoutingConfig;
-  updatedAt: string;
-}
-
-export interface ManualProviderRoutingConfig {
-  policy: ManualProviderRoutingPolicy;
-  lockedProviderId?: string;
-}
-
-export interface AutoProviderConfig {
-  enabled: boolean;
-  range: AutoProviderRange;
-  scorer: SellerRoutingScorer;
-  modelIds: string[];
-  sellerIds: string[];
-  maxConcurrentProviders: 10;
-  updatedAt: string;
-}
-
-export interface PublicManualProviderConfig extends Omit<ManualProviderConfig, "apiKeyEnv" | "secretRef"> {
-  keyRef?: {
-    kind: "env" | "secret";
-    name: string;
-    configured: boolean;
-  };
-  current?: boolean;
-  lastAccess?: string;
-  status?: "healthy" | "degraded" | "unhealthy" | "unknown";
-  errorClass?: string;
-  errorMessage?: string;
-  ttftMs?: number;
-  avgTokensPerSecond?: number;
-}
-
-export interface ManualProviderObservation {
-  providerId: string;
-  current: boolean;
-  lastAccess: string;
-  status: "healthy" | "degraded" | "unhealthy" | "unknown";
-  errorClass?: string;
-  errorMessage?: string;
-  ttftMs?: number;
-  avgTokensPerSecond?: number;
-}
-
-export interface ManualProviderObservationsConfig {
-  version: 1;
-  observations: ManualProviderObservation[];
-  updatedAt: string;
-}
-
-const VALID_PROTOCOLS = new Set<ProviderProtocol>(["chat_completions", "responses", "messages", "images_generations"]);
-const VALID_SCORERS = new Set<SellerRoutingScorer>(["balanced", "speed", "discount"]);
-
-export function defaultProviderModeConfig(now = new Date().toISOString()): ProviderModeConfig {
-  return {
-    mode: "manual",
-    updatedAt: now
-  };
-}
-
-export function normalizeProviderModeConfig(value: unknown, now = new Date().toISOString()): ProviderModeConfig {
-  if (!isRecord(value)) {
-    return defaultProviderModeConfig(now);
-  }
-  return {
-    mode: readProviderMode(value.mode),
-    updatedAt: readOptionalString(value.updatedAt) ?? now
-  };
-}
-
-export function normalizeManualProvidersConfig(value: unknown, now = new Date().toISOString()): ManualProvidersConfig {
-  if (!isRecord(value)) {
-    return {
-      version: 1,
-      providers: [],
-      routing: defaultManualProviderRoutingConfig(),
-      updatedAt: now
-    };
-  }
-  const providersValue = Array.isArray(value.providers) ? value.providers : [];
-  const seen = new Set<string>();
-  const providers = providersValue.map((providerValue) => {
-    const provider = normalizeManualProviderConfig(providerValue, { now });
-    if (seen.has(provider.id)) {
-      throw new Error(`manual provider id is duplicated: ${provider.id}`);
-    }
-    seen.add(provider.id);
-    return provider;
-  });
-  return {
-    version: 1,
-    providers,
-    routing: normalizeManualProviderRoutingConfig(value.routing),
-    updatedAt: readOptionalString(value.updatedAt) ?? now
-  };
-}
-
-export function defaultManualProviderRoutingConfig(): ManualProviderRoutingConfig {
-  return {
-    policy: "fallback"
-  };
-}
-
-export function normalizeManualProviderRoutingConfig(value: unknown): ManualProviderRoutingConfig {
-  if (!isRecord(value)) {
-    return defaultManualProviderRoutingConfig();
-  }
-  const policy = readManualProviderRoutingPolicy(value.policy);
-  const lockedProviderId = readOptionalString(value.lockedProviderId);
-  if (policy === "locked" && !lockedProviderId) {
-    throw new Error("manual provider locked routing requires lockedProviderId");
-  }
-  return {
-    policy,
-    lockedProviderId: policy === "locked" ? readProviderId(lockedProviderId) : undefined
-  };
-}
-
-export function normalizeManualProviderConfig(
-  value: unknown,
-  options: { now?: string; id?: string; existingIds?: ReadonlySet<string> } = {}
-): ManualProviderConfig {
-  if (!isRecord(value)) {
-    throw new Error("manual provider config must be an object");
-  }
-  if ("apiKey" in value) {
-    throw new Error("manual provider config must not contain a raw apiKey; use apiKeyEnv or secretRef");
-  }
-  const now = options.now ?? new Date().toISOString();
-  const id = readProviderId(options.id ?? value.id);
-  if (options.existingIds?.has(id)) {
-    throw new Error(`manual provider id is duplicated: ${id}`);
-  }
-  const apiKeyEnv = readOptionalString(value.apiKeyEnv);
-  const secretRef = readOptionalString(value.secretRef);
-  if (!apiKeyEnv && !secretRef) {
-    throw new Error("manual provider requires apiKeyEnv or secretRef");
-  }
-  if (apiKeyEnv && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(apiKeyEnv)) {
-    throw new Error("manual provider apiKeyEnv must be a valid environment variable name");
-  }
-
-  return {
-    id,
-    name: readRequiredString(value.name, "manual provider name"),
-    kind: readManualProviderKind(value.kind),
-    baseUrl: normalizeProviderBaseUrl(value.baseUrl),
-    apiKeyEnv,
-    secretRef,
-    models: readNonEmptyStringList(value.models, "manual provider models"),
-    supportedProtocols: readProtocols(value.supportedProtocols),
-    enabled: value.enabled === undefined ? true : value.enabled === true,
-    notes: readOptionalString(value.notes),
-    createdAt: readOptionalString(value.createdAt) ?? now,
-    updatedAt: now
-  };
-}
-
-export function normalizeAutoProviderConfig(value: unknown, now = new Date().toISOString()): AutoProviderConfig {
-  if (!isRecord(value)) {
-    return defaultAutoProviderConfig(now);
-  }
-  return {
-    enabled: value.enabled === true,
-    range: readAutoProviderRange(value.range),
-    scorer: readScorer(value.scorer),
-    modelIds: readStringList(value.modelIds),
-    sellerIds: readStringList(value.sellerIds),
-    maxConcurrentProviders: 10,
-    updatedAt: readOptionalString(value.updatedAt) ?? now
-  };
-}
-
-export function defaultAutoProviderConfig(now = new Date().toISOString()): AutoProviderConfig {
-  return {
-    enabled: false,
-    range: "recommended",
-    scorer: "balanced",
-    modelIds: [],
-    sellerIds: [],
-    maxConcurrentProviders: 10,
-    updatedAt: now
-  };
-}
-
-export function normalizeManualProviderObservationsConfig(
-  value: unknown,
-  now = new Date().toISOString()
-): ManualProviderObservationsConfig {
-  if (!isRecord(value)) {
-    return {
-      version: 1,
-      observations: [],
-      updatedAt: now
-    };
-  }
-  const observationsValue = Array.isArray(value.observations) ? value.observations : [];
-  const seen = new Set<string>();
-  const observations = observationsValue
-    .filter(isRecord)
-    .map((entry) => normalizeManualProviderObservation(entry, now))
-    .filter((entry) => {
-      if (seen.has(entry.providerId)) {
-        return false;
-      }
-      seen.add(entry.providerId);
-      return true;
-    });
-  return {
-    version: 1,
-    observations,
-    updatedAt: readOptionalString(value.updatedAt) ?? now
-  };
-}
-
-export function publicManualProviderConfig(
-  provider: ManualProviderConfig,
-  observation?: ManualProviderObservation,
-  env: NodeJS.ProcessEnv = process.env
-): PublicManualProviderConfig {
-  const keyRef = provider.apiKeyEnv
-    ? { kind: "env" as const, name: provider.apiKeyEnv, configured: Boolean(env[provider.apiKeyEnv]) }
-    : provider.secretRef
-      ? { kind: "secret" as const, name: provider.secretRef, configured: true }
-      : undefined;
-  const { apiKeyEnv: _apiKeyEnv, secretRef: _secretRef, ...publicProvider } = provider;
-  return {
-    ...publicProvider,
-    keyRef,
-    current: observation?.current,
-    lastAccess: observation?.lastAccess,
-    status: observation?.status,
-    errorClass: observation?.errorClass,
-    errorMessage: observation?.errorMessage,
-    ttftMs: observation?.ttftMs,
-    avgTokensPerSecond: observation?.avgTokensPerSecond
-  };
-}
-
-function normalizeManualProviderObservation(value: Record<string, unknown>, now: string): ManualProviderObservation {
-  return {
-    providerId: readRequiredString(value.providerId, "manual provider observation providerId"),
-    current: value.current === true,
-    lastAccess: readOptionalString(value.lastAccess) ?? now,
-    status: readObservationStatus(value.status),
-    errorClass: readOptionalString(value.errorClass),
-    errorMessage: readOptionalString(value.errorMessage),
-    ttftMs: readOptionalNumber(value.ttftMs),
-    avgTokensPerSecond: readOptionalNumber(value.avgTokensPerSecond)
-  };
-}
-
-function readObservationStatus(value: unknown): ManualProviderObservation["status"] {
-  if (value === "healthy" || value === "degraded" || value === "unhealthy" || value === "unknown") {
-    return value;
-  }
-  return "unknown";
-}
-
-function readProviderMode(value: unknown): ProviderMode {
-  if (value === "manual" || value === "auto") {
-    return value;
-  }
-  throw new Error("provider mode must be manual or auto");
-}
-
-function readManualProviderRoutingPolicy(value: unknown): ManualProviderRoutingPolicy {
-  if (value === undefined || value === null || value === "" || value === "fallback") {
-    return "fallback";
-  }
-  if (value === "locked") {
-    return "locked";
-  }
-  throw new Error("manual provider routing policy must be fallback or locked");
-}
-
-function readManualProviderKind(value: unknown): ManualProviderKind {
-  if (value === undefined || value === null || value === "" || value === "openai-compatible") {
-    return "openai-compatible";
-  }
-  throw new Error("manual provider kind must be openai-compatible");
-}
-
-function readAutoProviderRange(value: unknown): AutoProviderRange {
-  if (value === undefined || value === null || value === "" || value === "recommended") {
-    return "recommended";
-  }
-  if (value === "custom") {
-    return "custom";
-  }
-  throw new Error("auto provider range must be recommended or custom");
-}
-
-function readScorer(value: unknown): SellerRoutingScorer {
-  if (value === undefined || value === null || value === "") {
-    return "balanced";
-  }
-  if (typeof value === "string" && VALID_SCORERS.has(value as SellerRoutingScorer)) {
-    return value as SellerRoutingScorer;
-  }
-  throw new Error("auto provider scorer must be balanced, speed, or discount");
-}
-
-function readProtocols(value: unknown): ProviderProtocol[] {
-  const protocols = readStringList(value);
-  if (protocols.length === 0) {
-    return ["chat_completions"];
-  }
-  const invalid = protocols.find((protocol) => !VALID_PROTOCOLS.has(protocol as ProviderProtocol));
-  if (invalid) {
-    throw new Error(`manual provider protocol is invalid: ${invalid}`);
-  }
-  return protocols as ProviderProtocol[];
-}
-
-function normalizeProviderBaseUrl(value: unknown): string {
-  const raw = readRequiredString(value, "manual provider baseUrl");
-  let parsed: URL;
-  try {
-    parsed = new URL(raw);
-  } catch {
-    throw new Error("manual provider baseUrl must be a valid URL");
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error("manual provider baseUrl must use http or https");
-  }
-  return parsed.toString().replace(/\/+$/, "");
-}
-
-function readProviderId(value: unknown): string {
-  const id = readRequiredString(value, "manual provider id");
-  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{1,63}$/.test(id)) {
-    throw new Error("manual provider id must be 2-64 characters of letters, numbers, underscore, or dash");
-  }
-  return id;
-}
-
-function readRequiredString(value: unknown, label: string): string {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new Error(`${label} is required`);
-  }
-  return value.trim();
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-function readOptionalNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function readNonEmptyStringList(value: unknown, label: string): string[] {
-  const entries = readStringList(value);
-  if (entries.length === 0) {
-    throw new Error(`${label} must contain at least one value`);
-  }
-  return entries;
-}
-
-function readStringList(value: unknown): string[] {
-  if (!Array.isArray(value)) {
-    return [];
-  }
-  return value
-    .filter((entry): entry is string => typeof entry === "string")
-    .map((entry) => entry.trim())
-    .filter((entry, index, all) => entry.length > 0 && all.indexOf(entry) === index);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/src/registry-trust.ts

@@ -1,51 +0,0 @@
-import * as crypto from "crypto";
-
-export const DEFAULT_SELLER_REGISTRY_URL = "https://registry.tokenbuddy.ai/v1/registry.json";
-export const DEFAULT_SELLER_REGISTRY_SIGNATURE_URL = "https://registry.tokenbuddy.ai/v1/registry.sig";
-
-const TRUSTED_REGISTRY_KEYS: Record<string, string> = {
-  "registry-ed25519-2026-06": "MCowBQYDK2VwAyEAcPWdwqqycIHmhSBWmt+HgFgQEMNFJv2uEEcpxPzwgb0="
-};
-
-export function signatureUrlForRegistryUrl(registryUrl: string): string {
-  if (registryUrl === DEFAULT_SELLER_REGISTRY_URL) {
-    return DEFAULT_SELLER_REGISTRY_SIGNATURE_URL;
-  }
-  return registryUrl.replace(/\.json(?:\?.*)?$/, ".sig");
-}
-
-export function shouldVerifyRegistry(registryUrl: string): boolean {
-  if (process.env.TB_PROXYD_ALLOW_UNSIGNED_REGISTRY === "1") {
-    return false;
-  }
-  return registryUrl === DEFAULT_SELLER_REGISTRY_URL || process.env.TB_PROXYD_REQUIRE_SIGNED_REGISTRY === "1";
-}
-
-export function verifyTrustedRegistrySignature(registryBytes: string, signatureText: string): string {
-  return verifyRegistrySignatureWithKeys(registryBytes, signatureText, TRUSTED_REGISTRY_KEYS);
-}
-
-export function verifyRegistrySignatureWithKeys(
-  registryBytes: string,
-  signatureText: string,
-  trustedKeys: Record<string, string>
-): string {
-  const signature = signatureText.trim();
-  for (const [keyId, publicKeyDerBase64] of Object.entries(trustedKeys)) {
-    const publicKey = crypto.createPublicKey({
-      key: Buffer.from(publicKeyDerBase64, "base64"),
-      format: "der",
-      type: "spki"
-    });
-    const ok = crypto.verify(
-      null,
-      Buffer.from(registryBytes, "utf8"),
-      publicKey,
-      Buffer.from(signature, "base64url")
-    );
-    if (ok) {
-      return keyId;
-    }
-  }
-  throw new Error("registry signature verification failed");
-}