@flamingo-stack/openframe-frontend-core 0.0.723 → 0.0.725

package/src/utils/ai-providers.ts

@@ -0,0 +1,46 @@
+/**
+ * The AI model providers the product names: what each is called and the NAME of
+ * its mark in the icon set. THE one owner of both, for every surface that shows
+ * a provider (the token rates, a model picker). Server-safe: it holds names
+ * only, and the mark is resolved from the icon set by that name where it is
+ * drawn (`findIcon`), so no surface imports a provider's icon.
+ *
+ * A host that is told a provider's name or mark by its server states them on
+ * the record and they win. A provider this list has not met is named from its
+ * key, and its mark is looked up by the icon set's own naming
+ * (`<provider>-logo-grey`), so a logo added to the set shows with no change here.
+ */
+
+export interface AiProvider {
+  /** The name people know the provider by. */
+  label: string;
+  /** The icon set's name of the provider's monochrome mark. */
+  icon: string;
+}
+
+/** Keyed by the provider key billing sends (`ANTHROPIC`). */
+export const AI_PROVIDERS: Readonly<Record<string, AiProvider>> = {
+  ANTHROPIC: { label: 'Anthropic', icon: 'anthropic-logo-grey' },
+  OPENAI: { label: 'OpenAI', icon: 'openai-logo-grey' },
+  GOOGLE_GEMINI: { label: 'Google Gemini', icon: 'gemini-logo-grey' },
+};
+
+const words = (key: string): string[] =>
+  key
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+
+/**
+ * A provider by its key: what a host stated for it, else this list's entry,
+ * else its key read as a name and the mark the icon set would hold for it.
+ */
+export function aiProvider(key: string, stated?: { label?: string | null; icon?: string | null } | null): AiProvider {
+  const known = AI_PROVIDERS[key];
+  const parts = words(key);
+  return {
+    label:
+      stated?.label || known?.label || parts.map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ') || key,
+    icon: stated?.icon || known?.icon || `${parts.join('-')}-logo-grey`,
+  };
+}

package/src/utils/index.ts

