mohdel 0.124.0 → 1.0.0

package/src/lib/common.js

@@ -1,4 +1,5 @@
-import { join } from 'path'
+import { join, sep } from 'path'
+import { homedir } from 'os'
 import { existsSync } from 'fs'
 import { readFile, writeFile, mkdir, copyFile, stat } from 'fs/promises'
 import envPaths from 'env-paths'
@@ -17,6 +18,18 @@ export const EXCLUDED_PATH = join(CONFIG_DIR, 'excluded.json')
 export const PROVIDERS_CONFIG_PATH = join(CONFIG_DIR, 'providers.json')
 export const ENV_PATH = join(CONFIG_DIR, 'environment')
 
+export const tildePath = (path) => {
+  const home = homedir()
+  return home && path.startsWith(home + sep) ? '~' + path.slice(home.length) : path
+}
+
+// A path that must stay readable off this machine: the portable form leads,
+// the resolved one follows only when they differ.
+export const portablePath = (path) => {
+  const short = tildePath(path)
+  return short === path ? path : `${short} (${path} on this machine)`
+}
+
 // Meta keys (e.g. $schema for JSON Schema editors, _* for inline notes) live at
 // the top level of curated.json alongside model entries. They're preserved on
 // load/save but excluded from every iteration site so they don't pollute alias

package/src/lib/creators.js

