open-model-selector 0.1.0

package/dist/utils.d.ts

@@ -0,0 +1,304 @@
+/** Union of all supported model type identifiers. */
+type ModelType = 'text' | 'image' | 'video' | 'inpaint' | 'embedding' | 'tts' | 'asr' | 'upscale';
+interface Deprecation {
+    /** ISO 8601 date string indicating when the model is/was deprecated */
+    date: string;
+}
+interface BaseModel {
+    id: string;
+    name: string;
+    provider: string;
+    created: number;
+    type: ModelType;
+    description?: string;
+    privacy?: 'private' | 'anonymized';
+    offline?: boolean;
+    betaModel?: boolean;
+    /** Whether the user has marked this model as a favorite.
+     *  CLIENT-SIDE OVERLAY — this field is NEVER returned by any API.
+     *  It is a UI-layer concern managed via localStorage in the ModelSelector component.
+     *  Normalizers MUST default this to `false`; the component hydrates the real value
+     *  from localStorage at render time. */
+    is_favorite?: boolean;
+    modelSource?: string;
+    traits?: string[];
+    /** Deprecation info if this model is scheduled for or has been deprecated. */
+    deprecation?: Deprecation;
+}
+
+interface TextPricing {
+    prompt?: number;
+    completion?: number;
+    cache_input?: number;
+    cache_write?: number;
+}
+/** Feature flags indicating what a text model supports (vision, reasoning, function calling, etc.). */
+interface TextCapabilities {
+    optimizedForCode?: boolean;
+    supportsVision?: boolean;
+    supportsReasoning?: boolean;
+    supportsFunctionCalling?: boolean;
+    supportsResponseSchema?: boolean;
+    supportsLogProbs?: boolean;
+    supportsAudioInput?: boolean;
+    supportsVideoInput?: boolean;
+    supportsWebSearch?: boolean;
+    quantization?: string;
+}
+/** Default sampling parameter values for a text model. */
+interface TextConstraints {
+    temperature?: {
+        default: number;
+    };
+    top_p?: {
+        default: number;
+    };
+}
+/** A text/chat completion model with context length, pricing, and optional capabilities. */
+interface TextModel extends BaseModel {
+    type: 'text';
+    context_length: number;
+    pricing: TextPricing;
+    capabilities?: TextCapabilities;
+    constraints?: TextConstraints;
+}
+
+interface ImagePricing {
+    generation?: number;
+    upscale_2x?: number;
+    upscale_4x?: number;
+    resolutions?: Record<string, number>;
+}
+/** Generation constraints for an image model (prompt limits, aspect ratios, resolutions, etc.). */
+interface ImageConstraints {
+    promptCharacterLimit?: number;
+    steps?: {
+        default: number;
+        max: number;
+    };
+    widthHeightDivisor?: number;
+    aspectRatios?: string[];
+    defaultAspectRatio?: string;
+    resolutions?: string[];
+    defaultResolution?: string;
+}
+interface ImageModel extends BaseModel {
+    type: 'image';
+    pricing: ImagePricing;
+    constraints?: ImageConstraints;
+    /** Whether web search is supported for this image model.
+     *  In the Venice API, this field lives at `model_spec.supportsWebSearch`
+     *  (a sibling of `model_spec.constraints`), NOT inside `model_spec.constraints`. */
+    supportsWebSearch?: boolean;
+}
+
+/** Generation constraints for a video model (aspect ratios, durations, audio support, etc.). */
+interface VideoConstraints {
+    model_type?: 'text-to-video' | 'image-to-video' | 'video';
+    aspect_ratios?: string[];
+    resolutions?: string[];
+    durations?: string[];
+    audio?: boolean;
+    audio_configurable?: boolean;
+    audio_input?: boolean;
+    video_input?: boolean;
+}
+/** A video generation model. Note: no pricing data — the Venice API omits it for video models. */
+interface VideoModel extends BaseModel {
+    type: 'video';
+    constraints?: VideoConstraints;
+    model_sets?: string[];
+}
+
+interface InpaintPricing {
+    generation?: number;
+}
+/** Generation constraints for an inpainting model (aspect ratios, image combining). */
+interface InpaintConstraints {
+    aspectRatios?: string[];
+    combineImages?: boolean;
+}
+/** An image inpainting/editing model with pricing and generation constraints. */
+interface InpaintModel extends BaseModel {
+    type: 'inpaint';
+    pricing: InpaintPricing;
+    constraints?: InpaintConstraints;
+}
+
+interface EmbeddingPricing {
+    input?: number;
+    output?: number;
+}
+/** A text embedding model with per-token pricing. */
+interface EmbeddingModel extends BaseModel {
+    type: 'embedding';
+    pricing: EmbeddingPricing;
+}
+
+interface TtsPricing {
+    input?: number;
+}
+/** A text-to-speech model with pricing and available voice options. */
+interface TtsModel extends BaseModel {
+    type: 'tts';
+    pricing: TtsPricing;
+    voices?: string[];
+}
+
+interface AsrPricing {
+    per_audio_second?: number;
+}
+/** An automatic speech recognition (speech-to-text) model with per-second pricing. */
+interface AsrModel extends BaseModel {
+    type: 'asr';
+    pricing: AsrPricing;
+}
+
+interface UpscalePricing {
+    generation?: number;
+}
+/** An image upscaling model with flat per-generation pricing. */
+interface UpscaleModel extends BaseModel {
+    type: 'upscale';
+    pricing: UpscalePricing;
+}
+
+/** Discriminated union of all supported model types. Use `model.type` to narrow. */
+type AnyModel = TextModel | ImageModel | VideoModel | InpaintModel | EmbeddingModel | TtsModel | AsrModel | UpscaleModel;
+
+/** Safely coerce an unknown value to a number. Returns undefined for non-numeric/NaN. */
+declare function toNum(v: unknown): number | undefined;
+/** Extract shared BaseModel fields from a raw API response object.
+ *  Venice nests most metadata under model_spec; other providers use top-level fields.
+ *  This helper checks both locations with model_spec taking priority for Venice-specific fields. */
+declare function extractBaseFields(raw: Record<string, unknown>): Omit<BaseModel, 'type'>;
+
+/** Known model ID patterns for heuristic type inference.
+ *  Used when the API response lacks an explicit `type` field (non-Venice providers).
+ *  Exported so consumers can inspect or extend. */
+declare const MODEL_ID_TYPE_PATTERNS: Array<[RegExp, ModelType]>;
+/** Infer model type from its ID using naming conventions.
+ *  Returns undefined if no pattern matches (caller should fall back to 'text'). */
+declare function inferTypeFromId(id: string): ModelType | undefined;
+
+/** Normalize a raw API response object into a TextModel. */
+declare function normalizeTextModel(raw: Record<string, unknown>): TextModel;
+
+/** Normalize a raw API response object into an ImageModel. */
+declare function normalizeImageModel(raw: Record<string, unknown>): ImageModel;
+
+/** Normalize a raw API response object into a VideoModel.
+ *  Note: Video models have NO pricing data from the Venice API. */
+declare function normalizeVideoModel(raw: Record<string, unknown>): VideoModel;
+
+/** Normalize a raw API response object into an InpaintModel. */
+declare function normalizeInpaintModel(raw: Record<string, unknown>): InpaintModel;
+
+/** Normalize a raw API response object into an EmbeddingModel.
+ *  Note: Venice embedding models have BOTH input and output pricing. */
+declare function normalizeEmbeddingModel(raw: Record<string, unknown>): EmbeddingModel;
+
+/** Normalize a raw API response object into a TtsModel. */
+declare function normalizeTtsModel(raw: Record<string, unknown>): TtsModel;
+
+/** Normalize a raw API response object into an AsrModel. */
+declare function normalizeAsrModel(raw: Record<string, unknown>): AsrModel;
+
+/** Normalize a raw API response object into an UpscaleModel. */
+declare function normalizeUpscaleModel(raw: Record<string, unknown>): UpscaleModel;
+
+/** Function that extracts the array of raw model objects from an API response body. */
+type ResponseExtractor = (body: Record<string, unknown> | unknown[]) => Record<string, unknown>[];
+/** Function that normalizes a single raw model object into an AnyModel. */
+type ModelNormalizer = (raw: Record<string, unknown>) => AnyModel;
+/** Default response extractor handling common API response shapes:
+ *  - Top-level array → return as-is
+ *  - `{ data: [...] }` (OpenAI standard) → return data
+ *  - `{ models: [...] }` → return models
+ *  - Fallback → empty array */
+declare function defaultResponseExtractor(body: Record<string, unknown> | unknown[]): Record<string, unknown>[];
+/** Default dispatching model normalizer.
+ *  Uses three-tier type resolution:
+ *  1. Explicit `raw.type` field (Venice, custom providers)
+ *  2. Heuristic inference from model ID patterns (OpenAI, OpenRouter, etc.)
+ *  3. Fallback to 'text' — safe default for most providers */
+declare function defaultModelNormalizer(raw: Record<string, unknown>): AnyModel;
+
+/** Check whether a deprecation date is in the past.
+ *  Date-only ISO 8601 strings ("2025-01-15") are parsed as UTC midnight per the
+ *  ES spec, but we normalize explicitly to avoid any cross-engine ambiguity.
+ *  Returns false for invalid / unparseable date strings. */
+declare function isDeprecated(dateStr: string): boolean;
+
+/**
+ * Formats a per-token price into a human-readable per-million-tokens string.
+ *
+ * Accepts the price as a per-token value (matching the OpenAI / OpenRouter
+ * convention) and multiplies by 1,000,000 to display the per-million rate.
+ *
+ * @param value - Price per token as a number or numeric string.
+ *   Accepts `undefined`, `null`, empty string, or `NaN` — all return `"—"`.
+ * @returns A formatted dollar string (e.g. `"$30.00"`).
+ *   - Returns `"—"` for missing, empty, or non-numeric input.
+ *   - Uses 2 decimal places when the per-million value is ≥ $0.01.
+ *   - Uses 6 decimal places when the per-million value is < $0.01
+ *     (to preserve precision for very cheap models).
+ *
+ * @example
+ * ```ts
+ * formatPrice(0.00003)    // "$30.00"   (per-token → per-million)
+ * formatPrice("0.000015") // "$15.00"
+ * formatPrice(1e-12)      // "$0.000001"
+ * formatPrice(undefined)  // "—"
+ * ```
+ *
+ */
+declare function formatPrice(value: string | number | undefined | null): string;
+/**
+ * Formats a token count into a compact human-readable string.
+ *
+ * @param tokens - Raw token count (e.g. `128000`, `1_000_000`).
+ * @returns A compact string like `"128k"` or `"1M"`.
+ *   - Values ≥ 1,000,000 are shown in millions (e.g. `"1M"`, `"1.5M"`).
+ *   - Values < 1,000 are shown as exact numbers (e.g. `500` → `"500"`).
+ *   - Values ≥ 1,000 and < 1,000,000 are divided by 1,000 and rounded to the nearest
+ *     integer (e.g. `8192` → `"8k"`, `1000` → `"1k"`).
+ *
+ * @example
+ * ```ts
+ * formatContextLength(128000)    // "128k"
+ * formatContextLength(1_000_000) // "1M"
+ * formatContextLength(1_500_000) // "1.5M"
+ * ```
+ *
+ */
+declare function formatContextLength(tokens: number): string;
+/**
+ * Format a flat USD price (per-generation, per-inpaint, per-upscale).
+ * Unlike formatPrice which handles per-token values, this formats absolute USD amounts.
+ * Examples: 0.04 → "$0.04", 0.18 → "$0.18", 0 → "$0.00"
+ */
+declare function formatFlatPrice(usd: number | undefined | null): string;
+/**
+ * Format a per-audio-second price.
+ * Examples: 0.01 → "$0.01 / sec", 0.006 → "$0.006 / sec"
+ */
+declare function formatAudioPrice(perSecondUsd: number | undefined | null): string;
+/**
+ * Format an array of duration strings into a range.
+ * Examples: ["5", "10", "30"] → "5s – 30s", ["10"] → "10s", [] → "—"
+ * Handles both numeric strings and strings that may already have units.
+ */
+declare function formatDuration(durations: string[] | undefined | null): string;
+/**
+ * Format an array of resolution strings into a comma-separated list.
+ * Examples: ["720p", "1080p", "4K"] → "720p, 1080p, 4K", [] → "—"
+ */
+declare function formatResolutions(resolutions: string[] | undefined | null): string;
+/**
+ * Format an array of aspect ratio strings into a comma-separated list.
+ * Examples: ["16:9", "9:16", "1:1"] → "16:9, 9:16, 1:1", [] → "—"
+ */
+declare function formatAspectRatios(ratios: string[] | undefined | null): string;
+
+export { type AnyModel, type AsrModel, type AsrPricing, type BaseModel, type Deprecation, type EmbeddingModel, type EmbeddingPricing, type ImageConstraints, type ImageModel, type ImagePricing, type InpaintConstraints, type InpaintModel, type InpaintPricing, MODEL_ID_TYPE_PATTERNS, type ModelNormalizer, type ModelType, type ResponseExtractor, type TextCapabilities, type TextConstraints, type TextModel, type TextPricing, type TtsModel, type TtsPricing, type UpscaleModel, type UpscalePricing, type VideoConstraints, type VideoModel, defaultModelNormalizer, defaultResponseExtractor, extractBaseFields, formatAspectRatios, formatAudioPrice, formatContextLength, formatDuration, formatFlatPrice, formatPrice, formatResolutions, inferTypeFromId, isDeprecated, normalizeAsrModel, normalizeEmbeddingModel, normalizeImageModel, normalizeInpaintModel, normalizeTextModel, normalizeTtsModel, normalizeUpscaleModel, normalizeVideoModel, toNum };

