mohdel 1.2.0 → 1.3.1

package/config/curated.schema.json

@@ -553,12 +553,17 @@
         "rpmLimit": {
           "type": "integer",
           "minimum": 1,
-          "description": "Requests per minute. Overrides provider default."
+          "description": "Requests per minute this key may send. Overrides the provider-level default."
         },
         "tpmLimit": {
           "type": "integer",
           "minimum": 1,
-          "description": "Tokens per minute. Overrides provider default."
+          "description": "Tokens per minute this key may spend. Overrides the provider-level default."
+        },
+        "inpmLimit": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "Inputs per minute this key may send to an embedding endpoint, for a provider that meters the endpoint in inputs rather than requests or tokens (Cohere publishes '2,000 inputs / min'). Counted exactly before dispatch from the batch size; a batch larger than the whole allowance is sent rather than delayed, since waiting cannot make it fit."
         },
         "rateLimitScope": {
           "type": "string",
@@ -566,7 +571,7 @@
             "model",
             "provider"
           ],
-          "description": "'model' = private budget. 'provider' = shared with provider-level pool."
+          "description": "Whose budget this key's calls draw on: 'model' = a private bucket for this entry, 'provider' = the pool shared with every other model of the provider."
         },
         "deprecated": {
           "type": "string",

package/js/factory/bridge.js

@@ -187,6 +187,8 @@ export async function runAnswerTranscription ({ provider, model, configuration,
  * @param {object} args
  * @param {string} args.provider
  * @param {string} args.model
+ * @param {string} [args.modelKey]         Mohdel catalog key, for the rate-limit
+ *                                         bucket when the entry is model-scoped.
  * @param {any} args.configuration
  * @param {string | string[]} args.input   One text or a batch; normalized to an
  *                                         array so the result shape never
@@ -195,9 +197,10 @@ export async function runAnswerTranscription ({ provider, model, configuration,
  *                                         the envelope; `callId` / `authId` are
  *                                         transport metadata.
  * @param {any} [args.spec]
+ * @param {BridgeDeps} [deps]
  * @returns {Promise<any>}
  */
-export async function runAnswerEmbedding ({ provider, model, configuration, input, options = {}, spec }) {
+export async function runAnswerEmbedding ({ provider, model, modelKey, configuration, input, options = {}, spec }, deps = {}) {
   const callId = options.callId || newCallId()
   const authId = options.authId || 'local'
   assertValidIds(callId, authId, `${provider}/${model}`)
@@ -212,7 +215,11 @@ export async function runAnswerEmbedding ({ provider, model, configuration, inpu
   if (options.inputType) envelope.inputType = options.inputType
   if (options.dimensions !== undefined) envelope.dimensions = options.dimensions
 
-  const out = await runEmbedding(envelope, spec ? { spec } : {})
+  const out = await runEmbedding(envelope, {
+    ...deps,
+    ...(modelKey ? { modelKey } : {}),
+    ...(spec ? { spec } : {})
+  })
   if (!out.ok) throw MohdelError.fromJSON(out.error, { provider, model })
   return out.result
 }

package/js/session/_rate_limiter.js

@@ -1,7 +1,9 @@
 /**
  * Minute-bucket rate limiter (per-key: provider or provider/model).
  *
- * Tracks RPM and TPM. Returns ms to wait if over limit — throttles
+ * Tracks RPM, TPM and INPM — inputs per minute, the unit an embedding
+ * endpoint is metered in when the provider counts inputs rather than
+ * requests or tokens. Returns ms to wait if over limit — throttles
  * rather than rejecting, so the caller can absorb small bursts
  * without a 429 round-trip.
  *
@@ -14,7 +16,7 @@
  */
 
 export function createRateLimiter () {
-  /** @type {Map<string, {count: number, tokens: number, minute: number}>} */
+  /** @type {Map<string, {count: number, tokens: number, inputs: number, minute: number}>} */
   const buckets = new Map()
 
   const currentMinute = () => Math.floor(Date.now() / 60000)
@@ -24,7 +26,7 @@ export function createRateLimiter () {
     const minute = currentMinute()
     const b = buckets.get(key)
     if (b && b.minute === minute) return b
-    const fresh = { count: 0, tokens: 0, minute }
+    const fresh = { count: 0, tokens: 0, inputs: 0, minute }
     buckets.set(key, fresh)
     return fresh
   }
@@ -42,15 +44,30 @@ export function createRateLimiter () {
    *     returned regardless of the current bucket.
    *   - positive number → throttle at that value.
    *
+   * `rpmLimit` and `tpmLimit` gate on what the bucket already holds:
+   * the size of the call ahead is not known until it returns.
+   * `inpmLimit` gates on what the call is about to add, which
+   * `pending.inputs` carries — a batch size is exact before dispatch,
+   * so the call is admitted only if the whole batch fits.
+   *
    * @param {string} key
-   * @param {{rpmLimit?: number, tpmLimit?: number}} limits
+   * @param {{rpmLimit?: number, tpmLimit?: number, inpmLimit?: number}} limits
+   * @param {{inputs?: number}} [pending]
    * @returns {number}
    */
-  const check = (key, { rpmLimit, tpmLimit } = {}) => {
-    if (rpmLimit == null && tpmLimit == null) return 0
+  const check = (key, { rpmLimit, tpmLimit, inpmLimit } = {}, pending = {}) => {
+    if (rpmLimit == null && tpmLimit == null && inpmLimit == null) return 0
     const b = getBucket(key)
     if (rpmLimit != null && b.count >= rpmLimit) return msUntilNextMinute(b.minute)
     if (tpmLimit != null && b.tokens >= tpmLimit) return msUntilNextMinute(b.minute)
+    if (inpmLimit != null) {
+      const adding = pending.inputs ?? 0
+      if (inpmLimit === 0) return msUntilNextMinute(b.minute)
+      // A batch larger than the whole allowance never fits, so waiting out the
+      // minute buys nothing: send it and take the provider's answer. Splitting
+      // it is the caller's call, not mohdel's.
+      if (adding <= inpmLimit && b.inputs + adding > inpmLimit) return msUntilNextMinute(b.minute)
+    }
     return 0
   }
 
@@ -67,7 +84,15 @@ export function createRateLimiter () {
     getBucket(key).tokens += tokens
   }
 
-  return { check, recordRequest, recordTokens }
+  /**
+   * @param {string} key
+   * @param {number} inputs
+   */
+  const recordInputs = (key, inputs) => {
+    getBucket(key).inputs += inputs
+  }
+
+  return { check, recordRequest, recordTokens, recordInputs }
 }
 
 // Single session-local instance.
@@ -75,3 +100,4 @@ const defaultLimiter = createRateLimiter()
 export const check = defaultLimiter.check
 export const recordRequest = defaultLimiter.recordRequest
 export const recordTokens = defaultLimiter.recordTokens
+export const recordInputs = defaultLimiter.recordInputs

package/js/session/run_embedding.js

@@ -3,27 +3,46 @@
  * returns either a result or a typed error, never throwing.
  *
  * Mirrors `run_transcription.js`: one synchronous request, no streaming, no
- * cancellation path beyond the caller's own signal.
+ * cancellation path beyond the caller's own signal. Rate limits are enforced
+ * as in `run.js`, minus the speed lanes embeddings do not have.
  *
  * @module session/run_embedding
  */
 
 import { getEmbeddingAdapter } from './adapters/embedding/index.js'
 import { classifyProviderError } from './adapters/_errors.js'
+import { getProviderLimits } from './adapters/_providers.js'
+import * as defaultLimiter from './_rate_limiter.js'
 import { providerOf } from '#core/model-id.js'
 
 /**
  * @param {import('#core/embedding.js').EmbedEnvelope} envelope
- * @param {{resolveAdapter?: (provider: string) => any, spec?: any}} [options]
+ * @param {{
+ *   resolveAdapter?: (provider: string) => any,
+ *   resolveProviderLimits?: (provider: string) => any,
+ *   limiter?: any,
+ *   sleep?: (ms: number) => Promise<void>,
+ *   modelKey?: string,
+ *   spec?: any
+ * }} [options]
  * @returns {Promise<
  *   | {ok: true, result: import('#core/embedding.js').EmbedResult}
  *   | {ok: false, error: import('#core/errors.js').TypedError}
  * >}
  */
-export async function runEmbedding (envelope, { resolveAdapter = getEmbeddingAdapter, spec } = {}) {
+export async function runEmbedding (envelope, {
+  resolveAdapter = getEmbeddingAdapter,
+  resolveProviderLimits = getProviderLimits,
+  limiter = defaultLimiter,
+  sleep = defaultSleep,
+  modelKey = envelope.model,
+  spec
+} = {}) {
+  const provider = providerOf(envelope.model)
+
   let adapter
   try {
-    adapter = resolveAdapter(providerOf(envelope.model))
+    adapter = resolveAdapter(provider)
   } catch (e) {
     return {
       ok: false,
@@ -36,8 +55,27 @@ export async function runEmbedding (envelope, { resolveAdapter = getEmbeddingAda
     }
   }
 
+  const providerCfg = resolveProviderLimits(provider) || {}
+  const rpmLimit = spec?.rpmLimit ?? providerCfg.rpmLimit
+  const tpmLimit = spec?.tpmLimit ?? providerCfg.tpmLimit
+  const inpmLimit = spec?.inpmLimit ?? providerCfg.inpmLimit
+  // `modelKey` is the catalog key, which the envelope carries over the wire but
+  // not on the in-process path, where it holds the upstream id instead.
+  const bucketKey = spec?.rateLimitScope === 'model' ? modelKey : provider
+  // A malformed envelope is metered as nothing: `checkBatch` rejects it inside
+  // the adapter, and a call that never reaches the provider must not spend quota.
+  const inputs = Array.isArray(envelope.input) ? envelope.input.length : 0
+
+  if (inputs > 0 && (rpmLimit != null || tpmLimit != null || inpmLimit != null)) {
+    const delay = limiter.check(bucketKey, { rpmLimit, tpmLimit, inpmLimit }, { inputs })
+    if (delay > 0) await sleep(delay)
+    limiter.recordRequest(bucketKey)
+    if (inpmLimit != null) limiter.recordInputs(bucketKey, inputs)
+  }
+
   try {
     const result = await adapter(envelope, spec ? { spec } : {})
+    if (tpmLimit != null && result.inputTokens) limiter.recordTokens(bucketKey, result.inputTokens)
     return { ok: true, result }
   } catch (e) {
     const typed = /** @type {any} */(e).typed || classifyProviderError(e, envelope.auth?.key)
@@ -49,3 +87,8 @@ export async function runEmbedding (envelope, { resolveAdapter = getEmbeddingAda
 function messageOf (e) {
   return e instanceof Error ? e.message : String(e)
 }
+
+/** @param {number} ms */
+function defaultSleep (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -135,7 +135,7 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.0",
-    "mohdel-thin-gate-linux-x64-gnu": "1.2.0"
+    "mohdel-thin-gate-linux-x64-gnu": "1.3.1"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.125.0",

package/src/cli/complete.js

@@ -38,6 +38,7 @@ const ARGUMENT = {
   'tag rm': ['model', 'tag'],
   'ratelimit show': ['model'],
   'ratelimit set': ['model'],
+  'ratelimit provider set': ['provider'],
   'ratelimit rm': ['model']
 }
 

package/src/cli/index.js

@@ -80,9 +80,9 @@ Commands:
   tag rm <model> <tag>                    Remove a tag
 
   ratelimit show <model|provider>         Show effective limits                   (mo rl show)
-  ratelimit set <model> [rpm] [tpm]       Set model-level limits
+  ratelimit set <model> <limit> <value>   Set limits: rpm, tpm, inpm
   ratelimit rm <model>                    Remove model-level limits
-  ratelimit provider set <p> [rpm] [tpm]  Set provider-level limits
+  ratelimit provider set <p> <limit> <v>  Set provider-level limits
   ratelimit provider rm <p>               Remove provider-level limits
 
   ask <provider/model> [prompt]           One-shot inference (pipeable)

package/src/cli/instructions.js

@@ -222,8 +222,16 @@ a silent billing error, not a crash. Accuracy matters more than completeness.
    field removed. Editing an existing model? Read its current entry out of the
    catalog file first and change only what you mean to. Step 2 below prints
    every removal, so check the diff before handing it over.
+7. **Some numbers describe the key, not the model.** Providers sort accounts
+   into standings — trial and production, numbered tiers, committed use — under
+   whatever name they give them, and publish a row per standing. Rate limits are
+   the obvious case; a price can be one too, and so can access to a model at
+   all. Two accounts can read the same published page and correctly write
+   different numbers, so for these a URL alone never settles a value. Establish
+   which standing this key has before writing one, and record it. If you cannot
+   establish it, leave the field out and say which one and why.
 ${local
-? `7. **This installation has its own fields and tags** — see *Local conventions*
+? `8. **This installation has its own fields and tags** — see *Local conventions*
    below, and do not treat the field table as the whole story. A field marked
    *measured* has no page to read it off: run the command named for it. Never
    apply a tag whose required fields you cannot supply — leave the tag off and
@@ -297,6 +305,12 @@ from the docs page. Steps 1 and 3 only read, so run them as often as you need.
 Step 4 writes to the user's catalog and shows them the diff first — hand them
 the command, do not run it for them.
 
+Anything that would change the catalog ends in something they can apply: a
+candidate file and its \`mo model apply\`, or the exact \`mo\` command for the
+change. A summary of what you found is not an outcome — if the ask was to
+change something, the reply that contains no applyable artifact has not
+answered it.
+
 ## Where to read the numbers
 
 ${names.map(referenceList).join('\n')}
@@ -320,6 +334,58 @@ someone who picked a provider *because* it was free should not be shown a
 table of dollar figures with no explanation. The rates apply once the free
 quota is gone.
 
+## Account-dependent numbers
+
+Some published numbers describe the key rather than the model (hard rule 7).
+Rate limits are the case you will meet most often, so the steps below are
+written for them; a price taken from a row that varies by account standing
+takes the same route. Start by reading the catalog — the models in it are the
+only ones you need to look up, and an earlier pass may already have settled the
+standing.
+
+1. **Establish the standing, once per provider.** Open the provider's limits
+   page and see how it divides accounts — most publish a column or a table per
+   account standing. Ask the user which one their key is on, using the words
+   that page uses for them; ask rather than picking the likely one and inviting
+   a correction. If a provider's limits do not vary by standing, there is
+   nothing to establish.
+2. **Read the row for that standing**, per model. Providers usually publish
+   limits per model, and a model on the page that this catalog does not carry
+   is not your problem.
+3. **Check the unit before you write.** mohdel counts three things: requests per
+   minute, tokens per minute, and inputs per minute for an embedding endpoint
+   metered in inputs. A limit published in any other unit — images, concurrent
+   jobs, a daily or monthly cap — does not convert, because the conversion
+   depends on how the caller batches and that is not yours to assume. Leave the
+   fields out for that model and tell the user the endpoint, the number and the
+   unit as published, so they can decide what to do.
+4. **Put each number at the level it is published at.** A limit that differs per
+   model goes in that model's entry, as \`rpmLimit\` / \`tpmLimit\` / \`inpmLimit\`
+   with \`rateLimitScope: "model"\`. The provider level is for one quota the whole
+   key shares across everything the provider sells — hand the user
+   \`mo rl provider set <provider> …\`, and set \`rateLimitScope: "provider"\` on the
+   entries drawing on it. A limit published **per endpoint** is neither: it binds
+   the models that call that endpoint and no others, so it goes on each of their
+   entries. At provider level it would claim the whole key is capped there,
+   which is false as soon as the provider sells anything else. A quota a speed
+   lane sells separately goes on that lane inside \`speeds\`, where it outranks
+   both.
+5. **Say which row you read, in your summary.** \`source\` and \`sourcedAt\` pin the
+   page and the date but not the row, and mohdel has no field for the standing —
+   so the record is what you tell the user. Name the standing and which models
+   took numbers from it. Do not improvise a home for it in the entry; if they
+   want it kept there, that is theirs to decide.
+6. **Report what you left out.** An unset limit is one that gets discovered as a
+   429 in production. Say which models you skipped and why — no standing given,
+   unit that does not convert, nothing published.
+
+Limits reach the catalog the same way prices do, through a candidate and
+\`mo model apply\`. The exception is a provider-level quota, which is not a
+catalog fact at all: \`mo rl provider set\` writes it to
+\`~/.config/mohdel/providers.json\`, and like every writing command it is one you
+hand over rather than run. \`mo rl show <model>\` prints what the runtime will
+use once applied, and reads nothing but config.
+
 ## Entry kinds
 
 - **Text/vision model** — the default. \`inputFormat\` lists what it accepts.

package/src/cli/ratelimit.js

@@ -4,24 +4,115 @@ import { parseJsonFlag, jsonOutputOne } from './json-output.js'
 // CLI logger: silent for noisy levels, console.error for errors and fatals.
 const cliLogger = { ...silent, error: console.error, fatal: console.error }
 
+const LIMIT_NAMES = ['rpm', 'tpm', 'inpm']
+
+/**
+ * `0` is a killswitch, not "unset", so read nullability rather than truth.
+ *
+ * @param {{rpmLimit?: number, tpmLimit?: number, inpmLimit?: number} | null | undefined} entry
+ * @returns {string[]}
+ */
+function limitParts (entry) {
+  if (!entry) return []
+  return LIMIT_NAMES
+    .filter(name => entry[`${name}Limit`] != null)
+    .map(name => `${name}=${entry[`${name}Limit`]}`)
+}
+
+/**
+ * @param {string[]} cleared  Limits named on the command line; empty means all.
+ * @param {string[]} parts    What is left afterwards.
+ */
+function clearedLine (cleared, parts) {
+  if (cleared.length === 0) return 'limits cleared'
+  return `${cleared.join(', ')} cleared; ${parts.length ? `${parts.join(' ')} remain` : 'no limits remain'}`
+}
+
+/** @param {string[]} names */
+function parseLimitNames (names) {
+  for (const name of names) {
+    if (!LIMIT_NAMES.includes(name)) {
+      console.error(`Unknown limit '${name}'. Known: ${LIMIT_NAMES.join(', ')}`)
+      process.exit(1)
+    }
+  }
+  return names
+}
+
+/** @param {string} raw */
+function toCount (raw) {
+  const n = parseInt(raw, 10)
+  if (!Number.isInteger(n) || n < 0 || String(n) !== String(raw).trim()) {
+    console.error(`'${raw}' is not a whole number`)
+    process.exit(1)
+  }
+  return n
+}
+
+/**
+ * Two forms. Named pairs — `rpm 60 inpm 2000` — reach every limit, including
+ * one on its own. The positional `<rpm> [tpm]` covers the common pair; a
+ * leading digit picks that form, since no limit is named one.
+ *
+ * @param {string[]} args
+ * @param {string} usage
+ * @returns {{rpm?: number, tpm?: number, inpm?: number}}
+ */
+function parseLimits (args, usage) {
+  if (args.length === 0) { console.error(usage); process.exit(1) }
+
+  if (/^\d/.test(args[0])) {
+    const [rpm, tpm] = args
+    return tpm ? { rpm: toCount(rpm), tpm: toCount(tpm) } : { rpm: toCount(rpm) }
+  }
+
+  /** @type {Record<string, number>} */
+  const limits = {}
+  for (let i = 0; i < args.length; i += 2) {
+    const name = args[i]
+    if (!LIMIT_NAMES.includes(name)) {
+      console.error(`Unknown limit '${name}'. Known: ${LIMIT_NAMES.join(', ')}`)
+      process.exit(1)
+    }
+    if (args[i + 1] == null) { console.error(`'${name}' needs a value`); process.exit(1) }
+    limits[name] = toCount(args[i + 1])
+  }
+  return limits
+}
+
 export async function runRateLimit (args) {
   const jsonFlag = parseJsonFlag(args)
-  const [action, arg1, arg2, arg3] = args
+  const [action, arg1] = args
 
   if (!action || action === '-h' || action === '--help') {
     console.log(`mohdel ratelimit — manage rate limits
 
 Usage:
   ratelimit show <model|provider> [--json]       Show effective limits
-  ratelimit set <model> [rpm] [tpm]              Set model-level limits
-  ratelimit rm <model>                           Remove model-level limits
-  ratelimit provider set <provider> [rpm] [tpm]  Set provider-level limits
-  ratelimit provider rm <provider>               Remove provider-level limits
+  ratelimit set <model> <limit> <value> …        Set limits by name
+  ratelimit set <model> <rpm> [tpm]              Shortcut for the two common ones
+  ratelimit rm <model> [limit …]                 Remove limits, or all of them
+
+A <model> may carry a speed lane — openai/gpt-x@fast — to reach the quota that
+lane sells separately. A lane outranks the entry, and carries rpm and tpm only.
+  ratelimit provider set <provider> <limit> <value> …
+  ratelimit provider set <provider> <rpm> [tpm]
+  ratelimit provider rm <provider> [limit …]     Remove limits, or all of them
+
+Limits:
+  rpm     requests per minute
+  tpm     tokens per minute
+  inpm    inputs per minute — what an embedding endpoint is metered in when
+          the provider counts inputs rather than requests or tokens
 
 Examples:
   ratelimit show anthropic                   Provider limits
   ratelimit show gemini/gemini-flash-latest  Model limits, then provider
+  ratelimit set cohere/embed-v4.0 inpm 2000
+  ratelimit set gemini/gemini-flash-latest rpm 15 tpm 1000000
+  ratelimit set openai/gpt-x@fast rpm 200
   ratelimit set gemini/gemini-flash-latest 15 1000000
+  ratelimit rm cohere/embed-v4.0 inpm
   ratelimit provider set anthropic 60 100000
 
 Aliases:
@@ -49,35 +140,24 @@ Configuration:
     if (providerAction === 'show') {
       if (!providerName) { console.error('Usage: ratelimit provider show <provider>'); process.exit(1) }
       const entry = mo.getProviderRateLimit(providerName)
-      if (!entry) {
-        console.log(`${providerName}: no limits set`)
-      } else {
-        const parts = []
-        if (entry.rpmLimit) parts.push(`rpm=${entry.rpmLimit}`)
-        if (entry.tpmLimit) parts.push(`tpm=${entry.tpmLimit}`)
-        console.log(`${providerName}: ${parts.join(' ')}`)
-      }
+      const parts = limitParts(entry)
+      console.log(parts.length ? `${providerName}: ${parts.join(' ')}` : `${providerName}: no limits set`)
       return
     }
 
     if (providerAction === 'set') {
       if (!providerName) { console.error('Usage: ratelimit provider set <provider> [rpm] [tpm]'); process.exit(1) }
-      const [rpmStr, tpmStr] = providerArgs
-      const rpm = rpmStr ? parseInt(rpmStr, 10) : undefined
-      const tpm = tpmStr ? parseInt(tpmStr, 10) : undefined
-      if (rpm == null && tpm == null) { console.error('Provide at least rpm or tpm'); process.exit(1) }
-      const result = await mo.setProviderRateLimit(providerName, { rpm, tpm })
-      const parts = []
-      if (result.rpmLimit) parts.push(`rpm=${result.rpmLimit}`)
-      if (result.tpmLimit) parts.push(`tpm=${result.tpmLimit}`)
-      console.log(`${providerName}: ${parts.join(' ')}`)
+      const limits = parseLimits(providerArgs, 'Usage: ratelimit provider set <provider> <limit> <value> … | <rpm> [tpm]')
+      const result = await mo.setProviderRateLimit(providerName, limits)
+      console.log(`${providerName}: ${limitParts(result).join(' ')}`)
       return
     }
 
     if (providerAction === 'rm' || providerAction === 'remove') {
-      if (!providerName) { console.error('Usage: ratelimit provider rm <provider>'); process.exit(1) }
-      await mo.clearProviderRateLimit(providerName)
-      console.log(`${providerName}: limits cleared`)
+      if (!providerName) { console.error('Usage: ratelimit provider rm <provider> [limit …]'); process.exit(1) }
+      const names = parseLimitNames(providerArgs)
+      const remaining = await mo.clearProviderRateLimit(providerName, names)
+      console.log(`${providerName}: ${clearedLine(names, limitParts(remaining))}`)
       return
     }
 
@@ -96,29 +176,29 @@ Configuration:
     if (model) {
       const info = model.info()
       const providerEntry = mo.getProviderRateLimit(info.provider) || {}
-      const rpmLimit = info.rpmLimit ?? providerEntry.rpmLimit
-      const tpmLimit = info.tpmLimit ?? providerEntry.tpmLimit
-      const scope = info.rateLimitScope || 'provider'
-      const source = (info.rpmLimit || info.tpmLimit) ? 'model' : 'provider'
+      const lane = info.speed ? info.speeds?.[info.speed] ?? {} : {}
+      const rpmLimit = lane.rpmLimit ?? info.rpmLimit ?? providerEntry.rpmLimit
+      const tpmLimit = lane.tpmLimit ?? info.tpmLimit ?? providerEntry.tpmLimit
+      const inpmLimit = info.inpmLimit ?? providerEntry.inpmLimit
+      // A lane only gets its own bucket when it declares a limit; otherwise its
+      // traffic counts against the entry's, which is what `scope` then describes.
+      const scope = limitParts(lane).length ? `lane:${info.speed}` : (info.rateLimitScope || 'provider')
+      const source = limitParts(lane).length ? 'lane' : (limitParts(info).length ? 'model' : 'provider')
       if (jsonFlag.json) {
-        jsonOutputOne({ id: arg1, rpmLimit: rpmLimit || null, tpmLimit: tpmLimit || null, scope, source })
+        jsonOutputOne({ id: arg1, rpmLimit: rpmLimit || null, tpmLimit: tpmLimit || null, inpmLimit: inpmLimit || null, scope, source })
         return
       }
-      if (!rpmLimit && !tpmLimit) {
+      const parts = limitParts({ rpmLimit, tpmLimit, inpmLimit })
+      if (parts.length === 0) {
         console.log(`${arg1}: no limits`)
       } else {
-        const parts = []
-        if (rpmLimit) parts.push(`rpm=${rpmLimit}`)
-        if (tpmLimit) parts.push(`tpm=${tpmLimit}`)
-        parts.push(`scope=${scope}`)
-        parts.push(`(${source})`)
-        console.log(`${arg1}: ${parts.join(' ')}`)
+        console.log(`${arg1}: ${[...parts, `scope=${scope}`, `(${source})`].join(' ')}`)
       }
     } else {
       // Treat as provider name
       const entry = mo.getProviderRateLimit(arg1)
       if (jsonFlag.json) {
-        jsonOutputOne({ provider: arg1, rpmLimit: entry?.rpmLimit || null, tpmLimit: entry?.tpmLimit || null })
+        jsonOutputOne({ provider: arg1, rpmLimit: entry?.rpmLimit || null, tpmLimit: entry?.tpmLimit || null, inpmLimit: entry?.inpmLimit || null })
         return
       }
       if (!entry) {
@@ -127,6 +207,7 @@ Configuration:
         const parts = []
         if (entry.rpmLimit) parts.push(`rpm=${entry.rpmLimit}`)
         if (entry.tpmLimit) parts.push(`tpm=${entry.tpmLimit}`)
+        if (entry.inpmLimit) parts.push(`inpm=${entry.inpmLimit}`)
         console.log(`${arg1}: ${parts.join(' ')}`)
       }
     }
@@ -134,24 +215,28 @@ Configuration:
   }
 
   if (action === 'set') {
-    if (!arg1) { console.error('Usage: ratelimit set <model> [rpm] [tpm]'); process.exit(1) }
-    const rpm = arg2 ? parseInt(arg2, 10) : undefined
-    const tpm = arg3 ? parseInt(arg3, 10) : undefined
-    if (rpm == null && tpm == null) { console.error('Provide at least rpm or tpm'); process.exit(1) }
+    const usage = 'Usage: ratelimit set <model> <limit> <value> … | <rpm> [tpm]'
+    if (!arg1) { console.error(usage); process.exit(1) }
+    const limits = parseLimits(args.slice(2), usage)
     const model = useModel(arg1)
-    const result = await model.setRateLimit({ rpm, tpm })
-    const parts = []
-    if (result.rpmLimit) parts.push(`rpm=${result.rpmLimit}`)
-    if (result.tpmLimit) parts.push(`tpm=${result.tpmLimit}`)
-    console.log(`${arg1}: ${parts.join(' ')} scope=model`)
+    const lane = arg1.split('@')[1]
+    let result
+    try {
+      result = await model.setRateLimit(limits)
+    } catch (err) {
+      console.error(err.message)
+      process.exit(1)
+    }
+    console.log(`${arg1}: ${limitParts(result).join(' ')} scope=${lane ? `lane:${lane}` : 'model'}`)
     return
   }
 
   if (action === 'rm' || action === 'remove') {
-    if (!arg1) { console.error('Usage: ratelimit rm <model>'); process.exit(1) }
+    if (!arg1) { console.error('Usage: ratelimit rm <model> [limit …]'); process.exit(1) }
+    const names = parseLimitNames(args.slice(2))
     const model = useModel(arg1)
-    await model.clearRateLimit()
-    console.log(`${arg1}: model limits cleared`)
+    const remaining = await model.clearRateLimit(names)
+    console.log(`${arg1}: ${clearedLine(names, limitParts(remaining))}`)
     return
   }
 

package/src/lib/index.js

@@ -26,6 +26,8 @@ export const version = createRequire(import.meta.url)('../../package.json').vers
 
 const noop = () => {}
 
+const LIMIT_FIELDS = ['rpmLimit', 'tpmLimit', 'inpmLimit']
+
 // Verbosity tiers — controls which mohdel internal log lines fire.
 //
 //   0  Anomaly-only. Failures, throttling, deprecation, server lifecycle.
@@ -413,30 +415,31 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
         return (providerName) => {
           const entry = providersConfig[providerName]
           if (!entry) return null
-          const { rpmLimit, tpmLimit } = entry
-          return (rpmLimit || tpmLimit) ? { rpmLimit, tpmLimit } : null
+          const { rpmLimit, tpmLimit, inpmLimit } = entry
+          return (rpmLimit || tpmLimit || inpmLimit) ? { rpmLimit, tpmLimit, inpmLimit } : null
         }
       }
 
       if (prop === 'setProviderRateLimit') {
-        return async (providerName, { rpm, tpm } = {}) => {
+        return async (providerName, { rpm, tpm, inpm } = {}) => {
           const entry = providersConfig[providerName] || (providersConfig[providerName] = {})
           if (rpm != null) entry.rpmLimit = rpm
           if (tpm != null) entry.tpmLimit = tpm
+          if (inpm != null) entry.inpmLimit = inpm
           await saveProvidersConfig(providersConfig)
           return entry
         }
       }
 
       if (prop === 'clearProviderRateLimit') {
-        return async (providerName) => {
+        return async (providerName, names = []) => {
           const entry = providersConfig[providerName]
-          if (entry) {
-            delete entry.rpmLimit
-            delete entry.tpmLimit
-            if (Object.keys(entry).length === 0) delete providersConfig[providerName]
-            await saveProvidersConfig(providersConfig)
-          }
+          if (!entry) return null
+          const fields = names.length ? names.map(n => `${n}Limit`) : LIMIT_FIELDS
+          for (const field of fields) delete entry[field]
+          if (Object.keys(entry).length === 0) delete providersConfig[providerName]
+          await saveProvidersConfig(providersConfig)
+          return providersConfig[providerName] || null
         }
       }
 
@@ -735,36 +738,63 @@ const createModelProxy = (resolvedModelId, modelSpec, handlers, aliasOutputEffor
           return runAnswerEmbedding({
             provider: modelSpec.provider,
             model: modelSpec.model ?? resolvedModelId.split('/').pop(),
+            modelKey: resolvedModelId,
             configuration,
             input,
             options,
             spec: modelSpec
-          })
+          }, { limiter: rateLimiter, resolveProviderLimits })
         }
       }
 
       if (prop === 'setRateLimit') {
-        return async ({ rpm, tpm } = {}) => {
+        return async ({ rpm, tpm, inpm } = {}) => {
           const curatedCache = getCuratedCacheSnapshot()
           const model = curatedCache[resolvedModelId] || (curatedCache[resolvedModelId] = { ...modelSpec })
+
+          if (aliasSpeed) {
+            if (inpm != null) {
+              throw new Error(
+                'inpm is not a speed-lane limit — lanes carry rpmLimit and tpmLimit only. ' +
+                `Set it on the entry instead: mo rl set ${resolvedModelId} inpm <n>`
+              )
+            }
+            const lane = { ...model.speeds[aliasSpeed] }
+            if (rpm != null) lane.rpmLimit = rpm
+            if (tpm != null) lane.tpmLimit = tpm
+            model.speeds = { ...model.speeds, [aliasSpeed]: lane }
+            await persistCuratedCache()
+            return { rpmLimit: lane.rpmLimit, tpmLimit: lane.tpmLimit }
+          }
+
           if (rpm != null) model.rpmLimit = rpm
           if (tpm != null) model.tpmLimit = tpm
+          if (inpm != null) model.inpmLimit = inpm
           model.rateLimitScope = 'model'
           await persistCuratedCache()
-          return { rpmLimit: model.rpmLimit, tpmLimit: model.tpmLimit }
+          return { rpmLimit: model.rpmLimit, tpmLimit: model.tpmLimit, inpmLimit: model.inpmLimit }
         }
       }
 
       if (prop === 'clearRateLimit') {
-        return async () => {
+        return async (names = []) => {
           const curatedCache = getCuratedCacheSnapshot()
           const model = curatedCache[resolvedModelId]
-          if (model) {
-            delete model.rpmLimit
-            delete model.tpmLimit
-            delete model.rateLimitScope
+          if (!model) return {}
+          const fields = names.length ? names.map(n => `${n}Limit`) : LIMIT_FIELDS
+
+          if (aliasSpeed) {
+            const lane = { ...model.speeds[aliasSpeed] }
+            for (const field of fields) delete lane[field]
+            model.speeds = { ...model.speeds, [aliasSpeed]: lane }
             await persistCuratedCache()
+            return { rpmLimit: lane.rpmLimit, tpmLimit: lane.tpmLimit }
           }
+
+          for (const field of fields) delete model[field]
+          if (!LIMIT_FIELDS.some(field => model[field] != null)) delete model.rateLimitScope
+          await persistCuratedCache()
+          return { rpmLimit: model.rpmLimit, tpmLimit: model.tpmLimit, inpmLimit: model.inpmLimit }
         }
       }
 
@@ -811,7 +841,8 @@ const createModelProxy = (resolvedModelId, modelSpec, handlers, aliasOutputEffor
       if (prop === 'info') {
         return () => { // Sync
           const catalog = getCuratedCacheSnapshot()
-          return catalog?.[resolvedModelId] ? { ...catalog[resolvedModelId] } : { ...modelSpec }
+          const entry = catalog?.[resolvedModelId] ? { ...catalog[resolvedModelId] } : { ...modelSpec }
+          return aliasSpeed ? { ...entry, speed: aliasSpeed } : entry
         }
       }
 

package/src/lib/schema.js

@@ -69,6 +69,7 @@ const fieldDefs = {
   suspended: { type: 'string' },
   rpmLimit: { type: 'number' },
   tpmLimit: { type: 'number' },
+  inpmLimit: { type: 'number' },
   rateLimitScope: { type: 'string', validate: (v) => ['model', 'provider'].includes(v) ? null : 'must be "model" or "provider"' },
   outputCapStrategy: { type: 'string', validate: (v) => ['error', 'accept'].includes(v) ? null : "must be 'error' or 'accept'" },
   supportsTools: { type: 'boolean' },

package/src/lib/rate-limiter.js

@@ -1,50 +0,0 @@
-// Lightweight per-minute rate limiter.
-// Tracks RPM and TPM with minute-bucket granularity.
-// Throttles (delays) rather than rejects — returns ms to wait.
-
-const createRateLimiter = () => {
-  // key → { count, tokens, minute }
-  const buckets = new Map()
-
-  const currentMinute = () => Math.floor(Date.now() / 60000)
-
-  const getBucket = (key) => {
-    const minute = currentMinute()
-    const bucket = buckets.get(key)
-    if (bucket && bucket.minute === minute) return bucket
-    const fresh = { count: 0, tokens: 0, minute }
-    buckets.set(key, fresh)
-    return fresh
-  }
-
-  const msUntilNextMinute = (minute) => Math.max(0, (minute + 1) * 60000 - Date.now())
-
-  // Returns ms to wait before sending (0 = go ahead)
-  const check = (key, { rpmLimit, tpmLimit } = {}) => {
-    if (!rpmLimit && !tpmLimit) return 0
-    const bucket = getBucket(key)
-    if (rpmLimit && bucket.count >= rpmLimit) {
-      return msUntilNextMinute(bucket.minute)
-    }
-    if (tpmLimit && bucket.tokens >= tpmLimit) {
-      return msUntilNextMinute(bucket.minute)
-    }
-    return 0
-  }
-
-  // Record a request count (call before sending — RPM tracking)
-  const recordRequest = (key) => {
-    const bucket = getBucket(key)
-    bucket.count++
-  }
-
-  // Record token usage (call after response — TPM tracking)
-  const recordTokens = (key, tokens) => {
-    const bucket = getBucket(key)
-    bucket.tokens += tokens
-  }
-
-  return { check, recordRequest, recordTokens }
-}
-
-export default createRateLimiter