mohdel 0.118.0 → 0.120.0

package/README.md

@@ -101,6 +101,9 @@ mo ask anthropic/claude-sonnet-4-6 --stream "write a haiku about recursion"
 # With thinking effort
 mo ask anthropic/claude-opus-4-6 --effort high "prove P != NP"
 
+# On a faster service lane, when the model sells one
+mo ask anthropic/claude-opus-4-6@fast "triage this alert"
+
 # Speech → text from an audio file
 mo transcribe groq/whisper-large-v3-turbo meeting.mp3
 mo transcribe mistral/voxtral-mini-transcribe interview.wav --language fr
@@ -221,6 +224,8 @@ cargo run --bin mohdel-thin-gate /tmp/mohdel-data.sock /tmp/mohdel-admin.sock /p
 Positional args are optional (data socket, admin socket, session bin). Env overrides:
 - `MOHDEL_SESSION_BIN` — path to session entrypoint (defaults to none; if unset, data plane returns synthetic events)
 - `MOHDEL_SESSION_POOL_SIZE` — pre-warmed sessions (default 2)
+- `MOHDEL_POOL_ACQUIRE_TIMEOUT_MS` — wait for a free session before `503 SESSION_POOL_BUSY` (default 30000)
+- `MOHDEL_MAX_CONNECTIONS` — concurrently served data-plane connections (default 64)
 
 With no session-bin configured, thin-gate runs in demo mode: `POST /v1/call` returns a synthetic echo event sequence. Useful for health-checking the HTTP layer without a runtime dependency on Node.
 
@@ -313,6 +318,8 @@ What each provider supports through mohdel's unified interface:
 
 Adapter capability ≠ model capability — whether a given model accepts images, tools, or thinking effort depends on the model spec in `curated.json`. The adapter passes through what the envelope supplies; the provider rejects unsupported combos.
 
