mohdel 0.93.0 → 0.95.0

package/js/core/envelope.js

@@ -23,8 +23,11 @@
  * @property {string} [traceparent]  W3C tracecontext header.
  * @property {string} [baggage]      W3C baggage header.
  *
- * @property {string} provider       Adapter discriminator.
- * @property {string} model          Provider-native model id.
+ * @property {import('./model-id.js').ModelId} model
+ *   Full mohdel id — `"<provider>/<bare>[:<effort>]"`. Same shape
+ *   on the wire and in-process. See PROTOCOL §3. No separate
+ *   `provider` field exists at any layer; callers that need the
+ *   provider or bare part use the helpers in `core/model-id.js`.
  *
  * @property {(string|Message[])} prompt
  *   Either a plain string or a structured array of messages.
@@ -123,7 +126,6 @@ export const ENVELOPE_FIELDS = Object.freeze([
   'auth',
   'traceparent',
   'baggage',
-  'provider',
   'model',
   'prompt',
   'outputBudget',

package/js/core/image.js

@@ -17,8 +17,10 @@
  * @property {string} [traceparent]
  * @property {string} [baggage]
  *
- * @property {string} provider
- * @property {string} model
+ * @property {import('./model-id.js').ModelId} model
+ *   Full mohdel id — `"<provider>/<bare>"`. Same shape as
+ *   `CallEnvelope.model` (see `envelope.js`). No separate `provider`
+ *   field.
  * @property {string} prompt
  *
  * @property {string} [size]       e.g. "1024x1024". Provider-specific.
@@ -50,7 +52,6 @@ export const IMAGE_ENVELOPE_FIELDS = Object.freeze([
   'auth',
   'traceparent',
   'baggage',
-  'provider',
   'model',
   'prompt',
   'size',

package/js/core/model-id.js

@@ -0,0 +1,92 @@
+/**
+ * Model-id helpers.
+ *
+ * A mohdel model id is a single string of shape
+ * `"<provider>/<bare>[:<effort>]"` — same on the wire and in-process.
+ * See PROTOCOL §3. Nothing in mohdel ever holds the id in a split
+ * object form; when the provider or bare part is needed, these
+ * helpers return it as a substring.
+ *
+ * `parseModelId` validates + brands at the boundary (factory input,
+ * wire deserialize, admin endpoints). After that every `ModelId` in
+ * memory is known-valid; adapters and core code call the accessors
+ * freely without re-validating.
+ *
+ * @module core/model-id
+ */
+
+/**
+ * Branded string type. Only `parseModelId` produces one.
+ * @typedef {string & { __brand: 'ModelId' }} ModelId
+ */
+
+const MODEL_ID_RE = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9._-]*(?::[a-z]+)?$/i
+
+/**
+ * Validate and brand a raw string. Throws on malformed input so the
+ * boundary layer fails loudly instead of letting a bad id flow
+ * through.
+ *
+ * @param {string} raw
+ * @returns {ModelId}
+ */
+export function parseModelId (raw) {
+  if (typeof raw !== 'string' || !MODEL_ID_RE.test(raw)) {
+    throw new TypeError(`invalid model id: ${JSON.stringify(raw)} (expected "<provider>/<bare>[:<effort>]")`)
+  }
+  return /** @type {ModelId} */ (raw)
+}
+
+/**
+ * Provider segment of a model id.
+ * @param {ModelId | string} model
+ * @returns {string}
+ */
+export function providerOf (model) {
+  const slash = model.indexOf('/')
+  return slash > 0 ? model.slice(0, slash) : ''
+}
+
+/**
+ * Bare id (everything after the provider slash), including any
+ * `:effort` suffix. Callers that want effort stripped use
+ * `catalogKey()` instead.
+ *
+ * @param {ModelId | string} model
+ * @returns {string}
+ */
+export function bareOf (model) {
+  const slash = model.indexOf('/')
+  return slash >= 0 ? model.slice(slash + 1) : model
+}
+
+/**
+ * The catalog key: `<provider>/<bare>` with any `:effort` suffix
+ * removed. This is the key under which prices, thinking levels,
+ * output limits etc. are stored — per-effort variants do not get
+ * their own entry.
+ *
+ * @param {ModelId | string} model
+ * @returns {string}
+ */
+export function catalogKey (model) {
+  const colon = model.lastIndexOf(':')
+  const slash = model.indexOf('/')
+  // Only treat `:` as an effort separator when it appears after the
+  // provider slash (otherwise a model id without `/` that happens to
+  // contain `:` would get the wrong thing stripped).
+  return colon > slash ? model.slice(0, colon) : model
+}
+
+/**
+ * Effort suffix, without the `:`, or `undefined` if absent.
+ *
+ * @param {ModelId | string} model
+ * @returns {string | undefined}
+ */
+export function effortOf (model) {
+  const colon = model.lastIndexOf(':')
+  const slash = model.indexOf('/')
+  if (colon <= slash) return undefined
+  return model.slice(colon + 1)
+}

package/js/factory/bridge.js

@@ -137,8 +137,7 @@ export async function runAnswerImage ({ provider, model, configuration, prompt,
     callId: options.callId || newCallId(),
     authId: options.authId || 'local',
     auth: configToAuth(configuration),
-    provider,
-    model,
+    model: `${provider}/${model}`,
     prompt
   }
   if (options.size) envelope.size = options.size
@@ -164,8 +163,7 @@ function toEnvelope ({ provider, model, configuration, prompt, options }) {
     callId: options.callId || newCallId(),
     authId: options.authId || 'local',
     auth: configToAuth(configuration),
-    provider,
-    model,
+    model: /** @type {import('#core/model-id.js').ModelId} */ (`${provider}/${model}`),
     prompt: toEnvelopePrompt(prompt)
   }
 

package/js/session/adapters/_cancelled.js

@@ -13,6 +13,7 @@
 
 import { STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core/status.js'
 import { costFor } from './_pricing.js'
+import { catalogKey } from '#core/model-id.js'
 
 /**
  * @param {string} start       hrtime-bigint-as-string at call entry
@@ -34,7 +35,7 @@ export function cancelledDone (start, first, envelope, output, inputTokens, outp
       outputTokens,
       thinkingTokens: 0,
       cost: costFor(
-        `${envelope.provider}/${envelope.model}`,
+        catalogKey(envelope.model),
         { inputTokens, outputTokens, thinkingTokens: 0 }
       ),
       timestamps: { start, first: first ?? end, end },

package/js/session/adapters/_chat_completions.js

@@ -19,6 +19,7 @@
 import { getSpec } from './_catalog.js'
 import { classifyProviderError } from './_errors.js'
 import { costFor } from './_pricing.js'
+import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   STATUS_COMPLETED,
   STATUS_INCOMPLETE,
@@ -78,7 +79,7 @@ const DSML_PARAM_RE = /<\uFF5CDSML\uFF5Cparameter\s+name="([^"]+)"(?:\s+string="
  * @returns {AsyncGenerator<import('#core/events.js').Event>}
  */
 export async function * runChatCompletions (envelope, client, config, deps = {}) {
-  const spec = getSpec(`${envelope.provider}/${envelope.model}`) || {}
+  const spec = getSpec(catalogKey(envelope.model)) || {}
   const start = String(process.hrtime.bigint())
 
   const args = buildRequest(envelope, spec, config)
@@ -263,7 +264,7 @@ function finalize ({ envelope, content, toolCalls, usage, finishReason, start, f
       outputTokens: visibleOutputTokens,
       thinkingTokens,
       cost: costFor(
-        `${envelope.provider}/${envelope.model}`,
+        catalogKey(envelope.model),
         { inputTokens, outputTokens: visibleOutputTokens, thinkingTokens }
       ),
       timestamps: { start, first: first ?? end, end }
@@ -284,7 +285,7 @@ function finalize ({ envelope, content, toolCalls, usage, finishReason, start, f
 function buildRequest (envelope, spec, config) {
   /** @type {Record<string, any>} */
   const args = {
-    model: envelope.model,
+    model: spec?.model ?? bareOf(envelope.model),
     temperature: 0,
     messages: toChatMessages(envelope.prompt)
   }
@@ -319,7 +320,7 @@ function buildRequest (envelope, spec, config) {
         args.max_tokens += headroom
       }
       delete args.temperature
-      if (config.reasoningField === 'cerebras_zai' && /zai/i.test(envelope.model)) {
+      if (config.reasoningField === 'cerebras_zai' && /zai/i.test(bareOf(envelope.model))) {
         args.disable_reasoning = false
       } else {
         args.reasoning_effort = effort

package/js/session/adapters/_pricing.js

@@ -14,6 +14,19 @@ import { getSpec, setCatalog } from './_catalog.js'
 /**
  * Pure cost computation from spec + usage.
  *
+ * Each price field (`inputPrice` / `outputPrice` / `thinkingPrice`) is
+ * one of:
+ *
+ *   - a `number` — flat per-million rate; or
+ *   - an object `{">N": number, ..., "default": number}` — tiered.
+ *     The active rate is the one under the highest `>N` key that the
+ *     call's `inputTokens` exceeds; falls back to `"default"` when
+ *     nothing matches. Keys that aren't `">N"` or `"default"` are
+ *     ignored. `>` is strict — at exactly N, the default is used.
+ *
+ * `thinkingPrice` is optional and falls back to the resolved
+ * `outputPrice` when absent.
+ *
  * @param {any} spec  Catalog entry (with `inputPrice`/`outputPrice`/`thinkingPrice`),
  *                    or `undefined`.
  * @param {{inputTokens?: number, outputTokens?: number, thinkingTokens?: number}} usage
@@ -21,17 +34,50 @@ import { getSpec, setCatalog } from './_catalog.js'
  */
 export function computeCost (spec, usage) {
   if (!spec) return 0
-  const ip = spec.inputPrice
-  const op = spec.outputPrice
-  if (typeof ip !== 'number' || typeof op !== 'number') return 0
   const i = usage.inputTokens ?? 0
   const o = usage.outputTokens ?? 0
   const t = usage.thinkingTokens ?? 0
-  const tp = typeof spec.thinkingPrice === 'number' ? spec.thinkingPrice : op
-  const total = (i * ip + o * op + t * tp) / 1_000_000
+  const ip = resolveTier(spec.inputPrice, i)
+  const op = resolveTier(spec.outputPrice, i)
+  if (typeof ip !== 'number' || typeof op !== 'number') return 0
+  const tp = resolveTier(spec.thinkingPrice, i)
+  const tpFinal = typeof tp === 'number' ? tp : op
+  const total = (i * ip + o * op + t * tpFinal) / 1_000_000
   return round(total)
 }
 
+/**
+ * Resolve a price field against a token count. Scalars pass through;
+ * tiered maps return the rate of the highest `>N` key that
+ * `tokens` exceeds, falling back to `default`. Returns `null` when
+ * the field is absent or malformed — callers decide whether to treat
+ * that as "no price" (cost=0) or fall back (thinkingPrice→outputPrice).
+ *
+ * @param {unknown} price
+ * @param {number} tokens
+ * @returns {number | null}
+ */
+function resolveTier (price, tokens) {
+  if (typeof price === 'number') return price
+  if (!price || typeof price !== 'object') return null
+  let best = null
+  let bestThreshold = -1
+  for (const key of Object.keys(price)) {
+    if (key === 'default') continue
+    const m = /^>(\d+)$/.exec(key)
+    if (!m) continue
+    const threshold = Number(m[1])
+    if (tokens > threshold && threshold > bestThreshold) {
+      bestThreshold = threshold
+      const v = /** @type {Record<string, unknown>} */ (price)[key]
+      if (typeof v === 'number') best = v
+    }
+  }
+  if (best != null) return best
+  const d = /** @type {Record<string, unknown>} */ (price).default
+  return typeof d === 'number' ? d : null
+}
+
 /**
  * @param {string} model  Fully-qualified `<provider>/<model>`.
  * @param {{inputTokens?: number, outputTokens?: number, thinkingTokens?: number}} usage

package/js/session/adapters/anthropic.js

@@ -28,6 +28,7 @@ import { getSpec } from './_catalog.js'
 import { classifyProviderError } from './_errors.js'
 import { loadImages } from './_images.js'
 import { costFor } from './_pricing.js'
+import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   toAnthropicTools,
   fromAnthropicToolCalls,
@@ -216,7 +217,7 @@ export async function * anthropic (envelope, deps = {}) {
       outputTokens: messageOutputTokens,
       thinkingTokens: estimatedThinkingTokens,
       cost: costFor(
-        `${envelope.provider}/${envelope.model}`,
+        catalogKey(envelope.model),
         { inputTokens, outputTokens: messageOutputTokens, thinkingTokens: estimatedThinkingTokens }
       ),
       timestamps: { start, first: first ?? end, end }
@@ -253,12 +254,12 @@ function safeParseJson (s) {
  * @param {string} system
  */
 function buildRequest (envelope, conversation, system) {
-  const spec = getSpec(`${envelope.provider}/${envelope.model}`)
+  const spec = getSpec(catalogKey(envelope.model))
   const outputTokenLimit = spec?.outputTokenLimit
 
   /** @type {Record<string, any>} */
   const request = {
-    model: envelope.model,
+    model: spec?.model ?? bareOf(envelope.model),
     max_tokens: envelope.outputBudget ?? outputTokenLimit ?? ANTHROPIC_DEFAULT_MAX_TOKENS,
     messages: conversation
   }

package/js/session/adapters/gemini.js

@@ -30,6 +30,7 @@ import { classifyProviderError } from './_errors.js'
 import { loadImages } from './_images.js'
 import { loadVideos } from './_videos.js'
 import { costFor } from './_pricing.js'
+import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   toGeminiTools,
   fromGeminiToolCalls,
@@ -195,7 +196,7 @@ export async function * gemini (envelope, deps = {}) {
       outputTokens,
       thinkingTokens,
       cost: costFor(
-        `${envelope.provider}/${envelope.model}`,
+        catalogKey(envelope.model),
         { inputTokens, outputTokens, thinkingTokens }
       ),
       timestamps: { start, first: first ?? end, end }
@@ -214,7 +215,7 @@ export async function * gemini (envelope, deps = {}) {
  * @param {string} systemInstruction
  */
 function buildRequest (envelope, contents, systemInstruction) {
-  const spec = getSpec(`${envelope.provider}/${envelope.model}`)
+  const spec = getSpec(catalogKey(envelope.model))
 
   /** @type {Record<string, any>} */
   const config = {}
@@ -235,9 +236,10 @@ function buildRequest (envelope, contents, systemInstruction) {
   const effort = envelope.outputEffort ?? spec?.defaultThinkingEffort
   if (spec?.thinkingEffortLevels && effort && effort !== 'none') {
     const budget = spec.thinkingEffortLevels[effort]
-    if (/^gemini-3/.test(envelope.model)) {
+    const bare = bareOf(envelope.model)
+    if (/^gemini-3/.test(bare)) {
       config.thinkingConfig = { includeThoughts: true, thinkingLevel: effort }
-    } else if (/gemini-2/.test(envelope.model)) {
+    } else if (/gemini-2/.test(bare)) {
       if (typeof budget === 'number') {
         config.thinkingConfig = { thinkingBudget: budget }
       }
@@ -253,7 +255,7 @@ function buildRequest (envelope, contents, systemInstruction) {
 
   /** @type {Record<string, any>} */
   const request = {
-    model: envelope.model,
+    model: spec?.model ?? bareOf(envelope.model),
     contents
   }
   if (Object.keys(config).length > 0) request.config = config

package/js/session/adapters/image/novita.js

@@ -12,6 +12,7 @@
 
 import { getSpec } from '../_catalog.js'
 import { classifyProviderError } from '../_errors.js'
+import { catalogKey } from '#core/model-id.js'
 
 const BASE_URL = 'https://api.novita.ai'
 const NOVITA_TASK_POLL_INTERVAL_MS = 1000
@@ -32,7 +33,7 @@ export async function novitaImage (envelope, deps = {}) {
   const sleep = deps.sleep ?? defaultSleep
   const now = deps.now ?? Date.now
 
-  const spec = deps.spec ?? getSpec(`${envelope.provider}/${envelope.model}`) ?? {}
+  const spec = deps.spec ?? getSpec(catalogKey(envelope.model)) ?? {}
   const endpoint = spec.imageEndpoint
   if (!endpoint) {
     throw typedError('image endpoint not configured', 'PROVIDER_ERROR', false)

package/js/session/adapters/image/openai.js

@@ -10,6 +10,7 @@ import OpenAI from 'openai'
 
 import { getSpec } from '../_catalog.js'
 import { classifyProviderError } from '../_errors.js'
+import { catalogKey, bareOf } from '#core/model-id.js'
 
 /**
  * @param {import('#core/image.js').ImageEnvelope} envelope
@@ -18,10 +19,10 @@ import { classifyProviderError } from '../_errors.js'
  */
 export async function openaiImage (envelope, deps = {}) {
   const client = deps.client ?? new OpenAI({ apiKey: envelope.auth.key })
-  const spec = deps.spec ?? getSpec(`${envelope.provider}/${envelope.model}`) ?? {}
+  const spec = deps.spec ?? getSpec(catalogKey(envelope.model)) ?? {}
   const start = String(process.hrtime.bigint())
 
-  const args = { model: envelope.model, prompt: envelope.prompt }
+  const args = { model: spec.model ?? bareOf(envelope.model), prompt: envelope.prompt }
   const size = envelope.size || spec.imageDefaultSize
   if (size) args.size = size
 

package/js/session/adapters/index.js

@@ -1,5 +1,5 @@
 /**
- * Adapter registry. Maps `envelope.provider` to an adapter function.
+ * Adapter registry. Maps `providerOf(envelope.model)` to an adapter function.
  *
  * Each adapter has the shape:
  *   async function* adapter(envelope) => AsyncGenerator<Event>

package/js/session/adapters/openai.js

@@ -29,6 +29,7 @@ import { getSpec } from './_catalog.js'
 import { classifyProviderError } from './_errors.js'
 import { loadImages } from './_images.js'
 import { costFor } from './_pricing.js'
+import { catalogKey, providerOf, bareOf } from '#core/model-id.js'
 import {
   toOpenAITools,
   fromOpenAIToolCalls,
@@ -181,7 +182,7 @@ export async function * openai (envelope, deps = {}) {
       outputTokens: messageOutputTokens,
       thinkingTokens,
       cost: costFor(
-        `${envelope.provider}/${envelope.model}`,
+        catalogKey(envelope.model),
         { inputTokens, outputTokens: messageOutputTokens, thinkingTokens }
       ),
       timestamps: { start, first: first ?? end, end }
@@ -200,11 +201,12 @@ export async function * openai (envelope, deps = {}) {
  * @param {string} instructions
  */
 function buildRequest (envelope, input, instructions) {
-  const spec = getSpec(`${envelope.provider}/${envelope.model}`)
+  const spec = getSpec(catalogKey(envelope.model))
+  const provider = providerOf(envelope.model)
 
   /** @type {Record<string, any>} */
   const request = {
-    model: envelope.model,
+    model: spec?.model ?? bareOf(envelope.model),
     input
   }
   if (instructions) request.instructions = instructions
@@ -231,7 +233,7 @@ function buildRequest (envelope, input, instructions) {
       if (request.max_output_tokens && typeof headroom === 'number') {
         request.max_output_tokens += headroom
       }
-      if (envelope.provider === 'openai') {
+      if (provider === 'openai') {
         request.reasoning = { effort }
       }
     }
@@ -253,7 +255,7 @@ function buildRequest (envelope, input, instructions) {
   // Per-user identifier — openai uses `safety_identifier`; other
   // Responses-API providers (xai) use the legacy `user` field.
   if (envelope.identifier) {
-    if (envelope.provider === 'openai') {
+    if (provider === 'openai') {
       request.safety_identifier = envelope.identifier
     } else {
       request.user = envelope.identifier

package/js/session/adapters/xai.js

@@ -1,7 +1,7 @@
 /**
  * xAI adapter — OpenAI Responses API over x.ai/v1. Delegates to the
  * `openai` adapter with a baseURL-configured client; the openai
- * adapter branches on `envelope.provider === 'openai'` for fields
+ * adapter branches on `providerOf(envelope.model) === 'openai'` for fields
  * that differ between vendors (reasoning param, safety_identifier).
  *
  * @module session/adapters/xai

package/js/session/run.js

@@ -26,6 +26,7 @@ import { getAdapter } from './adapters/index.js'
 import { isImageProvider } from './adapters/image/index.js'
 import { getSpec } from './adapters/_catalog.js'
 import { getProviderLimits } from './adapters/_providers.js'
+import { providerOf, catalogKey, effortOf } from '#core/model-id.js'
 import * as defaultCooldown from './_cooldown.js'
 import * as defaultLimiter from './_rate_limiter.js'
 import { logger as defaultLogger } from './_logger.js'
@@ -74,12 +75,13 @@ export async function * run (envelope, {
   if (effortNorm.error) { yield effortNorm.error; return }
   envelope = effortNorm.envelope
 
+  const provider = providerOf(envelope.model)
   const span = openSpan(envelope)
   const log = scopedLogger(logger, envelope, span)
   const startedAt = Date.now()
 
   log.debug({
-    provider: envelope.provider,
+    provider,
     model: envelope.model,
     effort: envelope.outputEffort ?? 'default',
     outputBudget: envelope.outputBudget ?? null,
@@ -89,43 +91,57 @@ export async function * run (envelope, {
 
   let adapter
   try {
-    adapter = resolveAdapter(envelope.provider)
+    adapter = resolveAdapter(provider)
   } catch (e) {
     // Distinguish "image-only provider invoked via answer" from
     // truly-unknown. Novita-and-friends have no text adapter but a
     // caller using `mohdel.use('novita/...').answer(...)` otherwise
     // gets a bare "unknown provider" with no hint.
-    if (isImageProvider(envelope.provider)) {
-      const detail = `provider '${envelope.provider}' supports image generation only; use mohdel.image(...) instead`
+    if (isImageProvider(provider)) {
+      const detail = `provider '${provider}' supports image generation only; use mohdel.image(...) instead`
       const err = errorEvent(detail, 'PROVIDER_TEXT_NOT_SUPPORTED')
-      log.warn({ provider: envelope.provider }, '[mohdel:answer] image-only provider via answer')
+      log.warn({ provider }, '[mohdel:answer] image-only provider via answer')
       endSpanError(span, new Error(detail))
       yield err
       return
     }
     const err = errorEvent(messageOf(e), 'SESSION_UNKNOWN_PROVIDER')
-    log.warn({ err: e, provider: envelope.provider }, '[mohdel:answer] unknown provider')
+    log.warn({ err: e, provider }, '[mohdel:answer] unknown provider')
     endSpanError(span, e)
     yield err
     return
   }
 
-  const coolErr = cooldown.coolingDownError(envelope.provider)
+  // Catalog is authoritative: every callable model must have a
+  // spec. Without one we'd silently run the provider call with
+  // defaults (no rate-limits, no budget clamps, cost=0), masking
+  // misconfiguration in the layer that pushed the catalog. Effort
+  // suffix is stripped for the lookup — catalog entries are keyed
+  // by the bare `<provider>/<bare>` id, not per-effort variants.
+  const key = catalogKey(envelope.model)
+  const spec = resolveSpec(key)
+  if (!spec) {
+    const detail = `Unknown model '${key}' — not in catalog`
+    const err = errorEvent(detail, 'SESSION_UNKNOWN_MODEL')
+    log.warn({ provider, model: envelope.model }, '[mohdel:answer] unknown model')
+    endSpanError(span, new Error(detail))
+    yield err
+    return
+  }
+
+  const coolErr = cooldown.coolingDownError(provider)
   if (coolErr) {
-    log.debug({ provider: envelope.provider, detail: coolErr.detail }, '[mohdel:cooldown] fast-fail')
+    log.debug({ provider, detail: coolErr.detail }, '[mohdel:cooldown] fast-fail')
     span.setAttribute('mohdel.cooldown', true)
     endSpanOk(span, { 'mohdel.status': 'cooldown' })
     yield { type: 'error', error: coolErr }
     return
   }
 
-  const spec = resolveSpec(`${envelope.provider}/${envelope.model}`)
-  const providerCfg = resolveProviderLimits(envelope.provider) || {}
+  const providerCfg = resolveProviderLimits(provider) || {}
   const rpmLimit = spec?.rpmLimit ?? providerCfg.rpmLimit
   const tpmLimit = spec?.tpmLimit ?? providerCfg.tpmLimit
-  const bucketKey = (spec?.rateLimitScope === 'model')
-    ? `${envelope.provider}/${envelope.model}`
-    : envelope.provider
+  const bucketKey = (spec?.rateLimitScope === 'model') ? key : provider
 
   // `0` is a killswitch ("deny all"), not "unset"; `undefined`/`null`
   // means no limit configured for that dimension. Gate on nullability
@@ -175,7 +191,7 @@ export async function * run (envelope, {
         // incomplete-budget / tool_use) IS a genuine provider-side
         // success and resets the streak.
         if (ev.result?.warning !== WARNING_CANCELLED) {
-          cooldown.reset(envelope.provider)
+          cooldown.reset(provider)
         }
         if (tpmLimit != null && ev.result) {
           const total =
@@ -192,10 +208,10 @@ export async function * run (envelope, {
         log.debug(summarizeDone(ev.result, startedAt), '[mohdel:answer] done')
       } else if (ev.type === 'error') {
         sawTerminal = true
-        recordFailureFromError(cooldown, envelope.provider, ev.error)
+        recordFailureFromError(cooldown, provider, ev.error)
         log.warn({
           err: ev.error,
-          provider: envelope.provider,
+          provider,
           totalMs: Date.now() - startedAt,
           maxInterFrameMs
         }, '[mohdel:answer] failed')
@@ -211,7 +227,7 @@ export async function * run (envelope, {
       yield fallback
       return
     }
-    log.warn({ err: e, provider: envelope.provider, maxInterFrameMs }, '[mohdel:answer] adapter threw')
+    log.warn({ err: e, provider, maxInterFrameMs }, '[mohdel:answer] adapter threw')
     endSpanError(span, e)
     yield errorEvent(messageOf(e), 'SESSION_ADAPTER_THREW')
     return
@@ -225,7 +241,7 @@ export async function * run (envelope, {
       yield fallback
     } else {
       const err = 'adapter returned without a terminal event'
-      log.error({ provider: envelope.provider, maxInterFrameMs }, '[mohdel:answer] no terminal event')
+      log.error({ provider, maxInterFrameMs }, '[mohdel:answer] no terminal event')
       endSpanError(span, new Error(err))
       yield errorEvent(err, 'SESSION_ADAPTER_NO_TERMINAL')
     }
@@ -246,21 +262,19 @@ export async function * run (envelope, {
  * }}
  */
 function normalizeModelEffort (envelope, resolveSpec) {
-  const modelStr = envelope.model || ''
-  const colonIdx = modelStr.lastIndexOf(':')
-  if (colonIdx <= 0) return { envelope }
+  const candidate = effortOf(envelope.model)
+  if (!candidate) return { envelope }
   if (envelope.outputEffort) return { envelope } // explicit wins
 
-  const candidate = modelStr.slice(colonIdx + 1)
-  const base = modelStr.slice(0, colonIdx)
-  const baseSpec = resolveSpec(`${envelope.provider}/${base}`)
+  const base = catalogKey(envelope.model)
+  const baseSpec = resolveSpec(base)
   if (!baseSpec) return { envelope } // base not known — let full string fall through to not-found
 
   if (!baseSpec.thinkingEffortLevels) {
     return {
       envelope,
       error: errorEvent(
-        `Model '${envelope.provider}/${base}' does not support output effort (no thinkingEffortLevels). Cannot use ':${candidate}' suffix.`,
+        `Model '${base}' does not support output effort (no thinkingEffortLevels). Cannot use ':${candidate}' suffix.`,
         'SESSION_INVALID_OUTPUT_EFFORT'
       )
     }
@@ -269,7 +283,7 @@ function normalizeModelEffort (envelope, resolveSpec) {
     return {
       envelope,
       error: errorEvent(
-        `Model '${envelope.provider}/${base}' does not support output effort level '${candidate}'. Available: ${Object.keys(baseSpec.thinkingEffortLevels).join(', ')}`,
+        `Model '${base}' does not support output effort level '${candidate}'. Available: ${Object.keys(baseSpec.thinkingEffortLevels).join(', ')}`,
         'SESSION_INVALID_OUTPUT_EFFORT'
       )
     }
@@ -290,7 +304,7 @@ function openSpan (envelope) {
   /** @type {Record<string, any>} */
   const attrs = {
     'gen_ai.request.model': envelope.model,
-    'gen_ai.system': envelope.provider,
+    'gen_ai.system': providerOf(envelope.model),
     'mohdel.call_id': envelope.callId,
     'mohdel.auth_id': envelope.authId
   }
@@ -309,7 +323,7 @@ function scopedLogger (logger, envelope, span) {
   return logger.withContext({
     callId: envelope.callId,
     authId: envelope.authId,
-    provider: envelope.provider,
+    provider: providerOf(envelope.model),
     model: envelope.model,
     traceId: ctx.traceId,
     spanId: ctx.spanId

package/js/session/run_image.js

@@ -15,6 +15,7 @@
 
 import { getImageAdapter } from './adapters/image/index.js'
 import { classifyProviderError } from './adapters/_errors.js'
+import { providerOf } from '#core/model-id.js'
 
 /**
  * @param {import('#core/image.js').ImageEnvelope} envelope
@@ -33,7 +34,7 @@ import { classifyProviderError } from './adapters/_errors.js'
 export async function runImage (envelope, { resolveAdapter = getImageAdapter, spec } = {}) {
   let adapter
   try {
-    adapter = resolveAdapter(envelope.provider)
+    adapter = resolveAdapter(providerOf(envelope.model))
   } catch (e) {
     return {
       ok: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "0.93.0",
+  "version": "0.95.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -87,7 +87,7 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.215.0",
     "@opentelemetry/sdk-node": "^0.215.0",
     "chalk": "^5.4.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.93.0"
+    "mohdel-thin-gate-linux-x64-gnu": "0.95.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.91.0",
@@ -103,7 +103,7 @@
   },
   "devDependencies": {
     "lint-staged": "^16.4.0",
-    "release-it": "^20.0.0",
+    "release-it": "^20.0.1",
     "standard": "^17.1.2",
     "vitest": "^4.1.5"
   }