Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

7.5 KB
Raw Blame
import type { AIProvider, ModelInfo } from '@/types/ai';

export const AI_PROVIDER_DISPLAY_NAMES: Record<string, string> = {
  anthropic: 'Anthropic',
  openai: 'OpenAI',
  openrouter: 'OpenRouter',
  deepseek: 'DeepSeek',
  gemini: 'Google Gemini',
  zai: 'Z.ai',
  groq: 'Groq',
  mistral: 'Mistral',
  cerebras: 'Cerebras',
  together: 'Together AI',
  fireworks: 'Fireworks AI',
  'codex-subscription': 'Codex subscription (local)',
  'claude-subscription': 'Claude subscription (local)',
  ollama: 'Ollama',
  pulse: 'Pulse',
};

export const getAIProviderDisplayName = (provider: string): string =>
  AI_PROVIDER_DISPLAY_NAMES[provider] || provider;

export function getProviderFromModelId(modelId: string): AIProvider | string {
  const colonIndex = modelId.indexOf(':');
  if (colonIndex > 0) {
    return modelId.substring(0, colonIndex);
  }
  if (
    /^(openai|anthropic|google|deepseek|meta-llama|mistralai|x-ai|xai|cohere|qwen)\//.test(modelId)
  ) {
    return 'openrouter';
  }
  if (
    modelId.includes('claude') ||
    modelId.includes('opus') ||
    modelId.includes('sonnet') ||
    modelId.includes('haiku')
  ) {
    return 'anthropic';
  }
  if (
    modelId.includes('gpt') ||
    modelId.includes('o1') ||
    modelId.includes('o3') ||
    modelId.includes('o4')
  ) {
    return 'openai';
  }
  if (modelId.includes('deepseek')) {
    return 'deepseek';
  }
  if (modelId.includes('gemini')) {
    return 'gemini';
  }
  if (modelId.includes('glm')) {
    return 'zai';
  }
  if (modelId.includes('groq')) {
    return 'groq';
  }
  if (modelId.includes('mistral')) {
    return 'mistral';
  }
  if (modelId.includes('cerebras')) {
    return 'cerebras';
  }
  return 'ollama';
}

type AIModelRouteLabelInput =
  string | (Pick<ModelInfo, 'id'> & Partial<Pick<ModelInfo, 'name' | 'provider'>>);

const GATEWAY_MODEL_PROVIDERS = new Set<string>(['openrouter']);
const LOCAL_MODEL_ROUTE_LABELS: Record<string, string> = {
  'pulse:local-inventory': 'Pulse inventory',
  'pulse:mock-assistant': 'Pulse mock Assistant',
};
export const isPulseOwnedLocalModelRoute = (modelId: string): boolean =>
  Boolean(LOCAL_MODEL_ROUTE_LABELS[modelId.trim()]);
const UPSTREAM_PROVIDER_DISPLAY_NAMES: Record<string, string> = {
  anthropic: 'Anthropic',
  'arcee-ai': 'Arcee AI',
  'bytedance-seed': 'ByteDance Seed',
  cohere: 'Cohere',
  deepseek: 'DeepSeek',
  google: 'Google',
  'ibm-granite': 'IBM',
  inclusionai: 'inclusionAI',
  kwaipilot: 'Kwaipilot',
  meta: 'Meta',
  'meta-llama': 'Meta Llama',
  minimax: 'MiniMax',
  mistral: 'Mistral',
  mistralai: 'Mistral',
  moonshotai: 'MoonshotAI',
  nvidia: 'NVIDIA',
  openai: 'OpenAI',
  openrouter: 'OpenRouter',
  perceptron: 'Perceptron',
  poolside: 'Poolside',
  qwen: 'Qwen',
  rekaai: 'Reka',
  stepfun: 'StepFun',
  tencent: 'Tencent',
  xiaomi: 'Xiaomi',
  xai: 'xAI',
  'x-ai': 'xAI',
  'z-ai': 'Z.ai',
};
const MODEL_TOKEN_DISPLAY_NAMES: Record<string, string> = {
  api: 'API',
  deepseek: 'DeepSeek',
  flash: 'Flash',
  gemini: 'Gemini',
  glm: 'GLM',
  gpt: 'GPT',
  haiku: 'Haiku',
  instruct: 'Instruct',
  llama: 'Llama',
  mini: 'Mini',
  opus: 'Opus',
  plus: 'Plus',
  pro: 'Pro',
  qwen: 'Qwen',
  r: 'R',
  sonnet: 'Sonnet',
  turbo: 'Turbo',
  v: 'V',
};

const modelIdForLabel = (model: AIModelRouteLabelInput): string =>
  typeof model === 'string' ? model.trim() : model.id.trim();