+**Service speeds** are the exception to that pass-through rule. Where a provider sells the same weights at several speeds (Anthropic's fast mode, and equivalents elsewhere), the lanes a model sells are declared in its `curated.json` entry under `speeds`, with their own prices and rate limits. Select one with `speed` or the `@lane` id suffix. There is no default lane and no fallback: an undeclared lane fails the call before it is sent, because a model that silently ignores an unsupported lane would otherwise be billed at the lane's rates for standard service. See [docs/CATALOG.md](docs/CATALOG.md#service-speeds).
+
 ## Local Development
 
 ```bash

package/config/curated.schema.json

@@ -88,6 +88,7 @@
           "description": "USD per 1M thinking/reasoning tokens (when the provider bills these separately)."
         },
         "cacheWritePrice": { "type": "number", "minimum": 0, "description": "USD per 1M tokens written to provider-side prompt cache." },
+        "cacheWrite1hPrice": { "type": "number", "minimum": 0, "description": "USD per 1M tokens written with a 1h TTL, when the provider prices that above the default write rate. Falls back to cacheWritePrice." },
         "cacheReadPrice": { "type": "number", "minimum": 0, "description": "USD per 1M tokens served from provider-side prompt cache." },
 
         "contextTokenLimit": { "type": "integer", "minimum": 1, "description": "Maximum total tokens (input + output)." },
@@ -107,6 +108,43 @@
         },
         "defaultThinkingEffort": { "type": "string", "description": "Effort level used when the envelope omits 'outputEffort'." },
 
+        "speeds": {
+          "type": "object",
+          "description": "Service speed lanes this model sells, keyed by lane name. A lane is a provider request parameter buying a different speed/price point for the same weights. There is no default lane: omitting 'speed' on the envelope sends no parameter. Only lanes declared here may be requested.",
+          "additionalProperties": {
+            "type": "object",
+            "required": ["wire"],
+            "additionalProperties": false,
+            "description": "Lane overlay. Fields named here override the base entry; unnamed fields fall through. Only prices and rate limits are overridable — anything that would change what the model is belongs in its own entry.",
+            "properties": {
+              "wire": { "type": "string", "description": "Provider-native value for the lane parameter (e.g. 'fast')." },
+              "inputPrice": {
+                "oneOf": [
+                  { "type": "number", "minimum": 0 },
+                  { "type": "object", "required": ["default"], "additionalProperties": { "type": "number" }, "properties": { "default": { "type": "number" } } }
+                ]
+              },
+              "outputPrice": {
+                "oneOf": [
+                  { "type": "number", "minimum": 0 },
+                  { "type": "object", "required": ["default"], "additionalProperties": { "type": "number" }, "properties": { "default": { "type": "number" } } }
+                ]
+              },
+              "thinkingPrice": {
+                "oneOf": [
+                  { "type": "number", "minimum": 0 },
+                  { "type": "object", "required": ["default"], "additionalProperties": { "type": "number" }, "properties": { "default": { "type": "number" } } }
+                ]
+              },
+              "cacheWritePrice": { "type": "number", "minimum": 0 },
+              "cacheWrite1hPrice": { "type": "number", "minimum": 0 },
+              "cacheReadPrice": { "type": "number", "minimum": 0 },
+              "rpmLimit": { "type": "integer", "minimum": 1 },
+              "tpmLimit": { "type": "integer", "minimum": 1 }
+            }
+          }
+        },
+
         "tags": {
           "type": "array",
           "items": { "type": "string", "pattern": "^[a-zA-Z][a-zA-Z0-9._-]{0,31}$" },

package/js/client/call.js

@@ -9,6 +9,7 @@
  */
 
 import { requestUnix } from './transport.js'
+import { readAll, parseErrorBody } from './response.js'
 import { parseNDJSON } from './ndjson.js'
 import { isEvent, MohdelError } from '#core'
 
@@ -44,33 +45,3 @@ export async function * call (envelope, { socketPath, signal, path = '/v1/call'
     yield /** @type {import('#core/events.js').Event} */(obj)
   }
 }
-
-/**
- * @param {AsyncIterable<Buffer|string>} stream
- * @returns {Promise<string>}
- */
-async function readAll (stream) {
-  let s = ''
-  for await (const c of stream) s += typeof c === 'string' ? c : c.toString('utf8')
-  return s
-}
-
-/**
- * @param {string} body
- * @param {number} status
- * @returns {import('#core/errors.js').TypedError}
- */
-function parseErrorBody (body, status) {
-  try {
-    const parsed = JSON.parse(body)
-    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
-      return parsed
-    }
-  } catch {}
-  return {
-    type: 'PROTOCOL_HTTP_ERROR',
-    message: `thin-gate returned HTTP ${status}`,
-    severity: 'error',
-    retryable: status >= 500
-  }
-}

package/js/client/call_image.js

@@ -8,6 +8,7 @@
  */
 
 import { requestUnix } from './transport.js'
+import { readAll, parseErrorBody } from './response.js'
 import { MohdelError } from '#core'
 
 /**
@@ -51,33 +52,3 @@ export async function callImage (envelope, { socketPath, signal, path = '/v1/ima
   }
   return parsed
 }
-
-/**
- * @param {AsyncIterable<Buffer|string>} stream
- * @returns {Promise<string>}
- */
-async function readAll (stream) {
-  let s = ''
-  for await (const c of stream) s += typeof c === 'string' ? c : c.toString('utf8')
-  return s
-}
-
-/**
- * @param {string} body
- * @param {number} status
- * @returns {import('#core/errors.js').TypedError}
- */
-function parseErrorBody (body, status) {
-  try {
-    const parsed = JSON.parse(body)
-    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
-      return parsed
-    }
-  } catch {}
-  return {
-    type: 'PROTOCOL_HTTP_ERROR',
-    message: `thin-gate returned HTTP ${status}`,
-    severity: 'error',
-    retryable: status >= 500
-  }
-}

package/js/client/call_transcription.js

@@ -11,6 +11,7 @@
  */
 
 import { requestUnix } from './transport.js'
+import { readAll, parseErrorBody } from './response.js'
 import { MohdelError } from '#core'
 
 /**
@@ -54,33 +55,3 @@ export async function callTranscription (envelope, { socketPath, signal, path =
   }
   return parsed
 }
-
-/**
- * @param {AsyncIterable<Buffer|string>} stream
- * @returns {Promise<string>}
- */
-async function readAll (stream) {
-  let s = ''
-  for await (const c of stream) s += typeof c === 'string' ? c : c.toString('utf8')
-  return s
-}
-
-/**
- * @param {string} body
- * @param {number} status
- * @returns {import('#core/errors.js').TypedError}
- */
-function parseErrorBody (body, status) {
-  try {
-    const parsed = JSON.parse(body)
-    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
-      return parsed
-    }
-  } catch {}
-  return {
-    type: 'PROTOCOL_HTTP_ERROR',
-    message: `thin-gate returned HTTP ${status}`,
-    severity: 'error',
-    retryable: status >= 500
-  }
-}

package/js/client/ndjson.js

@@ -1,10 +1,14 @@
 /**
  * NDJSON line parser. Yields parsed objects from a byte/string stream.
  *
+ * The cap applies to a single unterminated line, not to the accumulated
+ * buffer: a buffer holding several complete frames is a legitimate
+ * burst, not a runaway line.
+ *
  * @module client/ndjson
  */
 
-const MAX_LINE_BYTES = 16 * 1024 * 1024
+import { MAX_LINE_BYTES, exceedsLineBytes } from '#core/framing.js'
 
 /**
  * @param {AsyncIterable<Buffer|string>} stream
@@ -14,15 +18,15 @@ export async function * parseNDJSON (stream) {
   let buf = ''
   for await (const chunk of stream) {
     buf += typeof chunk === 'string' ? chunk : chunk.toString('utf8')
-    if (buf.length > MAX_LINE_BYTES) {
-      throw new Error(`NDJSON line exceeds ${MAX_LINE_BYTES} bytes without newline`)
-    }
     let nl
     while ((nl = buf.indexOf('\n')) !== -1) {
       const line = buf.slice(0, nl).trim()
       buf = buf.slice(nl + 1)
       if (line) yield JSON.parse(line)
     }
+    if (exceedsLineBytes(buf)) {
+      throw new Error(`NDJSON line exceeds ${MAX_LINE_BYTES} bytes without newline`)
+    }
   }
   const tail = buf.trim()
   if (tail) yield JSON.parse(tail)

package/js/client/response.js

@@ -0,0 +1,40 @@
+/**
+ * Shared response handling for the three gate call paths.
+ *
+ * `call.js`, `call_image.js` and `call_transcription.js` each read a
+ * non-200 body the same way and turn it into the same `TypedError`;
+ * keeping one copy means a fix to the error shape cannot land on some
+ * paths and miss others.
+ *
+ * @module client/response
+ */
+
+/**
+ * @param {AsyncIterable<Buffer|string>} stream
+ * @returns {Promise<string>}
+ */
+export async function readAll (stream) {
+  let s = ''
+  for await (const c of stream) s += typeof c === 'string' ? c : c.toString('utf8')
+  return s
+}
+
+/**
+ * @param {string} body
+ * @param {number} status
+ * @returns {import('#core/errors.js').TypedError}
+ */
+export function parseErrorBody (body, status) {
+  try {
+    const parsed = JSON.parse(body)
+    if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
+      return parsed
+    }
+  } catch {}
+  return {
+    type: 'PROTOCOL_HTTP_ERROR',
+    message: `thin-gate returned HTTP ${status}`,
+    severity: 'error',
+    retryable: status >= 500
+  }
+}

package/js/client/transport.js

@@ -39,7 +39,12 @@ export function requestUnix ({ socketPath, path, method, body, signal, headers }
         reject(new Error('aborted'))
         return
       }
-      signal.addEventListener('abort', () => req.destroy(new Error('aborted')), { once: true })
+      const onAbort = () => req.destroy(new Error('aborted'))
+      signal.addEventListener('abort', onAbort, { once: true })
+      // Released on `close` rather than on resolve: the promise
+      // resolves at response headers, and cancellation has to stay
+      // live for the streaming body that follows.
+      req.on('close', () => signal.removeEventListener('abort', onAbort))
     }
 
     if (body !== undefined) req.end(JSON.stringify(body))

package/js/core/envelope.js

@@ -43,6 +43,13 @@
  *   Thinking effort level. Valid keys are per-model — validated at
  *   runtime against the curated entry's `thinkingEffortLevels`.
  *   Default is the model's `defaultThinkingEffort`.
+ * @property {string} [speed]
+ *   Service speed lane. Valid keys are per-model — validated at
+ *   runtime against the curated entry's `speeds`. There is no
+ *   default and no fallback: omitting the field sends no speed
+ *   parameter, while naming a lane the entry does not declare
+ *   (`SESSION_INVALID_SPEED`) or the provider's adapter cannot emit
+ *   (`SESSION_SPEED_NOT_IMPLEMENTED`) fails the call before dispatch.
  *
  * @property {MediaRef[]} [images]
  * @property {MediaRef[]} [videos]
@@ -64,6 +71,7 @@
  *   the gap persists. The consumer decides whether to act (log,
  *   bump a watchdog, abort via its own AbortSignal). Mohdel never
  *   aborts on its own. Omitting the field disables the heartbeat.
+ *   Positive values are raised to `MIN_IDLE_HEARTBEAT_MS` (250).
  *
  * @property {Object<string, object>} [providerOptions]
  *   Namespaced bag of provider-specific knobs that don't fit the
@@ -145,6 +153,7 @@ export const ENVELOPE_FIELDS = Object.freeze([
   'outputType',
   'outputStyle',
   'outputEffort',
+  'speed',
   'images',
   'videos',
   'cache',

package/js/core/framing.js

@@ -0,0 +1,29 @@
+/**
+ * NDJSON framing limits, shared by every JS reader of the protocol.
+ *
+ * The cap bounds a single unterminated line, not accumulated buffered
+ * frames, and is measured in UTF-8 bytes so it matches the gate's
+ * `read_capped_line` (`rust/thin-gate/src/server.rs`), which counts
+ * bytes off the socket. A reader that capped UTF-16 units instead
+ * would accept up to three times what the gate does.
+ *
+ * @module core/framing
+ */
+
+export const MAX_LINE_BYTES = 16 * 1024 * 1024
+
+/**
+ * Exact byte length is O(n) in the string, so it is only computed in
+ * the band where the answer is in doubt: UTF-8 encodes a UTF-16 unit
+ * as 1-3 bytes, which brackets the count between `length` and
+ * `3 * length`.
+ *
+ * @param {string} s
+ * @param {number} [cap]
+ * @returns {boolean}
+ */
+export function exceedsLineBytes (s, cap = MAX_LINE_BYTES) {
+  if (s.length > cap) return true
+  if (s.length * 3 <= cap) return false
+  return Buffer.byteLength(s, 'utf8') > cap
+}

package/js/core/model-id.js

@@ -2,10 +2,10 @@
  * 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.
+ * `"<provider>/<bare>[:<effort>][@<speed>]"` — same on the wire and
+ * in-process. See PROTOCOL §3. Nothing in mohdel ever holds the id in
+ * a split object form; when a part is needed, these helpers return it
+ * as a substring.
  *
  * Ids are validated at ingress by the gate
  * (`rust/thin-gate/src/protocol.rs::validate_ids`); these accessors
@@ -47,12 +47,8 @@ export function bareOf (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
+  const base = beforeSuffix(model, SPEED_SIGIL)
+  return beforeSuffix(base, EFFORT_SIGIL)
 }
 
 /**
@@ -62,8 +58,46 @@ export function catalogKey (model) {
  * @returns {string | undefined}
  */
 export function effortOf (model) {
-  const colon = model.lastIndexOf(':')
+  return afterSuffix(beforeSuffix(model, SPEED_SIGIL), EFFORT_SIGIL)
+}
+
+/**
+ * Speed-lane suffix, without the `@`, or `undefined` if absent.
+ *
+ * @param {string} model
+ * @returns {string | undefined}
+ */
+export function speedOf (model) {
+  return afterSuffix(model, SPEED_SIGIL)
+}
+
+const EFFORT_SIGIL = ':'
+const SPEED_SIGIL = '@'
+
+/**
+ * Index of `sigil` when it separates a suffix, or `-1`. A sigil only
+ * separates when it falls after the provider slash, so a bare id that
+ * itself contains one is left whole.
+ *
+ * @param {string} model
+ * @param {string} sigil
+ * @returns {number}
+ */
+function suffixIndex (model, sigil) {
   const slash = model.indexOf('/')
-  if (colon <= slash) return undefined
-  return model.slice(colon + 1)
+  if (slash < 0) return -1
+  const at = model.lastIndexOf(sigil)
+  return at > slash ? at : -1
+}
+
+/** @returns {string} */
+function beforeSuffix (model, sigil) {
+  const at = suffixIndex(model, sigil)
+  return at < 0 ? model : model.slice(0, at)
+}
+
+/** @returns {string | undefined} */
+function afterSuffix (model, sigil) {
+  const at = suffixIndex(model, sigil)
+  return at < 0 ? undefined : model.slice(at + 1)
 }

package/js/factory/bridge.js

@@ -223,6 +223,7 @@ function toEnvelope ({ modelKey, configuration, prompt, options }) {
   if (options.outputType) envelope.outputType = options.outputType
   if (options.outputStyle) envelope.outputStyle = options.outputStyle
   if (options.outputEffort) envelope.outputEffort = options.outputEffort
+  if (options.speed) envelope.speed = options.speed
   if (options.images?.length) envelope.images = options.images
   if (options.videos?.length) envelope.videos = options.videos
   if (options.cache !== undefined) envelope.cache = options.cache
@@ -281,7 +282,7 @@ function newCallId () {
  */
 const ALLOWED_CONFIG_KEYS = new Set(['apiKey', 'baseURL'])
 
-function configToAuth (configuration) {
+export function configToAuth (configuration) {
   if (!configuration) return { key: '' }
   const unsupported = Object.keys(configuration).filter(k => !ALLOWED_CONFIG_KEYS.has(k))
   if (unsupported.length > 0) {

package/js/session/_idle_heartbeat.js

@@ -11,20 +11,30 @@
  * own. Consumers decide whether to log, bump a watchdog, or trigger
  * an external AbortSignal.
  *
- * The in-flight `iterator.next()` is reused across timer firings so
- * no real event is dropped: when the timer wins the race, the
- * underlying promise stays pending and the next loop iteration
- * attaches a fresh race to the same promise.
+ * `idleMs` is caller-supplied and raised to `MIN_IDLE_HEARTBEAT_MS`.
+ * Without a floor one request can ask for a millisecond cadence and
+ * turn adapter silence into thousands of serialized events per second
+ * through the gate.
+ *
+ * The in-flight `iterator.next()` is reused across timer firings so no
+ * real event is dropped. Its continuation is attached exactly once, at
+ * creation, and parks its result in `settled`; each idle tick races a
+ * fresh timer against that flag rather than re-subscribing. Attaching
+ * per tick instead would retain two reaction records per firing on a
+ * promise that by definition has not settled.
  *
  * @module session/_idle_heartbeat
  */
 
+export const MIN_IDLE_HEARTBEAT_MS = 250
+
 /**
  * @template T
  * @param {AsyncIterable<T>} source
  * @param {number | undefined | null} idleMs
  *   When falsy or non-positive, the source is yielded through
- *   unchanged (no timer is set up).
+ *   unchanged (no timer is set up). Positive values below
+ *   `MIN_IDLE_HEARTBEAT_MS` are raised to it.
  * @returns {AsyncGenerator<T | import('#core/events.js').IdleEvent>}
  */
 export async function * withIdleHeartbeat (source, idleMs) {
@@ -33,28 +43,45 @@ export async function * withIdleHeartbeat (source, idleMs) {
     return
   }
 
+  const tickMs = Math.max(idleMs, MIN_IDLE_HEARTBEAT_MS)
   const iter = source[Symbol.asyncIterator]()
   let lastAt = Date.now()
-  /** @type {Promise<IteratorResult<T>> | null} */
-  let pending = null
+
+  /** @type {{real: IteratorResult<T>} | {err: unknown} | null} */
+  let settled = null
+  /** @type {(() => void) | null} */
+  let wake = null
+  let inFlight = false
+
+  const park = (result) => {
+    settled = result
+    const w = wake
+    wake = null
+    w?.()
+  }
 
   try {
     while (true) {
-      if (!pending) pending = iter.next()
-
-      /** @type {NodeJS.Timeout | undefined} */
-      let timer
-      /** @type {{idle: true} | {real: IteratorResult<T>} | {err: unknown}} */
-      const winner = await new Promise(resolve => {
-        timer = setTimeout(() => resolve({ idle: true }), idleMs)
-        pending.then(
-          r => resolve({ real: r }),
-          e => resolve({ err: e })
+      if (!inFlight) {
+        inFlight = true
+        iter.next().then(
+          r => park({ real: r }),
+          e => park({ err: e })
         )
-      })
-      clearTimeout(timer)
+      }
+
+      if (!settled) {
+        /** @type {NodeJS.Timeout | undefined} */
+        let timer
+        await new Promise(resolve => {
+          wake = resolve
+          timer = setTimeout(resolve, tickMs)
+        })
+        clearTimeout(timer)
+        wake = null
+      }
 
-      if ('idle' in winner) {
+      if (!settled) {
         yield /** @type {import('#core/events.js').IdleEvent} */ ({
           type: 'idle',
           sinceMs: Date.now() - lastAt
@@ -62,11 +89,13 @@ export async function * withIdleHeartbeat (source, idleMs) {
         continue
       }
 
-      pending = null
-      if ('err' in winner) throw winner.err
-      if (winner.real.done) return
+      const done = settled
+      settled = null
+      inFlight = false
+      if ('err' in done) throw done.err
+      if (done.real.done) return
       lastAt = Date.now()
-      yield winner.real.value
+      yield done.real.value
     }
   } finally {
     // Best-effort cleanup if the consumer abandons us mid-stream.

package/js/session/adapters/_cancelled.js

@@ -13,7 +13,6 @@
 
 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
@@ -43,7 +42,7 @@ export function cancelledDone (start, first, envelope, output, inputTokens, outp
       ...(cacheWriteInputTokens > 0 && { cacheWriteInputTokens }),
       ...(cacheReadInputTokens > 0 && { cacheReadInputTokens }),
       cost: costFor(
-        catalogKey(envelope.model),
+        envelope,
         { inputTokens, outputTokens, thinkingTokens: 0, cacheWriteInputTokens, cacheReadInputTokens }
       ),
       timestamps: { start, first: first ?? end, end },

package/js/session/adapters/_catalog.js

@@ -12,7 +12,10 @@
 
 import envPaths from 'env-paths'
 
+import { catalogKey } from '#core/model-id.js'
+
 import { createLazyJsonFileCache } from './_lazy_json_cache.js'
+import { mergeSpeed } from './_speed.js'
 
 // `{ suffix: null }` mirrors `src/lib/common.js::CONFIG_DIR` so the
 // session subprocess reads the same `~/.config/mohdel/curated.json`
@@ -56,3 +59,16 @@ export function setCatalog (table) {
 export function getSpec (model) {
   return cache.get(model)
 }
+
+/**
+ * Effective spec for a call: the catalog entry with any speed-lane
+ * overlay applied. Adapters resolve spec through this rather than
+ * `getSpec` so lane prices and quotas reach pricing and throttling
+ * without each adapter merging for itself.
+ *
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @returns {any | undefined}
+ */
+export function specFor (envelope) {
+  return mergeSpeed(getSpec(catalogKey(envelope.model)), envelope.speed)
+}

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 { applySpeed } from './_speed.js'
 import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   STATUS_COMPLETED,
@@ -287,7 +288,7 @@ function finalize ({ envelope, content, toolCalls, usage, finishReason, start, f
       thinkingTokens,
       ...(cachedInputTokens > 0 && { cacheReadInputTokens: cachedInputTokens }),
       cost: costFor(
-        catalogKey(envelope.model),
+        envelope,
         {
           inputTokens,
           outputTokens: visibleOutputTokens,
@@ -370,6 +371,8 @@ function buildRequest (envelope, spec, config) {
     args[config.identifierField || 'user'] = envelope.identifier
   }
 
+  applySpeed(args, envelope, spec)
+
   return args
 }