mohdel 0.123.0 → 0.125.0

package/README.md

@@ -154,7 +154,9 @@ const result = await mo.use('anthropic/claude-sonnet-4-6').answer('Hello')
 console.log(result.output, result.cost)
 ```
 
-No subprocess, no setup beyond your API key. Right for CLI tools (`mo ask`), scripts, tests, and single-process services — which is most projects.
+No subprocess, no setup beyond your API key. Right for CLI tools (`mo ask`), scripts, tests, and single-process services — which is most projects. Pass an `AbortSignal` as `answer(prompt, { signal })` to cancel in flight.
+
+The factory reads the catalog from `~/.config/mohdel/curated.json` and keys from the environment, the same defaults a gate session starts from. `mohdel({ models })` replaces the catalog for the process, factory and session runtime alike, the way `set_catalog` replaces it in a gate session. `mohdel({ configurations: { openai: { apiKey } } })` overrides the key per provider.
 
 ### Client — cross-process (the production gateway)
 
@@ -231,7 +233,7 @@ With no session-bin configured, thin-gate runs in demo mode: `POST /v1/call` ret
 
 ### Calling from JS
 
-The client snippet under [Library Usage](#library-usage) above is the full surface: `call(envelope, { socketPath, signal? })` returns an async iterable of events. Pass an `AbortSignal` to cancel in flight; thin-gate forwards a cancel control message to the session and reuses it on the pool. The envelope is the flat `answer(prompt, options)` surface plus transport metadata (`callId`, `authId`, `auth.key`, optional `traceparent`); see [`js/core/envelope.js`](js/core/envelope.js) for the full field list.
+The client snippet under [Library Usage](#library-usage) above is the full surface: `call(envelope, { socketPath, signal? })` returns an async iterable of events. Pass an `AbortSignal` to cancel in flight; thin-gate forwards a cancel control message to the session and reuses it on the pool, and the client ends the stream with the same cancelled `done` the in-process path returns (status `incomplete`, warning `cancelled`, the partial output it relayed, zero tokens). The envelope is the flat `answer(prompt, options)` surface plus transport metadata (`callId`, `authId`, `auth.key`, optional `traceparent`); see [`js/core/envelope.js`](js/core/envelope.js) for the full field list.
 
 ### Other languages
 

package/js/client/call.js

@@ -1,17 +1,42 @@
 /**
  * Send a CallEnvelope to thin-gate; returns an async iterable of Events.
  *
- * Cancellation: pass an AbortSignal. Aborting destroys the HTTP request;
- * thin-gate infers cancel from connection close and emits
- * `call.cancelled` upstream.
- *
+ * Cancellation: pass an AbortSignal. Aborting closes the HTTP request;
+ * thin-gate infers cancel from connection close and sends the session a
+ * cancel control message. The session's own cancelled terminal is drained
+ * gate-side, so the client synthesizes the same cancelled `done` here —
+ * partial output from the deltas it relayed, zero tokens, zero cost —
+ * giving a caller the same terminal on this path as on the in-process one.
  * @module client/call
  */
 
 import { requestUnix } from './transport.js'
 import { readAll, parseErrorBody } from './response.js'
 import { parseNDJSON } from './ndjson.js'
-import { isEvent, MohdelError } from '#core'
+import { isEvent, MohdelError, STATUS_INCOMPLETE, WARNING_CANCELLED } from '#core'
+
+/**
+ * @param {string} start
+ * @param {string | null} first
+ * @param {string} output
+ * @returns {import('#core/events.js').DoneEvent}
+ */
+function cancelledDone (start, first, output) {
+  const end = String(process.hrtime.bigint())
+  return {
+    type: 'done',
+    result: {
+      status: STATUS_INCOMPLETE,
+      output: output || null,
+      inputTokens: 0,
+      outputTokens: 0,
+      thinkingTokens: 0,
+      cost: 0,
+      timestamps: { start, first: first ?? end, end },
+      warning: WARNING_CANCELLED
+    }
+  }
+}
 
 /**
  * @param {import('#core/envelope.js').CallEnvelope} envelope
@@ -22,26 +47,58 @@ import { isEvent, MohdelError } from '#core'
  * @returns {AsyncGenerator<import('#core/events.js').Event>}
  */
 export async function * call (envelope, { socketPath, signal, path = '/v1/call' }) {
-  const res = await requestUnix({
-    socketPath,
-    path,
-    method: 'POST',
-    body: envelope,
-    signal
-  })
+  const start = String(process.hrtime.bigint())
+  if (signal?.aborted) {
+    yield cancelledDone(start, null, '')
+    return
+  }
+
+  let res
+  try {
+    res = await requestUnix({
+      socketPath,
+      path,
+      method: 'POST',
+      body: envelope,
+      signal
+    })
+  } catch (e) {
+    if (signal?.aborted) {
+      yield cancelledDone(start, null, '')
+      return
+    }
+    throw e
+  }
 
   if (res.statusCode !== 200) {
     const body = await readAll(res)
     throw MohdelError.fromJSON(parseErrorBody(body, res.statusCode ?? 0))
   }
 
-  for await (const obj of parseNDJSON(res)) {
-    if (!isEvent(obj)) {
-      throw new MohdelError(
-        'received non-Event object from thin-gate',
-        { type: 'PROTOCOL_INVALID_EVENT', retryable: false }
-      )
+  const outputParts = []
+  let first = null
+  let sawTerminal = false
+  try {
+    for await (const obj of parseNDJSON(res)) {
+      if (!isEvent(obj)) {
+        throw new MohdelError(
+          'received non-Event object from thin-gate',
+          { type: 'PROTOCOL_INVALID_EVENT', retryable: false }
+        )
+      }
+      if (obj.type === 'delta') {
+        if (first === null) first = String(process.hrtime.bigint())
+        if (obj.delta?.type === 'message') outputParts.push(obj.delta.delta)
+      } else if (obj.type === 'done' || obj.type === 'error') {
+        sawTerminal = true
+      }
+      yield /** @type {import('#core/events.js').Event} */(obj)
     }
-    yield /** @type {import('#core/events.js').Event} */(obj)
+  } catch (e) {
+    if (!signal?.aborted) throw e
+  }
+
+  if (signal?.aborted && !sawTerminal) {
+    yield cancelledDone(start, first, outputParts.join(''))
   }
 }

package/js/factory/bridge.js

@@ -35,7 +35,6 @@ import { createRealtimeDeltaBuffer } from '../../src/lib/utils.js'
  *   Hook that returns `{rpmLimit, tpmLimit}` for a given provider —
  *   lets the factory keep its own `providersConfig` as source of
  *   truth instead of the module-level `providers.json` loader.
- * @property {AbortSignal} [signal]
  */
 
 /**
@@ -58,6 +57,7 @@ import { createRealtimeDeltaBuffer } from '../../src/lib/utils.js'
  * | `providerOrder` / `providerAllow` / `providerDeny`| envelope.providerOptions.openrouter                  |
  * | `traceparent` / `baggage`                         | envelope transport metadata                          |
  * | `callId` / `authId`                               | envelope transport metadata                          |
+ * | `signal`                                          | not on the wire — `run()` deps, aborts the call      |
  * | `configuration.apiKey`                            | envelope.auth.key                                    |
  * | **`parentSpan`**                                  | **dropped** — use `traceparent` instead              |
  * | **`maybeThrowHandler`**                           | **dropped** — no factory-side validation hook        |
@@ -90,7 +90,7 @@ export async function runAnswer ({ provider, model, modelKey, configuration, pro
 
   let terminal
   try {
-    for await (const ev of run(envelope, deps)) {
+    for await (const ev of run(envelope, { ...deps, signal: options.signal })) {
       if (ev.type === 'delta' && ev.delta) {
         if (deltaBuffer) deltaBuffer.push(ev.delta.type, ev.delta.delta)
       } else if (ev.type === 'done' || ev.type === 'error') {

package/js/session/adapters/_cancelled.js

@@ -2,12 +2,6 @@
  * Shared `cancelledDone` helper for adapters that need to synthesize
  * a terminal `done` event on `signal.aborted` mid-stream.
  *
- * Three adapters (openai, anthropic, gemini) had byte-identical
- * copies of this; consolidated here. `_chat_completions.js`
- * and `run.js` have their own cancel paths — don't migrate them
- * here unless you're certain the shape matches (thinkingTokens,
- * cost, tool_calls semantics can all differ).
- *
  * @module session/adapters/_cancelled
  */
 

package/js/session/adapters/_chat_completions.js

@@ -19,6 +19,7 @@
 import { getSpec } from './_catalog.js'
 import { classifyProviderError } from './_errors.js'
 import { costFor } from './_pricing.js'
+import { cancelledDone } from './_cancelled.js'
 import { catalogKey, bareOf } from '#core/model-id.js'
 import {
   STATUS_COMPLETED,
@@ -98,6 +99,10 @@ export async function * runChatCompletions (envelope, client, config, deps = {})
   try {
     response = await client.chat.completions.create(args, { signal: deps.signal })
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, null, envelope, '', 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
@@ -161,6 +166,10 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
   try {
     stream = await client.chat.completions.create(args, { signal: deps.signal })
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, null, envelope, '', 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] request failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
@@ -168,6 +177,10 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
 
   try {
     for await (const chunk of stream) {
+      if (deps.signal?.aborted) {
+        yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+        return
+      }
       const choice = chunk.choices?.[0]
       // DeepSeek V4 / deepseek-reasoner / Cerebras reasoning models emit
       // `delta.reasoning_content` chunks before visible content. Capture
@@ -225,11 +238,20 @@ async function * runStreaming (envelope, client, args, config, start, deps) {
       if (chunk.usage) usage = chunk.usage
     }
   } catch (e) {
+    if (deps.signal?.aborted) {
+      yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+      return
+    }
     deps.log?.warn({ err: e }, `[mohdel:${config.provider}] stream failed`)
     yield { type: 'error', error: classifyProviderError(e, envelope.auth?.key, { provider: config.provider }) }
     return
   }
 
+  if (deps.signal?.aborted) {
+    yield cancelledDone(start, first, envelope, contentParts.join(''), 0, 0)
+    return
+  }
+
   const collectedToolCalls = Object.values(toolCallAccum).map(tc => ({
     id: tc.id,
     function: { name: tc.name, arguments: tc.arguments }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "0.123.0",
+  "version": "0.125.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -108,16 +108,16 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.222.0",
     "@opentelemetry/sdk-node": "^0.222.0",
     "chalk": "^6.0.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.123.0"
+    "mohdel-thin-gate-linux-x64-gnu": "0.125.0"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.122.0",
+    "@anthropic-ai/sdk": "^0.123.0",
     "@cerebras/cerebras_cloud_sdk": "^1.91.0",
-    "@google/genai": "^2.20.0",
+    "@google/genai": "^2.21.0",
     "@opentelemetry/api": "^1.9.1",
     "env-paths": "^4.0.0",
     "groq-sdk": "^1.6.0",
-    "openai": "^7.8.0",
+    "openai": "^7.9.0",
     "undici": "^7.29.0"
   },
   "lint-staged": {

package/src/cli/ask.js

@@ -13,7 +13,7 @@ export const hintsForError = (err, modelId) => {
   const provider = modelId.includes('/') ? modelId.split('/')[0] : null
   const hints = []
 
-  if (/not found in curated models/i.test(both)) {
+  if (/not found in catalog/i.test(both)) {
     if (provider) {
       hints.push(`→ run:  mo curate ${provider}        # add upstream models from this provider`)
       hints.push(`→ or:   mo model add ${modelId}      # add this one manually`)

