mohdel 1.1.0 → 1.3.0

package/js/session/adapters/embedding/index.js

@@ -0,0 +1,37 @@
+/**
+ * Embedding-adapter registry. Mirrors `session/adapters/transcription` but
+ * scoped to providers with an embeddings endpoint.
+ *
+ * Five of mohdel's thirteen providers offer embeddings at all, and neither
+ * meta-provider does. Of those that do, only the base URL and the name of the
+ * dimension parameter differ across the OpenAI-shaped ones, so they share one
+ * adapter; Gemini and Cohere need their own.
+ *
+ * @module session/adapters/embedding
+ */
+
+import { createEmbeddingAdapter } from './openai_compatible.js'
+import { geminiEmbedding } from './gemini.js'
+import { cohereEmbedding } from './cohere.js'
+
+const EMBEDDING_ADAPTERS = {
+  openai: createEmbeddingAdapter({ baseURL: 'https://api.openai.com/v1' }),
+  // The endpoint is the catalog entry's `baseURL`, as it is for local chat.
+  local: createEmbeddingAdapter(),
+  gemini: geminiEmbedding,
+  cohere: cohereEmbedding
+}
+
+/** Providers with an embeddings adapter, for capability checks. */
+export const EMBEDDING_PROVIDERS = Object.freeze(Object.keys(EMBEDDING_ADAPTERS))
+
+/**
+ * @param {string} provider
+ */
+export function getEmbeddingAdapter (provider) {
+  const adapter = EMBEDDING_ADAPTERS[provider]
+  if (!adapter) throw new Error(`no embedding adapter for provider: ${provider}`)
+  return adapter
+}
+
+export const embeddingAdapters = Object.freeze(EMBEDDING_ADAPTERS)

package/js/session/adapters/embedding/openai_compatible.js

@@ -0,0 +1,92 @@
+/**
+ * Shared embedding adapter for OpenAI-compatible `POST <baseURL>/embeddings`.
+ *
+ * Covers OpenAI and any self-hosted server that implements the endpoint
+ * (Ollama, vLLM, llama.cpp), and is the same shape Mistral, Fireworks and
+ * Qwen Cloud expose when they are added. Only the base URL and the name of the
+ * dimension parameter differ, so both are bound per provider in `./index.js`.
+ *
+ * @module session/adapters/embedding/openai_compatible
+ */
+
+import { getSpec } from '../_catalog.js'
+import { classifyProviderError, fromHttpStatus, typedError } from '../_errors.js'
+import { computeEmbeddingCost } from '../_pricing.js'
+import { catalogKey, bareOf } from '#core/model-id.js'
+import { checkBatch, checkDimensions, resolveInputType, widthOf } from './_shared.js'
+
+/**
+ * @param {{baseURL?: string, dimensionsField?: string}} config
+ */
+export function createEmbeddingAdapter ({ baseURL, dimensionsField = 'dimensions' } = {}) {
+  return async function embedding (envelope, deps = {}) {
+    const fetchFn = deps.fetch ?? globalThis.fetch
+    const spec = deps.spec ?? getSpec(catalogKey(envelope.model)) ?? {}
+    const start = String(process.hrtime.bigint())
+
+    checkBatch(envelope, spec)
+    const dimensions = checkDimensions(envelope, spec)
+    const inputType = resolveInputType(envelope, spec)
+
+    // `local/` carries its endpoint on the entry; everything else is bound
+    // to a base URL by the registry.
+    const root = (spec.baseURL ?? baseURL ?? '').replace(/\/$/, '')
+    if (!root) {
+      throw typedError('no baseURL for this embedding model', 'CONFIGURATION_MISSING', false)
+    }
+
+    /** @type {Record<string, any>} */
+    const body = { model: spec.model ?? bareOf(envelope.model), input: envelope.input }
+    if (dimensions !== undefined) body[dimensionsField] = dimensions
+    if (inputType) body.input_type = inputType
+
+    let res
+    try {
+      res = await fetchFn(`${root}/embeddings`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(envelope.auth?.key ? { Authorization: `Bearer ${envelope.auth.key}` } : {})
+        },
+        body: JSON.stringify(body)
+      })
+    } catch (e) {
+      throw typedError(classifyProviderError(e, envelope.auth?.key).message, 'NET_ERROR', true)
+    }
+
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '')
+      throw fromHttpStatus(res.status, detail, envelope.auth?.key)
+    }
+
+    const payload = await res.json()
+    const rows = Array.isArray(payload?.data) ? payload.data : []
+    // `index` is authoritative: the caller matches vectors to inputs by
+    // position, and a provider is free to answer out of order.
+    const vectors = rows
+      .slice()
+      .sort((a, b) => (a?.index ?? 0) - (b?.index ?? 0))
+      .map(r => r?.embedding)
+
+    if (vectors.length !== envelope.input.length || vectors.some(v => !Array.isArray(v))) {
+      throw typedError(
+        `expected ${envelope.input.length} vectors, got ${vectors.length}`,
+        'EMBED_RESULT_MISMATCH',
+        false
+      )
+    }
+
+    const inputTokens = payload?.usage?.prompt_tokens ?? payload?.usage?.total_tokens ?? 0
+    const end = String(process.hrtime.bigint())
+
+    return {
+      status: 'completed',
+      vectors,
+      dimensions: widthOf(vectors),
+      inputType,
+      inputTokens,
+      cost: computeEmbeddingCost(spec, { inputTokens }),
+      timestamps: { start, first: end, end }
+    }
+  }
+}