const explicitModelNameForLabel = (model: AIModelRouteLabelInput): string => {
  if (typeof model === 'string') return '';
  const name = model.name?.trim();
  if (!name) return '';
  const id = modelIdForLabel(model);
  const routePayload = id.split(':').pop()?.trim();
  if (name === id || (routePayload && name === routePayload)) return '';
  return name;
};

const baseModelLabel = (model: AIModelRouteLabelInput): string => {
  const id = modelIdForLabel(model);
  const localLabel = LOCAL_MODEL_ROUTE_LABELS[id];
  if (localLabel) {
    return localLabel;
  }
  const name = explicitModelNameForLabel(model);
  if (name) return name;
  return id.split(':').pop() || id;
};

const transportProviderForLabel = (model: AIModelRouteLabelInput): string => {
  if (typeof model !== 'string') {
    const provider = model.provider?.trim();
    if (provider) {
      return provider;
    }
  }
  const id = modelIdForLabel(model);
  return id ? getProviderFromModelId(id) : '';
};

const titleizeRouteNamespace = (namespace: string): string => {
  const normalized = namespace.trim().toLowerCase().replace(/^~+/, '');
  if (!normalized) return '';
  const known = UPSTREAM_PROVIDER_DISPLAY_NAMES[normalized];
  if (known) return known;
  return normalized
    .split(/[-_\s]+/)
    .filter(Boolean)
    .map((token) => token.charAt(0).toUpperCase() + token.slice(1))
    .join(' ');
};

const titleizeModelToken = (token: string): string => {
  const normalized = token.trim().toLowerCase();
  if (!normalized) return '';
  const known = MODEL_TOKEN_DISPLAY_NAMES[normalized];
  if (known) return known;
  const alphaNumeric = normalized.match(/^([a-z]+)([0-9].*)$/);
  if (alphaNumeric) {
    const prefix =
      MODEL_TOKEN_DISPLAY_NAMES[alphaNumeric[1]] || titleizeModelToken(alphaNumeric[1]);
    return `${prefix}${alphaNumeric[2]}`;
  }
  if (/^[rv][0-9]/.test(normalized)) {
    return normalized.charAt(0).toUpperCase() + normalized.slice(1);
  }
  if (/^[0-9]+b$/.test(normalized)) {
    return normalized.toUpperCase();
  }
  return normalized.charAt(0).toUpperCase() + normalized.slice(1);
};

const titleizeModelRouteId = (modelId: string): string =>
  modelId
    .split('/')
    .map((segment) =>
      segment
        .split(/[-_\s]+/)
        .filter(Boolean)
        .map(titleizeModelToken)
        .join(' '),
    )
    .filter(Boolean)
    .join('/');

const gatewayFallbackLabel = (model: AIModelRouteLabelInput): string => {
  if (explicitModelNameForLabel(model)) return '';
  const id = modelIdForLabel(model);
  const payload = id.includes(':') ? id.split(':').slice(1).join(':') : id;
  const slashIndex = payload.indexOf('/');
  if (slashIndex <= 0 || slashIndex === payload.length - 1) return '';
  const upstreamProvider = titleizeRouteNamespace(payload.slice(0, slashIndex));
  const modelLabel = titleizeModelRouteId(payload.slice(slashIndex + 1));
  if (!upstreamProvider || !modelLabel) return '';
  return `${upstreamProvider}: ${modelLabel}`;
};

const directProviderRouteFallbackLabel = (model: AIModelRouteLabelInput): string => {
  if (explicitModelNameForLabel(model)) return '';
  const id = modelIdForLabel(model);
  if (isPulseOwnedLocalModelRoute(id)) return '';
  const separator = id.indexOf(':');
  if (separator <= 0 || separator === id.length - 1) return '';
  const provider = id.slice(0, separator);
  if (GATEWAY_MODEL_PROVIDERS.has(provider)) return '';
  const providerName = getAIProviderDisplayName(provider);
  const modelLabel = titleizeModelRouteId(id.slice(separator + 1));
  if (!providerName || !modelLabel) return '';
  return `${providerName}: ${modelLabel}`;
};

export const formatAIModelRouteLabel = (model: AIModelRouteLabelInput): string => {
  const provider = transportProviderForLabel(model);
  const label =
    provider && GATEWAY_MODEL_PROVIDERS.has(provider)
      ? gatewayFallbackLabel(model) || baseModelLabel(model)
      : directProviderRouteFallbackLabel(model) || baseModelLabel(model);
  if (!provider || !GATEWAY_MODEL_PROVIDERS.has(provider)) {
    return label;
  }
  const providerName = getAIProviderDisplayName(provider);
  if (!providerName || label.toLowerCase().includes(providerName.toLowerCase())) {
    return label;
  }
  return `${label} via ${providerName}`;
};