package/src/lib/common.js

@@ -112,12 +112,11 @@ const createFileOperation = (filePath, defaultValue = {}, operationType) => {
   const loadHandler = async () => {
     let loadedData
     try {
-      if (!existsSync(CONFIG_DIR)) {
-        await mkdir(CONFIG_DIR, { recursive: true })
-      }
-
       if (!existsSync(filePath)) {
         if (defaultValue && Object.keys(defaultValue).length > 0) {
+          if (!existsSync(CONFIG_DIR)) {
+            await mkdir(CONFIG_DIR, { recursive: true })
+          }
           await writeFile(filePath, JSON.stringify(defaultValue, null, 2))
           loadedData = JSON.parse(JSON.stringify(defaultValue))
         } else {

package/src/lib/curated-cache.js

@@ -69,6 +69,11 @@ const rebuildAliasMap = () => {
 
 export const loadCuratedCache = ensureCuratedCache
 
+export const setCuratedCache = (table) => {
+  curatedCache = { ...table }
+  aliasMapCache = buildAliasMap(curatedCache)
+}
+
 export const getCuratedCacheSnapshot = () => curatedCache
 
 export const getAliasMapSnapshot = () => aliasMapCache

package/src/lib/index.js

@@ -7,6 +7,7 @@ import providers from './providers.js'
 import { getAPIKey, loadDefaultEnv, getProvidersConfig, saveProvidersConfig, setLogger as setCommonLogger } from './common.js'
 import {
   loadCuratedCache,
+  setCuratedCache,
   getCuratedCacheSnapshot,
   expandModelAliasSync,
   suggestModels,
@@ -14,6 +15,7 @@ import {
 } from './curated-cache.js'
 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 { startSpan, endSpanOk, endSpanError } from './tracing.js'
 import { isValidTag } from './schema.js'
@@ -200,21 +202,27 @@ export { buildHandlers as _buildHandlersForTests }
  * @param {Function} [opts.onFailure]           — fired after every failed answer call
  * @param {number} [opts.cooldownThreshold=3]   — consecutive provider failures before cooldown
  * @param {number} [opts.cooldownDuration=60000] — cooldown duration in ms
- * @param {object} [opts.models]                — model catalog (library mode — skips disk init)
- * @param {object} [opts.configurations]        — provider configurations (library mode)
+ * @param {object} [opts.models]                — catalog `{ [provider/model]: spec }`. Replaces
+ *                                                `~/.config/mohdel/curated.json` for this process,
+ *                                                factory and session runtime alike.
+ * @param {object} [opts.configurations]        — `{ [provider]: { apiKey } }`. Overrides the env
+ *                                                key per provider; env for the rest.
  */
 const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, cooldownThreshold, cooldownDuration, models, configurations } = {}) => {
-  // When consumer provides models + configurations, skip disk-based init (library mode).
-  // Otherwise load from ~/.config/mohdel/ (CLI / standalone mode).
-  const libraryMode = !!(models && configurations)
-
-  if (!libraryMode) {
-    loadDefaultEnv()
+  loadDefaultEnv()
+
+  // The session runtime keeps its own catalog cache (the seam thin-gate's
+  // `set_catalog` uses) and would otherwise lazy-load curated.json, so a
+  // replacement has to reach both caches.
+  if (models) {
+    setCuratedCache(models)
+    setCatalog(models)
+  } else {
     await loadCuratedCache()
   }
 
   // Provider config: user-specific rate limits per provider (~/.config/mohdel/providers.json)
-  const providersConfig = libraryMode ? {} : await getProvidersConfig()
+  const providersConfig = await getProvidersConfig()
 
   // Resolve verbosity tier once at init. Factory opt > env var > default.
   // Captured in the answer() closure below to gate per-call log lines.
@@ -248,7 +256,7 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
     get: (target, prop) => {
       if (prop === 'list') {
         return (tag) => { // Sync
-          const catalog = libraryMode ? models : getCuratedCacheSnapshot()
+          const catalog = getCuratedCacheSnapshot()
           let modelEntries = Object.entries(catalog)
             .filter(([, metadata]) => !metadata.deprecated)
 
@@ -267,7 +275,7 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
 
       if (prop === 'use') {
         return (modelId) => { // Sync
-          const catalog = libraryMode ? models : getCuratedCacheSnapshot()
+          const catalog = getCuratedCacheSnapshot()
 
           // Parse optional :outputEffort suffix (e.g. "claude-opus:max").
           // Effort levels vary per spec (`thinkingEffortLevels` keys —
@@ -284,7 +292,7 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
           // Fallback specs are excluded from that test on purpose:
           // providers that synthesize them resolve any string, which
           // would disable suffix parsing for them entirely.
-          const exactId = libraryMode ? modelId : expandModelAliasSync(modelId)
+          const exactId = expandModelAliasSync(modelId)
           const isCuratedId = !!catalog[exactId]
 
           // `@speed` is parsed off first so the two suffixes are read
@@ -299,7 +307,7 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
             // resolves the same as `x@fast`.
             const colon = base.lastIndexOf(':')
             const probe = colon > 0 ? base.slice(0, colon) : base
-            const probeResolved = libraryMode ? probe : expandModelAliasSync(probe)
+            const probeResolved = expandModelAliasSync(probe)
             if (catalog[probeResolved] || createFallbackModelSpec(probeResolved)) {
               aliasSpeed = candidate
               modelId = base
@@ -311,7 +319,7 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
           if (colonIdx > 0) {
             const candidate = modelId.slice(colonIdx + 1)
             const base = modelId.slice(0, colonIdx)
-            const baseResolved = libraryMode ? base : expandModelAliasSync(base)
+            const baseResolved = expandModelAliasSync(base)
             const baseSpec = catalog[baseResolved] || createFallbackModelSpec(baseResolved)
             if (baseSpec) {
               aliasOutputEffort = candidate
@@ -319,17 +327,14 @@ const mohdel = async ({ logger, verbosity: verbosityOpt, onSuccess, onFailure, c
             }
           }
 
-          let resolvedModelId = libraryMode ? modelId : expandModelAliasSync(modelId)
+          let resolvedModelId = expandModelAliasSync(modelId)
           let modelSpec = catalog[resolvedModelId]
 
           if (!modelSpec) {
             modelSpec = createFallbackModelSpec(resolvedModelId)
             if (!modelSpec) {
-              if (libraryMode) {
-                throw new Error(`Model '${modelId}' not found in provided models.`)
-              }
               const suggestions = suggestModels(modelId)
-              let msg = `Model '${modelId}' not found in curated models.`
+              let msg = `Model '${modelId}' not found in catalog.`
               if (suggestions.length) {
                 msg += ' Did you mean?\n' + suggestions.map(s => `  ${s.id}  ${s.label}`).join('\n')
               }
@@ -777,7 +782,7 @@ const createModelProxy = (resolvedModelId, modelSpec, handlers, aliasOutputEffor
 
       if (prop === 'info') {
         return () => { // Sync
-          const catalog = externalConfigurations ? null : getCuratedCacheSnapshot()
+          const catalog = getCuratedCacheSnapshot()
           return catalog?.[resolvedModelId] ? { ...catalog[resolvedModelId] } : { ...modelSpec }
         }
       }