mohdel 1.1.0 → 1.2.0

package/README.md

@@ -422,6 +422,7 @@ OPENROUTER_API_SK=sk-or-...
 NOVITA_API_SK=...
 QWEN_API_SK=sk-...
 XIAOMI_API_SK=...
+COHERE_API_SK=...
 MOHDEL_LOCAL_API_SK=...
 ```
 
@@ -462,6 +463,7 @@ What each provider supports through mohdel's unified interface:
 | Xiaomi | Yes | Yes | Yes | No | Auto | MiMo; shared chat-completions path, `reasoning_content` captured |
 | OpenRouter | Yes | Yes | Yes | No | Varies | Meta-provider; `providerOptions.openrouter` for routing prefs |
 | Local | Yes | Yes | Yes | No | No | Any OpenAI-compatible server; endpoint is the catalog entry's `baseURL` |
+| Cohere | n/a | n/a | n/a | n/a | n/a | Embeddings only: no chat models reach mohdel through it |
 | Novita | Yes | Yes | Yes | No | Yes (`reasoning_content`) | Prices in the model list; text via the shared chat-completions path, separate image adapter |
 
 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.

package/config/curated.schema.json

@@ -517,6 +517,39 @@
           "minimum": 0,
           "description": "USD per audio minute (transcription-type entries). Token-billed transcription models (OpenAI gpt-4o-*-transcribe) use inputPrice/outputPrice instead."
         },
+        "embeddingPrice": {
+          "type": "number",
+          "minimum": 0,
+          "description": "USD per 1,000,000 input tokens for an embedding model. Without it, cost is 0 on every embed call."
+        },
+        "dimensions": {
+          "type": "number",
+          "minimum": 1,
+          "description": "Native width of the vectors this model returns."
+        },
+        "dimensionsSelectable": {
+          "type": "boolean",
+          "description": "Whether the model accepts a requested output width. Providers spell the parameter differently (dimensions, output_dimension, outputDimensionality) and support it on some models only; when false, passing `dimensions` fails before dispatch instead of being ignored."
+        },
+        "maxBatch": {
+          "type": "number",
+          "minimum": 1,
+          "description": "Inputs accepted in one embed call. 2048 on OpenAI, 96 on Cohere, 10 on Qwen Cloud, 1 for Gemini's single-content endpoint. A larger batch fails before dispatch; mohdel does not split one, because splitting changes cost attribution and result ordering."
+        },
+        "maxInputTokens": {
+          "type": "number",
+          "minimum": 1,
+          "description": "Token ceiling for a single input, not for the request."
+        },
+        "inputTypes": {
+          "type": "object",
+          "additionalProperties": { "type": "string" },
+          "description": "Maps mohdel's symbolic roles (query, document, classification, clustering) to the provider's own vocabulary, e.g. {\"query\": \"RETRIEVAL_QUERY\"} for Gemini or {\"query\": \"search_query\"} for Cohere. An entry without it rejects `inputType` rather than dropping it: the role is baked into the vector, so a silent drop produces quietly worse retrieval."
+        },
+        "defaultInputType": {
+          "type": "string",
+          "description": "Symbolic role sent when the caller names none. Required for providers that make the parameter mandatory (Cohere v3+)."
+        },
         "rpmLimit": {
           "type": "integer",
           "minimum": 1,

package/js/client/call_embedding.js

@@ -0,0 +1,50 @@
+/**
+ * Send an EmbedEnvelope to thin-gate's `POST /v1/embed`.
+ *
+ * One-shot: a single JSON response body, no streaming, no cooldown or
+ * rate-limit. One call carries N inputs and returns N vectors in request
+ * order; the gate never splits a batch, so a batch larger than the model's
+ * `maxBatch` comes back as an error rather than as several calls.
+ *
+ * @module client/call_embedding
+ */
+
+import { requestUnix } from './transport.js'
+import { readAll, parseErrorBody } from './response.js'
+import { MohdelError } from '#core'
+
+/**
+ * @param {import('#core/embedding.js').EmbedEnvelope} envelope
+ * @param {object} options
+ * @param {string} options.socketPath
+ * @param {AbortSignal} [options.signal]
+ * @param {string} [options.path]  HTTP path; defaults to '/v1/embed'
+ * @returns {Promise<import('#core/embedding.js').EmbedResult>}
+ */
+export async function callEmbedding (envelope, { socketPath, signal, path = '/v1/embed' }) {
+  const res = await requestUnix({
+    socketPath,
+    path,
+    method: 'POST',
+    body: envelope,
+    signal
+  })
+
+  const body = await readAll(res)
+
+  if (res.statusCode !== 200) {
+    throw MohdelError.fromJSON(parseErrorBody(body, res.statusCode ?? 0))
+  }
+
+  let parsed
+  try {
+    parsed = JSON.parse(body)
+  } catch (e) {
+    throw new MohdelError(`gate returned an unparseable embed body: ${body.slice(0, 200)}`, {
+      type: 'PROTOCOL_INVALID_RESPONSE',
+      severity: 'error',
+      retryable: false
+    })
+  }
+  return parsed
+}

package/js/client/index.js

@@ -16,4 +16,5 @@
 export { call } from './call.js'
 export { callImage } from './call_image.js'
 export { callTranscription } from './call_transcription.js'
+export { callEmbedding } from './call_embedding.js'
 export { resolveGateBinary } from './gate-binary.js'

package/js/core/embedding.js

@@ -0,0 +1,76 @@
+/**
+ * Embedding envelope and result.
+ *
+ * Separate call path from `CallEnvelope` / `AnswerResult`: embeddings are a
+ * single synchronous request/response, nothing is generated, and one call
+ * carries N inputs and returns N vectors in request order.
+ * Result shape: `{ status, vectors, dimensions, inputTokens, cost, timestamps }`.
+ *
+ * @module core/embedding
+ */
+
+/**
+ * @typedef {object} EmbedEnvelope
+ *
+ * @property {string} callId
+ * @property {string} authId
+ * @property {import('./envelope.js').Auth} auth
+ * @property {string} [traceparent]
+ * @property {string} [baggage]
+ *
+ * @property {string} model
+ *   Full mohdel id — `"<provider>/<bare>"`. Same shape as
+ *   `CallEnvelope.model` (see `envelope.js`).
+ * @property {string[]} input
+ *   Texts to embed. Always an array, even for one. A batch larger than the
+ *   entry's `maxBatch` fails before dispatch rather than being split:
+ *   splitting would change both cost attribution and result ordering.
+ *
+ * @property {number} [dimensions]
+ *   Requested output width. Providers spell this three ways
+ *   (`dimensions`, `output_dimension`, `outputDimensionality`) and support it
+ *   on some models only; an entry without `dimensionsSelectable` rejects the
+ *   field rather than sending it to be ignored.
+ * @property {string} [inputType]
+ *   Symbolic role of the text: `query`, `document`, `classification`,
+ *   `clustering`. Asymmetric models embed the same string differently
+ *   depending on it, so a query and its matching passage land close together.
+ *   The entry's `inputTypes` maps it to the provider's own vocabulary.
+ */
+
+/**
+ * @typedef {object} EmbedResult
+ *
+ * @property {'completed'} status
+ *   Embeddings are one-shot — no `incomplete` state.
+ * @property {number[][]} vectors
+ *   One per input, in request order.
+ * @property {number} dimensions
+ *   Width of the returned vectors, which is what the provider actually
+ *   produced rather than what was asked for.
+ * @property {string | null} inputType
+ *   The provider-native value that was sent, or null when none was. The role
+ *   is baked into the vector, so a caller storing these must record it and
+ *   query the same namespace the same way.
+ * @property {number} inputTokens
+ * @property {number} cost
+ *   USD. `embeddingPrice` (per million input tokens) × `inputTokens`; 0 when
+ *   the spec carries no price.
+ * @property {{start: string, first: string, end: string}} timestamps
+ *   hrtime-bigint-as-string. `first` = `end` (no streaming).
+ */
+
+export const EMBED_ENVELOPE_FIELDS = Object.freeze([
+  'callId',
+  'authId',
+  'auth',
+  'traceparent',
+  'baggage',
+  'model',
+  'input',
+  'dimensions',
+  'inputType'
+])
+
+/** Symbolic roles a caller may pass; the entry maps them to provider values. */
+export const INPUT_TYPES = Object.freeze(['query', 'document', 'classification', 'clustering'])

package/js/factory/bridge.js

@@ -23,6 +23,7 @@
 import { run } from '../session/run.js'
 import { runImage } from '../session/run_image.js'
 import { runTranscription } from '../session/run_transcription.js'
+import { runEmbedding } from '../session/run_embedding.js'
 import { markTrustedMedia } from '../session/adapters/_media.js'
 import { MohdelError, validateIds } from '#core'
 import { createRealtimeDeltaBuffer } from '../../src/lib/utils.js'
@@ -180,6 +181,42 @@ export async function runAnswerTranscription ({ provider, model, configuration,
   return out.result
 }
 
+/**
+ * Run an `embed()` call through the /session runtime.
+ *
+ * @param {object} args
+ * @param {string} args.provider
+ * @param {string} args.model
+ * @param {any} args.configuration
+ * @param {string | string[]} args.input   One text or a batch; normalized to an
+ *                                         array so the result shape never
+ *                                         depends on how the caller asked.
+ * @param {any} [args.options]             `inputType` / `dimensions` map onto
+ *                                         the envelope; `callId` / `authId` are
+ *                                         transport metadata.
+ * @param {any} [args.spec]
+ * @returns {Promise<any>}
+ */
+export async function runAnswerEmbedding ({ provider, model, configuration, input, options = {}, spec }) {
+  const callId = options.callId || newCallId()
+  const authId = options.authId || 'local'
+  assertValidIds(callId, authId, `${provider}/${model}`)
+
+  const envelope = {
+    callId,
+    authId,
+    auth: configToAuth(configuration),
+    model: `${provider}/${model}`,
+    input: Array.isArray(input) ? input : [input]
+  }
+  if (options.inputType) envelope.inputType = options.inputType
+  if (options.dimensions !== undefined) envelope.dimensions = options.dimensions
+
+  const out = await runEmbedding(envelope, spec ? { spec } : {})
+  if (!out.ok) throw MohdelError.fromJSON(out.error, { provider, model })
+  return out.result
+}
+
 /**
  * @param {object} args
  * @param {string} args.modelKey      Mohdel catalog key `<provider>/<bare>`. The

package/js/session/adapters/_pricing.js

@@ -147,6 +147,21 @@ export function computeTranscriptionCost (spec, usage) {
   return 0
 }
 
+/**
+ * Embedding cost. `embeddingPrice` is USD per million input tokens; nothing is
+ * generated, so there is no output side.
+ *
+ * @param {any} spec
+ * @param {{inputTokens?: number}} usage
+ * @returns {number}
+ */
+export function computeEmbeddingCost (spec, usage) {
+  if (!spec || typeof spec.embeddingPrice !== 'number') return 0
+  const tokens = usage.inputTokens
+  if (typeof tokens !== 'number' || tokens <= 0) return 0
+  return round((tokens / 1_000_000) * spec.embeddingPrice)
+}
+
 /**
  * Test convenience: inject pricing-only specs by model id. Wraps
  * `setCatalog` with the `{input, output, thinking?}` shape used in
@@ -168,6 +183,9 @@ export function setPricing (table) {
 }
 
 /** @param {number} n */
+// 1e-10 USD, not 1e-6. Six decimals reads as plenty until you price a short
+// embedding: 4 tokens at $0.02 per million is 8e-8, which rounds to zero, and
+// a million such calls then sum to zero instead of to their real cost.
 function round (n) {
-  return Math.round(n * 1e6) / 1e6
+  return Math.round(n * 1e10) / 1e10
 }

package/js/session/adapters/embedding/_shared.js

@@ -0,0 +1,92 @@
+/**
+ * Pieces every embedding adapter needs: the pre-dispatch checks that turn a
+ * provider's per-model limits into an error before a request is sent, and the
+ * envelope-to-provider translation of `inputType`.
+ *
+ * These fail rather than drop. A `dimensions` the model ignores, or an
+ * `inputType` silently discarded, both produce vectors that look fine and
+ * retrieve badly, which is the failure mohdel exists to prevent.
+ *
+ * @module session/adapters/embedding/shared
+ */
+
+import { typedError } from '../_errors.js'
+
+/**
+ * @param {import('#core/embedding.js').EmbedEnvelope} envelope
+ * @param {any} spec
+ */
+export function checkBatch (envelope, spec) {
+  const input = envelope.input
+  if (!Array.isArray(input) || input.length === 0) {
+    throw typedError('embed requires a non-empty input array', 'EMBED_INPUT_EMPTY', false)
+  }
+  if (input.some(t => typeof t !== 'string')) {
+    throw typedError('embed input must be strings', 'EMBED_INPUT_INVALID', false)
+  }
+  const max = spec?.maxBatch
+  if (typeof max === 'number' && input.length > max) {
+    throw typedError(
+      `${input.length} inputs exceeds this model's batch limit of ${max}`,
+      'EMBED_BATCH_TOO_LARGE',
+      false
+    )
+  }
+}
+
+/**
+ * @param {import('#core/embedding.js').EmbedEnvelope} envelope
+ * @param {any} spec
+ * @returns {number | undefined}
+ */
+export function checkDimensions (envelope, spec) {
+  const wanted = envelope.dimensions
+  if (wanted === undefined) return undefined
+  if (!spec?.dimensionsSelectable) {
+    throw typedError(
+      'this model returns a fixed vector width; remove `dimensions`',
+      'EMBED_DIMENSIONS_UNSUPPORTED',
+      false
+    )
+  }
+  return wanted
+}
+
+/**
+ * Symbolic role to the provider's own vocabulary. The entry owns the mapping,
+ * the same way `thinkingEffortLevels` owns thinking budgets.
+ *
+ * @param {import('#core/embedding.js').EmbedEnvelope} envelope
+ * @param {any} spec
+ * @returns {string | null}
+ */
+export function resolveInputType (envelope, spec) {
+  const table = spec?.inputTypes
+  const wanted = envelope.inputType ?? spec?.defaultInputType ?? null
+  if (wanted === null) return null
+
+  if (!table || typeof table !== 'object') {
+    throw typedError(
+      'this model declares no inputTypes; remove `inputType`',
+      'EMBED_INPUT_TYPE_UNSUPPORTED',
+      false
+    )
+  }
+  const native = table[wanted]
+  if (typeof native !== 'string') {
+    throw typedError(
+      `inputType '${wanted}' is not declared for this model; known: ${Object.keys(table).join(', ')}`,
+      'EMBED_INPUT_TYPE_UNKNOWN',
+      false
+    )
+  }
+  return native
+}
+
+/**
+ * @param {number[][]} vectors
+ * @returns {number}
+ */
+export function widthOf (vectors) {
+  return vectors.length && Array.isArray(vectors[0]) ? vectors[0].length : 0
+}