package/js/session/driver.js

@@ -18,6 +18,7 @@ import { MAX_LINE_BYTES, exceedsLineBytes } from '#core/framing.js'
 import { run } from './run.js'
 import { runImage } from './run_image.js'
 import { runTranscription } from './run_transcription.js'
+import { runEmbedding } from './run_embedding.js'
 import { setCatalog } from './adapters/_catalog.js'
 
 // Bounded memory for pre-dequeue cancels. Hostile/buggy supervisors
@@ -221,6 +222,16 @@ export async function drive (stdin, stdout) {
         } else {
           await writeLine({ type: 'error', error: out.error })
         }
+      } else if (envelope.op === 'embed') {
+        // Same one-shot contract; shape matches `js/core/embedding.js`
+        // after the tag strip. One line carries all N vectors.
+        const { op: _op, ...embEnv } = envelope
+        const out = await runEmbedding(embEnv)
+        if (out.ok) {
+          await writeLine({ type: 'embed_done', result: out.result })
+        } else {
+          await writeLine({ type: 'error', error: out.error })
+        }
       } else {
         for await (const ev of run(envelope, { signal: controller.signal })) {
           await writeLine(ev)

package/js/session/run_embedding.js

@@ -0,0 +1,94 @@
+/**
+ * Embedding runtime. Resolves the adapter for the envelope's provider and
+ * 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. 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,
+ *   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,
+  resolveProviderLimits = getProviderLimits,
+  limiter = defaultLimiter,
+  sleep = defaultSleep,
+  modelKey = envelope.model,
+  spec
+} = {}) {
+  const provider = providerOf(envelope.model)
+
+  let adapter
+  try {
+    adapter = resolveAdapter(provider)
+  } catch (e) {
+    return {
+      ok: false,
+      error: {
+        message: messageOf(e),
+        severity: 'error',
+        retryable: false,
+        type: 'SESSION_UNKNOWN_PROVIDER'
+      }
+    }
+  }
+
+  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)
+    return { ok: false, error: typed }
+  }
+}
+
+/** @param {unknown} e */
+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.1.0",
+  "version": "1.3.0",
   "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.1.0"
+    "mohdel-thin-gate-linux-x64-gnu": "1.3.0"
   },
   "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/ratelimit.js

@@ -4,24 +4,111 @@ 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
+  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 gemini/gemini-flash-latest 15 1000000
+  ratelimit rm cohere/embed-v4.0 inpm
   ratelimit provider set anthropic 60 100000
 
 Aliases:
@@ -49,35 +136,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
     }
 
@@ -98,27 +174,24 @@ Configuration:
       const providerEntry = mo.getProviderRateLimit(info.provider) || {}
       const rpmLimit = info.rpmLimit ?? providerEntry.rpmLimit
       const tpmLimit = info.tpmLimit ?? providerEntry.tpmLimit
+      const inpmLimit = info.inpmLimit ?? providerEntry.inpmLimit
       const scope = info.rateLimitScope || 'provider'
-      const source = (info.rpmLimit || info.tpmLimit) ? 'model' : 'provider'
+      const source = 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 +200,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 +208,21 @@ 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 result = await model.setRateLimit(limits)
+    console.log(`${arg1}: ${limitParts(result).join(' ')} scope=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/creators.js

@@ -59,6 +59,18 @@ const creators = {
     logo: 'moonshotai.svg',
     description: 'Moonshot AI ships fluent, Chinese-first assistants and lean models tuned for consumer chat and business workflows.'
   },
+  cohere: {
+    prefixes: ['embed', 'command', 'rerank'],
+    label: 'Cohere',
+    logo: 'cohere.svg',
+    description: 'Cohere builds retrieval-focused models: embeddings and rerankers aimed at enterprise search rather than chat.'
+  },
+  nomic: {
+    prefixes: ['nomic-embed'],
+    label: 'Nomic',
+    logo: 'nomic.svg',
+    description: 'Nomic publishes open-weight embedding models with Matryoshka dimensions, widely self-hosted through Ollama and vLLM.'
+  },
   openai: {
     prefixes: ['gpt', 'whisper', 'dall-e', 'sora', 'text-embedding', 'o1', 'o3', 'o4'],
     label: 'OpenAI',

package/src/lib/index.js

@@ -16,7 +16,7 @@ import {
 import { createRateLimiter } from '../../js/session/_rate_limiter.js'
 import { createCooldownTracker } from '../../js/session/_cooldown.js'
 import { setCatalog } from '../../js/session/adapters/_catalog.js'
-import { runAnswer, runAnswerImage, runAnswerTranscription } from '../../js/factory/bridge.js'
+import { runAnswer, runAnswerEmbedding, runAnswerImage, runAnswerTranscription } from '../../js/factory/bridge.js'
 import { startSpan, endSpanOk, endSpanError } from './tracing.js'
 import { isValidTag } from './schema.js'
 import { silent } from './logger.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
         }
       }
 
@@ -729,28 +732,44 @@ const createModelProxy = (resolvedModelId, modelSpec, handlers, aliasOutputEffor
         }
       }
 
+      if (prop === 'embed') {
+        return async (input, options = {}) => {
+          const { configuration } = await getRuntime()
+          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 (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
-            await persistCuratedCache()
-          }
+          if (!model) return {}
+          const fields = names.length ? names.map(n => `${n}Limit`) : LIMIT_FIELDS
+          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 }
         }
       }