@@ -1,70 +1,84 @@
 const creators = {
   alibaba: {
+    prefixes: ['qwen', 'qwq'],
     label: 'Alibaba',
     logo: 'alibaba.svg',
     description: 'Alibaba Cloud’s Qwen models target large-scale enterprise scenarios with strong multilingual and commerce-focused capabilities.'
   },
   bfl: {
+    prefixes: ['flux'],
     label: 'Black Forest Labs',
     logo: 'bfl.svg',
     description: 'Black Forest Labs builds the Flux family of image generation models, delivering fast, high-quality text-to-image synthesis.'
   },
   anthropic: {
+    prefixes: ['claude'],
     label: 'Anthropic',
     logo: 'anthropic.svg',
     description: 'Anthropic builds Claude models that emphasize safe reasoning, tool use, and reliable outputs for production assistants.'
   },
   deepseek: {
+    prefixes: ['deepseek'],
     label: 'DeepSeek',
     logo: 'deepseek.svg',
     description: 'DeepSeek offers fast, cost-efficient foundation models optimized for coding, chat, and multilingual reasoning.'
   },
   google: {
+    prefixes: ['gemini', 'gemma', 'imagen', 'nano-banana'],
     label: 'Google',
     logo: 'gemini.svg',
     description: 'Google’s Gemini family blends multimodal understanding, coding assistance, and long-context reasoning from Google DeepMind research.'
   },
   kwaipilot: {
+    prefixes: ['kwaipilot', 'kat-coder'],
     label: 'Kwaipilot',
     logo: 'kwaipilot.svg',
     description: 'Kuaishou\'s KwaiPilot team builds KAT-Coder, a MoE coding model with strong agentic and multi-step reasoning for software engineering tasks.'
   },
   meta: {
+    prefixes: ['llama', 'code-llama'],
     label: 'Meta',
     logo: 'meta.svg',
     description: 'Meta stewards the Llama ecosystem with open, widely adoptable models for chat, coding, and research.'
   },
   minimax: {
+    prefixes: ['minimax'],
     label: 'Minimax',
     logo: 'minimax.svg',
     description: 'Minimax offers versatile Chinese-first chat and coding models tuned for fast, cost-aware assistants and enterprise integrations.'
   },
   mistral: {
+    prefixes: ['mistral', 'codestral', 'pixtral', 'ministral', 'magistral', 'voxtral', 'devstral'],
     label: 'Mistral',
     logo: 'mistral.svg',
     description: 'Mistral AI ships strong open-weight and proprietary models with a focus on European hosting, multilingual quality, and efficient deployment.'
   },
   moonshotai: {
+    prefixes: ['moonshotai', 'kimi'],
     label: 'Moonshot AI',
     logo: 'moonshotai.svg',
     description: 'Moonshot AI ships fluent, Chinese-first assistants and lean models tuned for consumer chat and business workflows.'
   },
   openai: {
+    prefixes: ['gpt', 'whisper', 'dall-e', 'sora', 'text-embedding', 'o1', 'o3', 'o4'],
     label: 'OpenAI',
     logo: 'openai.svg',
     description: 'OpenAI’s GPT and o-series models focus on broad tool-use, reasoning quality, and multimodal support across developer platforms.'
   },
   xai: {
+    prefixes: ['grok'],
     label: 'xAI',
     logo: 'xai.svg',
     description: 'xAI develops Grok with real-time, web-aware chat and coding behavior aimed at terse, fast responses.'
   },
   xiaomi: {
+    prefixes: ['mimo'],
     label: 'Xiaomi',
     logo: 'xiaomi.svg',
     description: 'Xiaomi develops MiMo, a high-efficiency MoE reasoning model optimized for agentic coding and tool use at low inference cost.'
   },
   zai: {
+    prefixes: ['zai', 'zai-org', 'glm'],
     label: 'Z AI',
     logo: 'zai.svg',
     description: 'Z AI delivers streamlined assistants with lightweight models oriented toward pragmatic productivity use cases.'
@@ -73,4 +87,25 @@ const creators = {
 
 Object.freeze(creators)
 
+// Which organisation trained a model, guessed from its id. Two signals: a
+// router-style id carries the creator as a namespace (`moonshotai/kimi-k3`),
+// and a bare id usually starts with a family name (`claude-`, `qwen3-`).
+// A guess is only ever offered as a default — it is never written unasked.
+const startsWithToken = (id, prefix) => {
+  if (!id.startsWith(prefix)) return false
+  const next = id[prefix.length]
+  return next === undefined || !/[a-z]/.test(next)
+}
+
+export const creatorFromModelId = (bare) => {
+  const segments = String(bare).toLowerCase().split('/')
+  const candidates = segments.length > 1 ? [segments[0], segments[segments.length - 1]] : segments
+  for (const segment of candidates) {
+    for (const [name, def] of Object.entries(creators)) {
+      if ((def.prefixes || []).some(p => startsWithToken(segment, p))) return name
+    }
+  }
+  return null
+}
+
 export default creators

package/src/lib/index.js

@@ -170,7 +170,7 @@ const resolveProviderConfiguration = async (provider, providerName) => {
 // unchanged.
 const buildHandlers = ({ logger, onSuccess, onFailure }) => {
   const log = logger || silent
-  return {
+  const bag = {
     trace: typeof log.trace === 'function' ? (...args) => log.trace(...args) : noop,
     debug: typeof log.debug === 'function' ? (...args) => log.debug(...args) : noop,
     info: typeof log.info === 'function' ? (...args) => log.info(...args) : noop,
@@ -180,6 +180,13 @@ const buildHandlers = ({ logger, onSuccess, onFailure }) => {
     onSuccess,
     onFailure
   }
+  // The session scopes its logger with per-call context before using it. A
+  // logger that understands context gets it; one that does not keeps its
+  // levels rather than being replaced by the session's own default.
+  bag.withContext = typeof log.withContext === 'function'
+    ? (context) => buildHandlers({ logger: log.withContext(context), onSuccess, onFailure })
+    : () => bag
+  return bag
 }
 
 // @internal — exported under an underscore-prefixed alias for unit tests only.
@@ -335,7 +342,14 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
             if (!modelSpec) {
               const suggestions = suggestModels(modelId)
               let msg = `Model '${modelId}' not found in catalog.`
-              if (suggestions.length) {
+              // An empty catalog is a fresh install, not a typo. Saying only
+              // "not found" leaves a library caller with nowhere to go — the
+              // CLI prints these next steps, and nothing else did.
+              if (!Object.keys(catalog).some(k => !k.startsWith('$') && !k.startsWith('_'))) {
+                msg += ' The catalog is empty.' +
+                  '\n  Populate it:  mo curate <provider>   then   mo model instructions <provider>' +
+                  '\n  Or pass one:  mohdel({ models: { "<provider>/<model>": { … } } })'
+              } else if (suggestions.length) {
                 msg += ' Did you mean?\n' + suggestions.map(s => `  ${s.id}  ${s.label}`).join('\n')
               }
               throw new Error(msg)
@@ -581,7 +595,7 @@ const createModelProxy = (resolvedModelId, modelSpec, handlers, aliasOutputEffor
               configuration: effectiveConfiguration,
               prompt,
               options: sdkOptions
-            }, { cooldown, limiter: rateLimiter, resolveProviderLimits })
+            }, { cooldown, limiter: rateLimiter, resolveProviderLimits, logger: handlers })
 
             // End span with result attributes
             const endAttrs = {

package/src/lib/local-conventions.js

@@ -0,0 +1,120 @@
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { CONFIG_DIR, isMetaKey } from './common.js'
+import { fieldDefs, isValidTag } from './schema.js'
+
+export const LOCAL_PATH = join(CONFIG_DIR, 'catalog.local.json')
+
+const TOP_LEVEL = ['fields', 'tags', 'adding', 'notes']
+const FIELD_KEYS = ['type', 'description', 'measured', 'readBy']
+const TAG_KEYS = ['description', 'requires', 'severity']
+const TYPES = ['string', 'number', 'boolean', 'array', 'object']
+const SEVERITIES = ['error', 'warn']
+
+const isPlainObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
+
+export const parseLocalConventions = (text) => {
+  let doc
+  try {
+    doc = JSON.parse(text)
+  } catch (e) {
+    throw new Error(`not valid JSON: ${e.message}`)
+  }
+  if (!isPlainObject(doc)) throw new Error('must be a JSON object')
+
+  for (const key of Object.keys(doc)) {
+    if (isMetaKey(key)) continue
+    if (!TOP_LEVEL.includes(key)) {
+      throw new Error(`unknown key '${key}' (expected: ${TOP_LEVEL.join(', ')})`)
+    }
+  }
+
+  const fields = {}
+  for (const [name, def] of Object.entries(doc.fields || {})) {
+    if (!isPlainObject(def)) throw new Error(`fields.${name} must be an object`)
+    for (const key of Object.keys(def)) {
+      if (!FIELD_KEYS.includes(key)) throw new Error(`fields.${name}.${key} is not a known key (expected: ${FIELD_KEYS.join(', ')})`)
+    }
+    if (fieldDefs[name]) throw new Error(`fields.${name} is already a mohdel field — remove it, mohdel validates it already`)
+    if (!TYPES.includes(def.type)) throw new Error(`fields.${name}.type must be one of ${TYPES.join(', ')}`)
+    if (typeof def.description !== 'string' || !def.description) throw new Error(`fields.${name}.description is required`)
+    for (const key of ['measured', 'readBy']) {
+      if (def[key] !== undefined && typeof def[key] !== 'string') throw new Error(`fields.${name}.${key} must be a string`)
+    }
+    fields[name] = def
+  }
+
+  const tags = {}
+  for (const [name, def] of Object.entries(doc.tags || {})) {
+    if (!isPlainObject(def)) throw new Error(`tags.${name} must be an object`)
+    for (const key of Object.keys(def)) {
+      if (!TAG_KEYS.includes(key)) throw new Error(`tags.${name}.${key} is not a known key (expected: ${TAG_KEYS.join(', ')})`)
+    }
+    if (!isValidTag(name)) throw new Error(`tags.${name} is not a valid tag name`)
+    if (typeof def.description !== 'string' || !def.description) throw new Error(`tags.${name}.description is required`)
+    if (def.severity !== undefined && !SEVERITIES.includes(def.severity)) {
+      throw new Error(`tags.${name}.severity must be one of ${SEVERITIES.join(', ')}`)
+    }
+    if (def.requires !== undefined) {
+      if (!Array.isArray(def.requires)) throw new Error(`tags.${name}.requires must be an array of field names`)
+      for (const required of def.requires) {
+        if (!fieldDefs[required] && !fields[required]) {
+          throw new Error(`tags.${name}.requires names '${required}', which is neither a mohdel field nor declared under fields`)
+        }
+      }
+    }
+    tags[name] = { severity: 'error', requires: [], ...def }
+  }
+
+  const adding = doc.adding || {}
+  if (!isPlainObject(adding)) throw new Error('adding must be an object')
+  for (const [key, value] of Object.entries(adding)) {
+    if (!['field', 'tag'].includes(key)) throw new Error(`adding.${key} is not a known key (expected: field, tag)`)
+    if (typeof value !== 'string') throw new Error(`adding.${key} must be a string`)
+  }
+
+  if (doc.notes !== undefined && typeof doc.notes !== 'string') throw new Error('notes must be a string')
+
+  return { fields, tags, adding, notes: doc.notes || '' }
+}
+
+// Absent is the default state, not an error. A file that exists but does not
+// parse is broken policy — it must not read as "no conventions".
+export const loadLocalConventions = async (path = LOCAL_PATH) => {
+  if (!existsSync(path)) return null
+  try {
+    return parseLocalConventions(await readFile(path, 'utf8'))
+  } catch (e) {
+    throw new Error(`${path}: ${e.message}`)
+  }
+}
+
+export const TEMPLATE = `{
+  "_comment": "Declares what THIS installation adds to the mohdel catalog: custom fields your own services read, tags that mean something to them, and how a new one gets introduced. Absent by default; mohdel ships nothing here. See docs/CATALOG.md > Local conventions.",
+
+  "fields": {
+    "yourField": {
+      "type": "number",
+      "description": "What it means. The coding agent reads this before filling it in.",
+      "measured": "the command that produces this value, when it is measured rather than published",
+      "readBy": "which of your services read it"
+    }
+  },
+
+  "tags": {
+    "yourTag": {
+      "description": "What applying this tag does in your stack.",
+      "requires": ["yourField"],
+      "severity": "error"
+    }
+  },
+
+  "adding": {
+    "field": "How a new custom field is introduced here. Name every step that has to happen before it counts as existing.",
+    "tag": "How a new tag is introduced here, and what reads it."
+  },
+
+  "notes": "Anything else the coding agent should know about this catalog."
+}
+`

package/src/lib/provider-info.js

@@ -0,0 +1,98 @@
+// What first-run setup shows about each provider: how to get a key, and
+// whether you can use it without paying. Kept beside the provider registry
+// rather than inside the onboarding flow, because the brief needs it too.
+const PROVIDER_INFO = {
+  gemini: {
+    label: 'Google Gemini',
+    description: 'Long context, vision, video, audio. Free tier, no card required.',
+    url: 'https://aistudio.google.com/apikey',
+    hint: 'Create an API key at aistudio.google.com → Get API Key',
+    free: true
+  },
+  groq: {
+    label: 'Groq',
+    description: 'Open-weight models at the fastest inference available. Free tier, no card required.',
+    url: 'https://console.groq.com/keys',
+    hint: 'Create an API key at console.groq.com → API Keys',
+    free: true
+  },
+  cerebras: {
+    label: 'Cerebras',
+    description: 'Llama, Qwen — fast inference on custom hardware. Starter credits for new accounts.',
+    url: 'https://cloud.cerebras.ai/platform',
+    hint: 'Create an API key at cloud.cerebras.ai → Platform → API Keys',
+    free: false
+  },
+  anthropic: {
+    label: 'Anthropic',
+    description: 'Claude Opus, Sonnet, Haiku — reasoning, coding, vision, tool use.',
+    url: 'https://console.anthropic.com/settings/keys',
+    hint: 'Create an API key at console.anthropic.com → Settings → API Keys',
+    free: false
+  },
+  openai: {
+    label: 'OpenAI',
+    description: 'GPT and reasoning models — vision, image generation, tool use.',
+    url: 'https://platform.openai.com/api-keys',
+    hint: 'Create an API key at platform.openai.com → API Keys',
+    free: false
+  },
+  xai: {
+    label: 'xAI',
+    description: 'Grok — reasoning and tool use.',
+    url: 'https://console.x.ai',
+    hint: 'Create an API key at console.x.ai',
+    free: false
+  },
+  mistral: {
+    label: 'Mistral',
+    description: 'Mistral Large, Codestral, Pixtral — coding, reasoning, vision. Free tier, no card required.',
+    url: 'https://console.mistral.ai/api-keys',
+    hint: 'Create an API key at console.mistral.ai → API Keys',
+    free: true
+  },
+  deepseek: {
+    label: 'DeepSeek',
+    description: 'Reasoning and coding models, at low cost.',
+    url: 'https://platform.deepseek.com/api_keys',
+    hint: 'Create an API key at platform.deepseek.com → API Keys',
+    free: false
+  },
+  fireworks: {
+    label: 'Fireworks',
+    description: 'Llama, Qwen, DeepSeek — serverless inference with reasoning.',
+    url: 'https://fireworks.ai/account/api-keys',
+    hint: 'Create an API key at fireworks.ai → Account → API Keys',
+    free: false
+  },
+  openrouter: {
+    label: 'OpenRouter',
+    description: 'Multi-provider router — hundreds of models behind one key, some of them at no cost. Free tier, no card required.',
+    url: 'https://openrouter.ai/settings/keys',
+    hint: 'Create an API key at openrouter.ai → Settings → Keys',
+    free: true
+  },
+  novita: {
+    label: 'Novita',
+    description: 'Image generation and open-weight inference.',
+    url: 'https://novita.ai/dashboard/key',
+    hint: 'Create an API key at novita.ai → Dashboard → API Key',
+    free: false
+  },
+  xiaomi: {
+    label: 'Xiaomi MiMo',
+    description: 'MiMo — vision and text models.',
+    url: 'https://platform.xiaomimimo.com/',
+    hint: 'Create an API key in the MiMo open platform console',
+    free: false
+  },
+  qwen: {
+    label: 'Qwen Cloud',
+    description: 'Qwen — reasoning, coding, long context. Free quota for new users.',
+    url: 'https://home.qwencloud.com/api-keys',
+    hint: 'Create an API key at home.qwencloud.com → API Keys',
+    free: false
+  }
+}
+
+export default PROVIDER_INFO

package/src/lib/providers.js

@@ -1,9 +1,19 @@
+// `contextSemantics` and `outputCapStrategy` are published facts about a
+// provider, not switches: mohdel caps `outputBudget` to the model's
+// `outputTokenLimit` whatever they say. They exist so an embedder building its
+// own provider requests does not have to rediscover the behaviour one 400 at a
+// time. Entries may override `outputCapStrategy` per model. See
+// ARCHITECTURE.md > "The output budget is capped to the model's ceiling".
 const providers = {
   anthropic: {
     sdk: 'anthropic',
     apiKeyEnv: 'ANTHROPIC_API_SK',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['anthropic'],
+    references: {
+      pricing: 'https://platform.claude.com/docs/en/about-claude/pricing',
+      models: 'https://platform.claude.com/docs/en/models/overview',
+      rateLimits: 'https://platform.claude.com/docs/en/api/rate-limits'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'error'
   },
@@ -11,7 +21,11 @@ const providers = {
     sdk: 'cerebras',
     apiKeyEnv: 'CEREBRAS_API_SK',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['openai', 'zai'],
+    references: {
+      pricing: 'https://www.cerebras.ai/pricing',
+      models: 'https://inference-docs.cerebras.ai/models/overview',
+      rateLimits: 'https://inference-docs.cerebras.ai/support/rate-limits'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -21,7 +35,11 @@ const providers = {
     apiKeyEnv: 'DEEPSEEK_API_SK',
     baseURL: 'https://api.deepseek.com',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['deepseek'],
+    references: {
+      pricing: 'https://api-docs.deepseek.com/quick_start/pricing',
+      models: 'https://api-docs.deepseek.com/quick_start/pricing',
+      rateLimits: 'https://api-docs.deepseek.com/quick_start/rate_limit'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -30,7 +48,11 @@ const providers = {
     apiKeyEnv: 'FIREWORKS_API_SK',
     baseURL: 'https://api.fireworks.ai/inference/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['meta', 'alibaba'],
+    references: {
+      pricing: 'https://fireworks.ai/pricing',
+      models: 'https://fireworks.ai/models',
+      rateLimits: 'https://docs.fireworks.ai/guides/quotas_usage/account-quotas'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -38,7 +60,11 @@ const providers = {
     sdk: 'gemini',
     apiKeyEnv: 'GEMINI_API_SK',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['google'],
+    references: {
+      pricing: 'https://ai.google.dev/gemini-api/docs/pricing',
+      models: 'https://ai.google.dev/gemini-api/docs/models',
+      rateLimits: 'https://ai.google.dev/gemini-api/docs/rate-limits'
+    },
     contextSemantics: 'separate',
     outputCapStrategy: 'accept'
   },
@@ -46,14 +72,17 @@ const providers = {
     sdk: 'groq',
     apiKeyEnv: 'GROQ_API_SK',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['meta']
+    references: {
+      pricing: 'https://console.groq.com/docs/models',
+      models: 'https://console.groq.com/docs/models',
+      rateLimits: 'https://console.groq.com/docs/rate-limits'
+    }
   },
   local: {
     sdk: 'openai',
     api: 'chatCompletions',
     catalog: false,
     resolveConfiguration: () => ({ apiKey: process.env.MOHDEL_LOCAL_API_SK || '' }),
-    creators: [],
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -63,7 +92,11 @@ const providers = {
     apiKeyEnv: 'MISTRAL_API_SK',
     baseURL: 'https://api.mistral.ai/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['mistral']
+    references: {
+      pricing: 'https://mistral.ai/pricing',
+      models: 'https://docs.mistral.ai/models',
+      rateLimits: 'https://docs.mistral.ai/admin/billing-usage/usage-limits'
+    }
   },
   novita: {
     sdk: 'openai',
@@ -72,7 +105,10 @@ const providers = {
     apiKeyEnv: 'NOVITA_API_SK',
     baseURL: 'https://api.novita.ai/openai',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['deepseek', 'openai', 'bfl'],
+    references: {
+      pricing: 'https://novita.ai/pricing',
+      models: 'https://novita.ai/models'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'error'
   },
@@ -80,7 +116,11 @@ const providers = {
     sdk: 'openai',
     apiKeyEnv: 'OPENAI_API_SK',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['openai'],
+    references: {
+      pricing: 'https://developers.openai.com/api/docs/pricing',
+      models: 'https://developers.openai.com/api/docs/models',
+      rateLimits: 'https://developers.openai.com/api/docs/guides/rate-limits'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -89,7 +129,15 @@ const providers = {
     apiKeyEnv: 'OPENROUTER_API_SK',
     baseURL: 'https://openrouter.ai/api/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: []
+    // Alone among the providers, OpenRouter's model list carries per-token
+    // prices, so `mo curate openrouter` writes complete entries with no
+    // pricing page to read.
+    pricesFromApi: true,
+    references: {
+      pricing: 'https://openrouter.ai/models',
+      models: 'https://openrouter.ai/models',
+      rateLimits: 'https://openrouter.ai/docs/api_reference/limits'
+    }
   },
   qwen: {
     sdk: 'openai',
@@ -97,7 +145,11 @@ const providers = {
     apiKeyEnv: 'QWEN_API_SK',
     baseURL: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['alibaba'],
+    references: {
+      pricing: 'https://www.alibabacloud.com/help/en/model-studio/models',
+      models: 'https://www.alibabacloud.com/help/en/model-studio/models',
+      rateLimits: 'https://www.alibabacloud.com/help/en/model-studio/rate-limit'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -106,7 +158,11 @@ const providers = {
     apiKeyEnv: 'XAI_API_SK',
     baseURL: 'https://api.x.ai/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['xai'],
+    references: {
+      pricing: 'https://docs.x.ai/developers/models',
+      models: 'https://docs.x.ai/developers/models',
+      rateLimits: 'https://docs.x.ai/developers/rate-limits'
+    },
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
@@ -116,7 +172,6 @@ const providers = {
     apiKeyEnv: 'XIAOMI_API_SK',
     baseURL: 'https://api.xiaomimimo.com/v1',
     createConfiguration: apiKey => ({ apiKey }),
-    creators: ['xiaomi'],
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   }

package/src/lib/schema.js

@@ -15,6 +15,13 @@ const validateSpeeds = (speeds) => {
   return null
 }
 
+const INPUT_FORMATS = ['text', 'image', 'video', 'audio']
+
+const validateInputFormat = (formats) => {
+  const unknown = formats.filter(f => !INPUT_FORMATS.includes(f))
+  return unknown.length ? `unknown modality '${unknown.join("', '")}' (allowed: ${INPUT_FORMATS.join(', ')})` : null
+}
+
 const fieldDefs = {
   model: { type: 'string', required: true },
   baseURL: { type: 'string' },
@@ -32,6 +39,7 @@ const fieldDefs = {
   cacheWritePrice: { type: 'number', altType: 'object' },
   cacheWrite1hPrice: { type: 'number', altType: 'object' },
   contextTokenLimit: { type: 'number' },
+  inputCeilingMargin: { type: 'number' },
   outputTokenLimit: { type: 'number' },
   thinkingTokenLimit: { type: 'number' },
   thinkingEffortLevels: { type: 'object', nullable: true, default: null },
@@ -42,7 +50,7 @@ const fieldDefs = {
   replaces: { type: 'array', itemType: 'string', default: [] },
   leaderboard: { type: 'array', itemType: 'number', validate: (v) => Array.isArray(v) && v.length === 3 ? null : 'must be [intelligence, speed, latency]' },
   leaderboardNote: { type: 'string' },
-  inputFormat: { type: 'array', itemType: 'string', required: true, default: ['text'] },
+  inputFormat: { type: 'array', itemType: 'string', required: true, default: ['text'], validate: validateInputFormat, severity: 'error' },
   version: { type: 'string' },
   createdAt: { type: 'string' },
   created: { type: 'number' },
@@ -55,7 +63,11 @@ const fieldDefs = {
   rpmLimit: { type: 'number' },
   tpmLimit: { type: 'number' },
   rateLimitScope: { type: 'string', validate: (v) => ['model', 'provider'].includes(v) ? null : 'must be "model" or "provider"' },
-  supportsTools: { type: 'boolean' }
+  outputCapStrategy: { type: 'string', validate: (v) => ['error', 'accept'].includes(v) ? null : "must be 'error' or 'accept'" },
+  supportsTools: { type: 'boolean' },
+  reasoningContentPlaceholder: { type: 'string' },
+  source: { type: 'string' },
+  sourcedAt: { type: 'string' }
 }
 
 const knownFields = new Set(Object.keys(fieldDefs))
@@ -106,7 +118,7 @@ const validate = (entry, curatedKey, { strict = false } = {}) => {
     if (def.validate) {
       const msg = def.validate(value)
       if (msg) {
-        issues.push({ field, message: msg, severity: 'warn' })
+        issues.push({ field, message: msg, severity: def.severity || 'warn' })
       }
     }