package/js/session/adapters/embedding/cohere.js

@@ -0,0 +1,91 @@
+/**
+ * Cohere embedding adapter.
+ *
+ * The most divergent shape mohdel talks to: `POST /v2/embed` rather than
+ * `/embeddings`, inputs under `texts`, `input_type` **required**, and
+ * `embeddings` returned as an object keyed by dtype
+ * (`{ float: [[...]] }`) instead of a `data[]` array. Tokens live at
+ * `meta.billed_units.input_tokens`.
+ *
+ * @module session/adapters/embedding/cohere
+ */
+
+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'
+
+const BASE_URL = 'https://api.cohere.com/v2'
+
+export async function cohereEmbedding (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)
+
+  // Cohere rejects a call without it, so an entry that declares no mapping is
+  // unusable rather than merely less accurate.
+  if (!inputType) {
+    throw typedError(
+      'cohere requires an input_type; set inputType or the entry\'s defaultInputType',
+      'EMBED_INPUT_TYPE_REQUIRED',
+      false
+    )
+  }
+
+  const body = {
+    model: spec.model ?? bareOf(envelope.model),
+    texts: envelope.input,
+    input_type: inputType,
+    embedding_types: ['float'],
+    ...(dimensions !== undefined ? { output_dimension: dimensions } : {})
+  }
+
+  let res
+  try {
+    res = await fetchFn(`${BASE_URL}/embed`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        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 vectors = payload?.embeddings?.float ?? []
+
+  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?.meta?.billed_units?.input_tokens ??
+    payload?.meta?.tokens?.input_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/adapters/embedding/gemini.js

@@ -0,0 +1,92 @@
+/**
+ * Gemini embedding adapter.
+ *
+ * Shares nothing with the OpenAI shape: a different endpoint per batch size
+ * (`:embedContent` for one input, `:batchEmbedContents` for several), vectors
+ * under `embedding.values`, and tokens under
+ * `usageMetadata.promptTokenCount`. The dimension parameter is
+ * `outputDimensionality` and lives inside a config object rather than at the
+ * top level.
+ *
+ * @module session/adapters/embedding/gemini
+ */
+
+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'
+
+const BASE_URL = 'https://generativelanguage.googleapis.com/v1beta'
+
+export async function geminiEmbedding (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 taskType = resolveInputType(envelope, spec)
+
+  const model = spec.model ?? bareOf(envelope.model)
+  const name = model.startsWith('models/') ? model : `models/${model}`
+  const batched = envelope.input.length > 1
+
+  const one = (text) => ({
+    model: name,
+    content: { parts: [{ text }] },
+    ...(taskType ? { taskType } : {}),
+    ...(dimensions !== undefined ? { outputDimensionality: dimensions } : {})
+  })
+  const body = batched
+    ? { requests: envelope.input.map(one) }
+    : one(envelope.input[0])
+
+  const method = batched ? 'batchEmbedContents' : 'embedContent'
+  let res
+  try {
+    res = await fetchFn(`${BASE_URL}/${name}:${method}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': 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 vectors = batched
+    ? (payload?.embeddings ?? []).map(e => e?.values)
+    : [payload?.embedding?.values]
+
+  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
+    )
+  }
+
+  // Only the single-content endpoint reports usage; the batch one does not,
+  // so a batched call prices at 0 rather than on a guessed token count.
+  const inputTokens = payload?.usageMetadata?.promptTokenCount ?? 0
+  const end = String(process.hrtime.bigint())
+
+  return {
+    status: 'completed',
+    vectors,
+    dimensions: widthOf(vectors),
+    inputType: taskType,
+    inputTokens,
+    cost: computeEmbeddingCost(spec, { inputTokens }),
+    timestamps: { start, first: end, end }
+  }
+}

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,51 @@
+/**
+ * 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.
+ *
+ * @module session/run_embedding
+ */
+
+import { getEmbeddingAdapter } from './adapters/embedding/index.js'
+import { classifyProviderError } from './adapters/_errors.js'
+import { providerOf } from '#core/model-id.js'
+
+/**
+ * @param {import('#core/embedding.js').EmbedEnvelope} envelope
+ * @param {{resolveAdapter?: (provider: string) => any, 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 } = {}) {
+  let adapter
+  try {
+    adapter = resolveAdapter(providerOf(envelope.model))
+  } catch (e) {
+    return {
+      ok: false,
+      error: {
+        message: messageOf(e),
+        severity: 'error',
+        retryable: false,
+        type: 'SESSION_UNKNOWN_PROVIDER'
+      }
+    }
+  }
+
+  try {
+    const result = await adapter(envelope, spec ? { spec } : {})
+    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)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "1.1.0",
+  "version": "1.2.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.2.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.125.0",

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'
@@ -729,6 +729,20 @@ 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(),
+            configuration,
+            input,
+            options,
+            spec: modelSpec
+          })
+        }
+      }
+
       if (prop === 'setRateLimit') {
         return async ({ rpm, tpm } = {}) => {
           const curatedCache = getCuratedCacheSnapshot()

package/src/lib/provider-info.js

@@ -86,6 +86,13 @@ const PROVIDER_INFO = {
     hint: 'Create an API key in the MiMo open platform console',
     free: false
   },
+  cohere: {
+    label: 'Cohere',
+    description: 'Embeddings and reranking for retrieval. No chat models through mohdel.',
+    url: 'https://dashboard.cohere.com/api-keys',
+    hint: 'Create an API key in the Cohere dashboard under API Keys',
+    free: true
+  },
   qwen: {
     label: 'Qwen Cloud',
     description: 'Qwen — reasoning, coding, long context. Free quota for new users.',

package/src/lib/providers.js

@@ -86,6 +86,18 @@ const providers = {
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
   },
+  cohere: {
+    sdk: 'cohere',
+    api: 'embeddings',
+    apiKeyEnv: 'COHERE_API_SK',
+    baseURL: 'https://api.cohere.com/v2',
+    createConfiguration: apiKey => ({ apiKey }),
+    references: {
+      pricing: 'https://cohere.com/pricing',
+      models: 'https://docs.cohere.com/docs/models',
+      rateLimits: 'https://docs.cohere.com/docs/rate-limits'
+    }
+  },
   mistral: {
     sdk: 'openai',
     api: 'chatCompletions',

package/src/lib/schema.js

@@ -58,6 +58,13 @@ const fieldDefs = {
   imageEndpoint: { type: 'string' },
   imageDefaultSize: { type: 'string' },
   transcriptionPrice: { type: 'number' },
+  embeddingPrice: { type: 'number' },
+  dimensions: { type: 'number' },
+  dimensionsSelectable: { type: 'boolean' },
+  maxBatch: { type: 'number' },
+  maxInputTokens: { type: 'number' },
+  inputTypes: { type: 'object' },
+  defaultInputType: { type: 'string' },
   deprecated: { type: 'string' },
   suspended: { type: 'string' },
   rpmLimit: { type: 'number' },
@@ -77,6 +84,7 @@ const COMPUTED_FIELDS = new Set(['upstreamIds'])
 const TYPE_CHECKERS = {
   string: (v) => typeof v === 'string',
   number: (v) => typeof v === 'number',
+  boolean: (v) => typeof v === 'boolean',
   array: (v) => Array.isArray(v),
   object: (v) => typeof v === 'object' && v !== null && !Array.isArray(v)
 }