package/dist/utils.js

@@ -0,0 +1,371 @@
+// src/utils/normalizers/type-inference.ts
+var MODEL_ID_TYPE_PATTERNS = [
+  [/\b(embed|embedding)\b/i, "embedding"],
+  [/\b(dall-e|stable-diffusion|sdxl|midjourney|flux)\b/i, "image"],
+  [/\b(tts)\b/i, "tts"],
+  [/\b(whisper|asr)\b/i, "asr"],
+  [/\b(sora|video|wan)\b/i, "video"],
+  [/\b(inpaint)\b/i, "inpaint"],
+  [/\b(upscale|esrgan)\b/i, "upscale"]
+];
+function inferTypeFromId(id) {
+  for (const [pattern, type] of MODEL_ID_TYPE_PATTERNS) {
+    if (pattern.test(id)) return type;
+  }
+  return void 0;
+}
+
+// src/utils/normalizers/base.ts
+function toNum(v) {
+  if (v === null || v === void 0 || v === "") return void 0;
+  const n = Number(v);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function extractBaseFields(raw) {
+  const spec = raw.model_spec;
+  const id = raw.id || raw.model_id || "";
+  if (!id) throw new Error("Model missing required id field");
+  const provider = id.includes("/") ? id.split("/")[0] : raw.owned_by || "Unknown";
+  return {
+    id,
+    name: spec?.name || raw.name || id,
+    provider,
+    created: toNum(raw.created) ?? Math.floor(Date.now() / 1e3),
+    description: spec?.description || raw.description || void 0,
+    // Venice-specific fields — always nested under model_spec, never top-level
+    betaModel: spec?.betaModel ?? raw.betaModel ?? void 0,
+    privacy: spec?.privacy ?? raw.privacy ?? void 0,
+    offline: spec?.offline ?? raw.offline ?? void 0,
+    modelSource: spec?.modelSource ?? raw.modelSource ?? void 0,
+    traits: spec?.traits ?? raw.traits ?? void 0,
+    // Deprecation info — lifecycle field, can appear on any model type.
+    deprecation: spec?.deprecation ?? void 0,
+    // CLIENT-SIDE OVERLAY: is_favorite is never returned by any API.
+    is_favorite: false
+  };
+}
+
+// src/utils/normalizers/text.ts
+function normalizeTextModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const specPricing = spec?.pricing;
+  const context_length = toNum(raw.context_length) ?? toNum(raw.context_window) ?? toNum(spec?.availableContextTokens) ?? 0;
+  const rawPricing = raw.pricing;
+  const metaPricing = raw.metadata?.pricing;
+  const costPricing = raw.cost;
+  let prompt;
+  let completion;
+  let cache_input;
+  let cache_write;
+  if (rawPricing) {
+    prompt = toNum(rawPricing.prompt);
+    completion = toNum(rawPricing.completion);
+    cache_input = toNum(rawPricing.cache_input);
+    cache_write = toNum(rawPricing.cache_write);
+  } else if (metaPricing) {
+    prompt = toNum(metaPricing.prompt);
+    completion = toNum(metaPricing.completion);
+  } else if (costPricing) {
+    prompt = toNum(costPricing.prompt);
+    completion = toNum(costPricing.completion);
+  } else if (specPricing) {
+    const input = specPricing.input;
+    const output = specPricing.output;
+    const cacheInput = specPricing.cache_input;
+    const cacheWrite = specPricing.cache_write;
+    prompt = input?.usd !== void 0 ? input.usd / 1e6 : void 0;
+    completion = output?.usd !== void 0 ? output.usd / 1e6 : void 0;
+    cache_input = cacheInput?.usd !== void 0 ? cacheInput.usd / 1e6 : void 0;
+    cache_write = cacheWrite?.usd !== void 0 ? cacheWrite.usd / 1e6 : void 0;
+  }
+  const caps = spec?.capabilities;
+  const constraints = spec?.constraints;
+  return {
+    ...base,
+    type: "text",
+    context_length,
+    pricing: {
+      prompt,
+      completion,
+      cache_input,
+      cache_write
+    },
+    capabilities: caps ? {
+      optimizedForCode: caps.optimizedForCode,
+      supportsVision: caps.supportsVision,
+      supportsReasoning: caps.supportsReasoning,
+      supportsFunctionCalling: caps.supportsFunctionCalling,
+      supportsResponseSchema: caps.supportsResponseSchema,
+      supportsLogProbs: caps.supportsLogProbs,
+      supportsAudioInput: caps.supportsAudioInput,
+      supportsVideoInput: caps.supportsVideoInput,
+      supportsWebSearch: caps.supportsWebSearch,
+      quantization: caps.quantization
+    } : void 0,
+    constraints: constraints ? {
+      temperature: constraints.temperature,
+      top_p: constraints.top_p
+    } : void 0
+  };
+}
+
+// src/utils/normalizers/image.ts
+function normalizeImageModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const pricing = spec?.pricing;
+  const constraints = spec?.constraints;
+  const generation = pricing?.generation;
+  const upscale = pricing?.upscale;
+  const rawResolutions = pricing?.resolutions;
+  let normalizedResolutions;
+  if (rawResolutions && typeof rawResolutions === "object") {
+    normalizedResolutions = {};
+    for (const [key, value] of Object.entries(rawResolutions)) {
+      if (value && typeof value === "object" && "usd" in value) {
+        normalizedResolutions[key] = value.usd ?? 0;
+      }
+    }
+  }
+  return {
+    ...base,
+    type: "image",
+    pricing: {
+      generation: generation?.usd,
+      upscale_2x: upscale?.["2x"]?.usd,
+      upscale_4x: upscale?.["4x"]?.usd,
+      resolutions: normalizedResolutions
+    },
+    constraints: constraints ? {
+      promptCharacterLimit: constraints.promptCharacterLimit,
+      steps: constraints.steps,
+      widthHeightDivisor: constraints.widthHeightDivisor,
+      aspectRatios: constraints.aspectRatios,
+      defaultAspectRatio: constraints.defaultAspectRatio,
+      resolutions: constraints.resolutions,
+      defaultResolution: constraints.defaultResolution
+    } : void 0,
+    // supportsWebSearch lives at model_spec.supportsWebSearch (sibling of constraints),
+    // NOT inside model_spec.constraints. Extract from spec, not constraints.
+    supportsWebSearch: spec?.supportsWebSearch ?? void 0
+  };
+}
+
+// src/utils/normalizers/video.ts
+function normalizeVideoModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const constraints = spec?.constraints;
+  return {
+    ...base,
+    type: "video",
+    constraints: constraints ? {
+      model_type: constraints.model_type,
+      aspect_ratios: constraints.aspect_ratios,
+      resolutions: constraints.resolutions,
+      durations: constraints.durations,
+      audio: constraints.audio,
+      audio_configurable: constraints.audio_configurable,
+      audio_input: constraints.audio_input,
+      video_input: constraints.video_input
+    } : void 0,
+    model_sets: spec?.model_sets ?? raw.model_sets ?? void 0
+  };
+}
+
+// src/utils/normalizers/inpaint.ts
+function normalizeInpaintModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const pricing = spec?.pricing;
+  const constraints = spec?.constraints;
+  const generation = pricing?.generation;
+  return {
+    ...base,
+    type: "inpaint",
+    pricing: {
+      generation: generation?.usd
+    },
+    constraints: constraints ? {
+      aspectRatios: constraints.aspectRatios,
+      combineImages: constraints.combineImages
+    } : void 0
+  };
+}
+
+// src/utils/normalizers/embedding.ts
+function normalizeEmbeddingModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const specPricing = spec?.pricing;
+  const input = specPricing?.input;
+  const output = specPricing?.output;
+  return {
+    ...base,
+    type: "embedding",
+    pricing: {
+      input: input?.usd !== void 0 ? input.usd / 1e6 : void 0,
+      output: output?.usd !== void 0 ? output.usd / 1e6 : void 0
+    }
+  };
+}
+
+// src/utils/normalizers/tts.ts
+function normalizeTtsModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const specPricing = spec?.pricing;
+  const input = specPricing?.input;
+  return {
+    ...base,
+    type: "tts",
+    pricing: {
+      input: input?.usd !== void 0 ? input.usd / 1e6 : void 0
+    },
+    voices: spec?.voices ?? void 0
+  };
+}
+
+// src/utils/normalizers/asr.ts
+function normalizeAsrModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const specPricing = spec?.pricing;
+  const perAudioSecond = specPricing?.per_audio_second;
+  return {
+    ...base,
+    type: "asr",
+    pricing: {
+      per_audio_second: perAudioSecond?.usd
+    }
+  };
+}
+
+// src/utils/normalizers/upscale.ts
+function normalizeUpscaleModel(raw) {
+  const base = extractBaseFields(raw);
+  const spec = raw.model_spec;
+  const pricing = spec?.pricing;
+  const generation = pricing?.generation;
+  return {
+    ...base,
+    type: "upscale",
+    pricing: {
+      generation: generation?.usd
+    }
+  };
+}
+
+// src/utils/normalizers/index.ts
+function defaultResponseExtractor(body) {
+  if (Array.isArray(body)) return body;
+  if (body && typeof body === "object") {
+    if (Array.isArray(body.data)) return body.data;
+    if (Array.isArray(body.models)) return body.models;
+  }
+  return [];
+}
+var VALID_TYPES = /* @__PURE__ */ new Set(["text", "image", "video", "inpaint", "embedding", "tts", "asr", "upscale"]);
+function defaultModelNormalizer(raw) {
+  const id = raw.id ?? raw.model_id ?? "";
+  const rawType = raw.type;
+  const type = (rawType && VALID_TYPES.has(rawType) ? rawType : void 0) ?? inferTypeFromId(id) ?? "text";
+  switch (type) {
+    case "text":
+      return normalizeTextModel(raw);
+    case "image":
+      return normalizeImageModel(raw);
+    case "video":
+      return normalizeVideoModel(raw);
+    case "inpaint":
+      return normalizeInpaintModel(raw);
+    case "embedding":
+      return normalizeEmbeddingModel(raw);
+    case "tts":
+      return normalizeTtsModel(raw);
+    case "asr":
+      return normalizeAsrModel(raw);
+    case "upscale":
+      return normalizeUpscaleModel(raw);
+    default:
+      return normalizeTextModel(raw);
+  }
+}
+
+// src/utils/helpers.ts
+function isDeprecated(dateStr) {
+  const normalized = /^\d{4}-\d{2}-\d{2}$/.test(dateStr) ? dateStr + "T00:00:00Z" : dateStr;
+  const ts = new Date(normalized).getTime();
+  return !Number.isNaN(ts) && ts < Date.now();
+}
+
+// src/utils/format.ts
+function formatPrice(value) {
+  if (value === void 0 || value === null || value === "") return "\u2014";
+  const num = typeof value === "string" ? parseFloat(value) : value;
+  if (isNaN(num)) return "\u2014";
+  if (num < 0) return "\u2014";
+  if (num === 0) return "Free";
+  const perMillion = num * 1e6;
+  if (perMillion < 0.01) return "$" + perMillion.toFixed(6);
+  return "$" + perMillion.toFixed(2);
+}
+function formatContextLength(tokens) {
+  if (!tokens || tokens <= 0 || isNaN(tokens)) return "N/A";
+  if (tokens < 1e3) return `${Math.round(tokens)}`;
+  if (tokens >= 1e6) {
+    const millions = tokens / 1e6;
+    return millions % 1 === 0 ? `${millions}M` : `${millions.toFixed(1)}M`;
+  }
+  const k = Math.round(tokens / 1e3);
+  return `${k}k`;
+}
+function formatFlatPrice(usd) {
+  if (usd === void 0 || usd === null || Number.isNaN(usd)) return "\u2014";
+  return `$${usd.toFixed(2)}`;
+}
+function formatAudioPrice(perSecondUsd) {
+  if (perSecondUsd === void 0 || perSecondUsd === null || Number.isNaN(perSecondUsd)) return "\u2014";
+  const formatted = perSecondUsd >= 0.01 ? perSecondUsd.toFixed(2) : perSecondUsd.toFixed(4);
+  return `$${formatted} / sec`;
+}
+function formatDuration(durations) {
+  if (!durations || durations.length === 0) return "\u2014";
+  const nums = durations.map((d) => parseFloat(d)).filter((n) => !Number.isNaN(n)).sort((a, b) => a - b);
+  if (nums.length === 0) return "\u2014";
+  if (nums.length === 1) return `${nums[0]}s`;
+  return `${nums[0]}s \u2013 ${nums[nums.length - 1]}s`;
+}
+function formatResolutions(resolutions) {
+  if (!resolutions || resolutions.length === 0) return "\u2014";
+  return resolutions.join(", ");
+}
+function formatAspectRatios(ratios) {
+  if (!ratios || ratios.length === 0) return "\u2014";
+  return ratios.join(", ");
+}
+export {
+  MODEL_ID_TYPE_PATTERNS,
+  defaultModelNormalizer,
+  defaultResponseExtractor,
+  extractBaseFields,
+  formatAspectRatios,
+  formatAudioPrice,
+  formatContextLength,
+  formatDuration,
+  formatFlatPrice,
+  formatPrice,
+  formatResolutions,
+  inferTypeFromId,
+  isDeprecated,
+  normalizeAsrModel,
+  normalizeEmbeddingModel,
+  normalizeImageModel,
+  normalizeInpaintModel,
+  normalizeTextModel,
+  normalizeTtsModel,
+  normalizeUpscaleModel,
+  normalizeVideoModel,
+  toNum
+};