@@ -17,6 +17,8 @@ export {
 // source of truth). Re-exported here so existing callers that pull from
 // the barrel keep working without changing imports.
 export { formatDate, formatNumber, formatPrice, formatBytes, formatUrlForDisplay } from './format';
+export * from './ai-providers';
+export * from './model-token-rates';
 export { TRIAL_DAYS, TRIAL_LABELS } from './trial';
 export {
   VENDOR_CLASSIFICATIONS,

package/src/utils/list-url.ts

@@ -118,6 +118,7 @@ const BUILDERS: Record<string, (ids: string[], base: string) => string> = {
   prospect_call: (ids, b) => `${b}/api/prospect-calls?ids=${ids.join(',')}`,
   // The public website's own pages (live source; ChatRef-shaped items like the objects above).
   site_page: (ids, b) => `${b}/api/site-pages?ids=${ids.join(',')}`,
+  openframe_price: (ids, b) => `${b}/api/openframe-pricing?ids=${ids.join(',')}`,
   // The OpenMSP vendor directory (indexed source).
   vendor: (ids, b) => `${b}/api/vendors/cards?ids=${ids.join(',')}`,
   // Code intelligence — per-object card hydration, same `handleEntityCardList`

package/src/utils/model-token-rates.ts

@@ -0,0 +1,103 @@
+/**
+ * The per-model AI token exchange rates: their shape and how a rate is written.
+ * Server-safe (no client code), so a host's server (a chat source, a page's
+ * metadata) states a rate exactly as the shared table (`ModelTokenRates`) does.
+ */
+
+import { aiProvider } from './ai-providers';
+
+/** One model's rates: OpenFrame tokens charged per ONE token of the model. */
+export interface ModelTokenRate {
+  modelName: string;
+  /** The name people know the model by; the model's id stands in when it is missing. */
+  displayName?: string | null;
+  /** The provider's key (`ANTHROPIC`, `OPENAI`, `GOOGLE_GEMINI`); an unknown one is shown by name, without a mark. */
+  providerType: string;
+  /** The provider's name, when the host's server states one; else the shared provider list names it. */
+  providerLabel?: string | null;
+  /** The icon set's name of the provider's mark, when the host's server states one; else the shared provider list's. */
+  providerIcon?: string | null;
+  inputTokenRate: number;
+  outputTokenRate: number;
+  /** Charged for an input token read back from the prompt cache. Shown only where the table has room for it. */
+  cacheReadInputTokenRate?: number | null;
+}
+
+/** What a figure that cannot be stated is written as. */
+export const TOKEN_RATE_EMPTY = '\u2014';
+
+/**
+ * A rate as a multiplier. Two decimals from 0.1 up ("1.33×", "5×"), two
+ * significant digits under it ("0.033×"), so a cheap model's rate is never
+ * rounded to nothing.
+ */
+export function formatTokenRate(value: number | null | undefined): string {
+  if (value == null || !Number.isFinite(value) || value <= 0) return TOKEN_RATE_EMPTY;
+  const rounded = value >= 0.1 ? Number(value.toFixed(2)) : Number(value.toPrecision(2));
+  return `${rounded}\u00d7`;
+}
+
+/** What OpenFrame tokens cost: `price` USD buys `tokens` of them. */
+export interface TokenPrice {
+  tokens: number;
+  price: number;
+}
+
+/** What a number of OpenFrame tokens costs in USD at a price. Null without a price. */
+export function tokenCost(tokens: number, tokenPrice: TokenPrice | null | undefined): number | null {
+  if (!tokenPrice || !(tokenPrice.tokens > 0) || !(tokenPrice.price > 0) || !(tokens >= 0)) return null;
+  return (tokens / tokenPrice.tokens) * tokenPrice.price;
+}
+
+/** The units a token count is shortened to, largest first. */
+const TOKEN_AMOUNT_UNITS = [
+  { size: 1_000_000_000, suffix: 'B' },
+  { size: 1_000_000, suffix: 'M' },
+  { size: 1_000, suffix: 'K' },
+] as const;
+
+/**
+ * A token count in short form: "850", "10K", "750K", "1.25M". The unit is chosen
+ * from the ROUNDED figure, so a count just under a unit reads as the next one
+ * ("1M", never "1000K").
+ */
+export function formatTokenAmount(tokens: number | null | undefined): string {
+  if (tokens == null || !Number.isFinite(tokens) || tokens < 0) return TOKEN_RATE_EMPTY;
+  const whole = Math.round(tokens);
+  if (whole < 1_000) return String(whole);
+  for (const [index, unit] of TOKEN_AMOUNT_UNITS.entries()) {
+    if (whole < unit.size) continue;
+    const figure = Number((whole / unit.size).toPrecision(3));
+    // Rounded up to a thousand of this unit: it is one of the unit above.
+    const larger = TOKEN_AMOUNT_UNITS[index - 1];
+    return figure >= 1_000 && larger ? `1${larger.suffix}` : `${figure}${unit.suffix}`;
+  }
+  return String(whole);
+}
+
+/**
+ * How many of a model's tokens a balance of OpenFrame tokens runs at a rate:
+ * the balance divided by the rate. Null without a rate.
+ */
+export function tokensForBalance(balance: number, rate: number | null | undefined): number | null {
+  if (rate == null || !Number.isFinite(rate) || rate <= 0 || !(balance > 0)) return null;
+  return balance / rate;
+}
+
+/** A provider's name: what the host stated for it, else the shared provider list's (`aiProvider`). */
+export function tokenRateProviderLabel(providerType: string, stated?: string | null): string {
+  return aiProvider(providerType, { label: stated }).label;
+}
+
+/** The rates under their providers, in the order the host gave them (providers by first appearance). */
+export function groupTokenRatesByProvider<T extends ModelTokenRate>(
+  rates: readonly T[],
+): { providerType: string; rates: T[] }[] {
+  const groups = new Map<string, T[]>();
+  for (const rate of rates) {
+    const group = groups.get(rate.providerType);
+    if (group) group.push(rate);
+    else groups.set(rate.providerType, [rate]);
+  }
+  return [...groups].map(([providerType, grouped]) => ({ providerType, rates: grouped }));
+}

package/src/utils/source-icons.ts

@@ -58,6 +58,7 @@ export const SOURCE_ICON_NAMES: Record<string, string> = {
   'trust-center': 'shield-check',
   // The public website's own pages (live source): the site's own mark, as a glyph in the slot's colour
   'website-pages': 'flamingo-logo-grey',
+  'openframe-pricing': 'money-bill-dollar',
   // The OpenMSP vendor directory: the icon the site menu's "Tool directory" entry draws (it reads this one)
   vendors: 'package-search',
 
@@ -150,6 +151,7 @@ export const SOURCE_LABELS_BY_TABLE: Record<string, string> = {
   // Trust
   'trust-center': 'Trust Center',
   'website-pages': 'Website',
+  'openframe-pricing': 'OpenFrame pricing',
   vendors: 'Vendor Directory',
 
   // Financials
@@ -255,6 +257,7 @@ export const DEFAULT_DOCUMENT_TYPE_TO_TABLE_ID: Record<string, string> = {
   // Trust
   trust_center: 'trust-center',
   site_page: 'website-pages',
+  openframe_price: 'openframe-pricing',
   vendor: 'vendors',
 
   // Financials