mohdel 0.105.1 → 0.106.0

package/js/core/envelope.js

@@ -57,6 +57,14 @@
  *   Opaque per-user ID passed to the provider for tracking / abuse
  *   monitoring.
  *
+ * @property {number} [idleHeartbeatMs]
+ *   When set, the session emits a synthetic `{type:'idle', sinceMs}`
+ *   event whenever the adapter has been silent for at least this
+ *   many milliseconds, and re-emits every `idleHeartbeatMs` while
+ *   the gap persists. The consumer decides whether to act (log,
+ *   bump a watchdog, abort via its own AbortSignal). Mohdel never
+ *   aborts on its own. Omitting the field disables the heartbeat.
+ *
  * @property {Object<string, object>} [providerOptions]
  *   Namespaced bag of provider-specific knobs that don't fit the
  *   shared envelope. Keys are provider names; values are arbitrary
@@ -139,5 +147,6 @@ export const ENVELOPE_FIELDS = Object.freeze([
   'toolChoice',
   'parallelToolCalls',
   'identifier',
+  'idleHeartbeatMs',
   'providerOptions'
 ])

package/js/core/events.js

@@ -1,8 +1,13 @@
 /**
  * Event union for the session → thin-gate → client stream.
  *
- * Three events:
+ * Four events:
  *   - `delta`  — streaming chunk (message text or function-call args).
+ *   - `idle`   — synthetic event emitted when the adapter has been
+ *                silent for at least `idleHeartbeatMs` (opt-in via
+ *                `CallEnvelope.idleHeartbeatMs`). Carries the elapsed
+ *                gap so the consumer can drive its own stall policy.
+ *                Never terminal; further events may follow.
  *   - `done`   — terminal with the full `AnswerResult`.
  *   - `error`  — wire-format error (serializable `TypedError`).
  *
@@ -12,7 +17,7 @@
  */
 
 /**
- * @typedef {(DeltaEvent | DoneEvent | ErrorEvent)} Event
+ * @typedef {(DeltaEvent | IdleEvent | DoneEvent | ErrorEvent)} Event
  */
 
 /**
@@ -23,6 +28,23 @@
  * @property {DeltaChunk} delta
  */
 
+/**
+ * Synthetic heartbeat emitted by `session/run.js` while the adapter
+ * is silent — i.e. no real event (delta / done / error / tool call)
+ * for at least `idleHeartbeatMs`. The consumer decides what to do
+ * (log, bump a watchdog, abort via its own AbortSignal). Mohdel
+ * never aborts on its own.
+ *
+ * Re-emitted every `idleHeartbeatMs` while the gap persists; the
+ * timer resets on the next real event.
+ *
+ * @typedef {object} IdleEvent
+ * @property {'idle'} type
+ * @property {number} sinceMs
+ *   Milliseconds since the last real event (or since the call
+ *   started, when no event has arrived yet).
+ */
+
 /**
  * @typedef {object} DeltaChunk
  * @property {('message'|'function_call')} type
@@ -109,7 +131,7 @@
  *   ToolCall back unchanged so the adapter can re-attach it.
  */
 
-export const EVENT_TYPES = Object.freeze(['delta', 'done', 'error'])
+export const EVENT_TYPES = Object.freeze(['delta', 'idle', 'done', 'error'])
 
 /**
  * @param {unknown} x

package/js/factory/bridge.js

@@ -51,6 +51,7 @@ import { createRealtimeDeltaBuffer } from '../../src/lib/utils.js'
  * | `images` / `videos` / `cache`                     | flat fields on envelope                              |
  * | `tools` / `toolChoice` / `parallelToolCalls`      | flat fields on envelope                              |
  * | `identifier`                                      | envelope.identifier (adapter maps to provider field) |
+ * | `idleHeartbeatMs`                                 | envelope.idleHeartbeatMs (session emits idle events) |
  * | `realtimeHandler` / `bufferOpts`                  | drained via createRealtimeDeltaBuffer                |
  * | `providerOrder` / `providerAllow` / `providerDeny`| envelope.providerOptions.openrouter                  |
  * | `traceparent` / `baggage`                         | envelope transport metadata                          |
@@ -183,6 +184,7 @@ function toEnvelope ({ modelKey, configuration, prompt, options }) {
   if (options.toolChoice) envelope.toolChoice = options.toolChoice
   if (options.parallelToolCalls === false) envelope.parallelToolCalls = false
   if (options.identifier) envelope.identifier = options.identifier
+  if (options.idleHeartbeatMs !== undefined) envelope.idleHeartbeatMs = options.idleHeartbeatMs
 
   // OpenRouter routing prefs ride in their own bag to keep the flat
   // envelope clean. The openrouter adapter reads this via

package/js/session/_idle_heartbeat.js

@@ -0,0 +1,77 @@
+/**
+ * Idle-heartbeat wrapper for an adapter's event stream.
+ *
+ * `withIdleHeartbeat(source, idleMs)` consumes `source` and re-emits
+ * every event it yields. When `source` is silent for at least
+ * `idleMs`, an `{type:'idle', sinceMs}` event is yielded; while the
+ * silence persists, further idle events are yielded every `idleMs`.
+ * The timer resets on every real event.
+ *
+ * Idle events are advisory — mohdel does not abort the call on its
+ * own. Consumers decide whether to log, bump a watchdog, or trigger
+ * an external AbortSignal.
+ *
+ * The in-flight `iterator.next()` is reused across timer firings so
+ * no real event is dropped: when the timer wins the race, the
+ * underlying promise stays pending and the next loop iteration
+ * attaches a fresh race to the same promise.
+ *
+ * @module session/_idle_heartbeat
+ */
+
+/**
+ * @template T
+ * @param {AsyncIterable<T>} source
+ * @param {number | undefined | null} idleMs
+ *   When falsy or non-positive, the source is yielded through
+ *   unchanged (no timer is set up).
+ * @returns {AsyncGenerator<T | import('#core/events.js').IdleEvent>}
+ */
+export async function * withIdleHeartbeat (source, idleMs) {
+  if (!idleMs || idleMs <= 0) {
+    yield * source
+    return
+  }
+
+  const iter = source[Symbol.asyncIterator]()
+  let lastAt = Date.now()
+  /** @type {Promise<IteratorResult<T>> | null} */
+  let pending = null
+
+  try {
+    while (true) {
+      if (!pending) pending = iter.next()
+
+      /** @type {NodeJS.Timeout | undefined} */
+      let timer
+      /** @type {{idle: true} | {real: IteratorResult<T>} | {err: unknown}} */
+      const winner = await new Promise(resolve => {
+        timer = setTimeout(() => resolve({ idle: true }), idleMs)
+        pending.then(
+          r => resolve({ real: r }),
+          e => resolve({ err: e })
+        )
+      })
+      clearTimeout(timer)
+
+      if ('idle' in winner) {
+        yield /** @type {import('#core/events.js').IdleEvent} */ ({
+          type: 'idle',
+          sinceMs: Date.now() - lastAt
+        })
+        continue
+      }
+
+      pending = null
+      if ('err' in winner) throw winner.err
+      if (winner.real.done) return
+      lastAt = Date.now()
+      yield winner.real.value
+    }
+  } finally {
+    // Best-effort cleanup if the consumer abandons us mid-stream.
+    if (typeof iter.return === 'function') {
+      try { await iter.return() } catch { /* ignore */ }
+    }
+  }
+}

package/js/session/adapters/_errors.js

@@ -239,6 +239,10 @@ const providerOverrides = {
     if (code === 'rate_limit_exceeded') return tierResult(detail)
     return undefined
   },
+  xiaomi (_err, code, detail) {
+    if (code === 'rate_limit_exceeded') return tierResult(detail)
+    return undefined
+  },
   novita (_err, code, detail) {
     if (code === 'rate_limit_exceeded') return tierResult(detail)
     return undefined

package/js/session/adapters/anthropic.js

@@ -216,13 +216,27 @@ export async function * anthropic (envelope, deps = {}) {
   // output_tokens and what actually streamed as visible output (text +
   // tool input JSON) — catches redacted_thinking blocks (opus 4.7 default)
   // that consume output tokens but emit no streaming deltas.
+  //
+  // When the caller explicitly disabled thinking via `outputEffort: 'none'`,
+  // we did NOT send `request.thinking` (see buildRequest) — Anthropic
+  // won't emit thinking content, redacted or otherwise — so the fallback
+  // heuristic would only attribute the natural chars/4 estimation gap
+  // (Anthropic packs denser than 4 chars/token on most content) to a
+  // non-existent thinking budget. Trust the explicit opt-out and report
+  // zero.
   const streamedOutput = currentOutput()
   const streamedOutputChars = streamedOutput.length +
     [...toolBlocks.values()].reduce((s, b) => s + b.inputJson.length, 0)
   const streamedOutputTokens = Math.ceil(streamedOutputChars / ANTHROPIC_THINKING_CHARS_PER_TOKEN)
-  const estimatedThinkingTokens = thinkingChars > 0
-    ? Math.min(Math.ceil(thinkingChars / ANTHROPIC_THINKING_CHARS_PER_TOKEN), outputTokens)
-    : Math.max(0, outputTokens - streamedOutputTokens)
+  const thinkingDisabled = envelope.outputEffort === 'none'
+  let estimatedThinkingTokens
+  if (thinkingDisabled) {
+    estimatedThinkingTokens = 0
+  } else if (thinkingChars > 0) {
+    estimatedThinkingTokens = Math.min(Math.ceil(thinkingChars / ANTHROPIC_THINKING_CHARS_PER_TOKEN), outputTokens)
+  } else {
+    estimatedThinkingTokens = Math.max(0, outputTokens - streamedOutputTokens)
+  }
   const messageOutputTokens = Math.max(0, outputTokens - estimatedThinkingTokens)
 
   /** @type {import('#core/events.js').DoneEvent} */

package/js/session/adapters/index.js

@@ -24,6 +24,7 @@ import { novita } from './novita.js'
 import { openai } from './openai.js'
 import { openrouter } from './openrouter.js'
 import { xai } from './xai.js'
+import { xiaomi } from './xiaomi.js'
 
 export const adapters = Object.freeze({
   anthropic,
@@ -38,7 +39,8 @@ export const adapters = Object.freeze({
   novita,
   openai,
   openrouter,
-  xai
+  xai,
+  xiaomi
 })
 
 /**

package/js/session/adapters/xiaomi.js

@@ -0,0 +1,35 @@
+/**
+ * Xiaomi MiMo adapter — OpenAI-compatible chat completions against
+ * api.xiaomimimo.com. Standard `reasoning_content` field handling
+ * is provided by the shared core; this module just wires the base
+ * URL and provider tag.
+ *
+ * @module session/adapters/xiaomi
+ */
+
+import OpenAI from 'openai'
+
+import { runChatCompletions } from './_chat_completions.js'
+import { streamingDispatcher } from './_dispatcher.js'
+
+const BASE_URL = 'https://api.xiaomimimo.com/v1'
+
+/**
+ * @param {import('#core/envelope.js').CallEnvelope} envelope
+ * @param {{client?: any, signal?: AbortSignal, log?: any, span?: any}} [deps]
+ * @returns {AsyncGenerator<import('#core/events.js').Event>}
+ */
+export async function * xiaomi (envelope, deps = {}) {
+  const client = deps.client ?? new OpenAI({
+    apiKey: envelope.auth.key,
+    baseURL: envelope.auth.baseURL || BASE_URL,
+    fetchOptions: { dispatcher: streamingDispatcher() }
+  })
+  yield * runChatCompletions(envelope, client, {
+    provider: 'xiaomi'
+  }, {
+    signal: deps.signal,
+    log: deps.log,
+    span: deps.span
+  })
+}

package/js/session/run.js

@@ -29,6 +29,7 @@ import { getProviderLimits } from './adapters/_providers.js'
 import { providerOf, catalogKey, effortOf } from '#core/model-id.js'
 import * as defaultCooldown from './_cooldown.js'
 import * as defaultLimiter from './_rate_limiter.js'
+import { withIdleHeartbeat } from './_idle_heartbeat.js'
 import { logger as defaultLogger } from './_logger.js'
 import {
   startSpan,
@@ -175,7 +176,18 @@ export async function * run (envelope, {
   let lastFrameAt = startedAt
   let maxInterFrameMs = 0
   try {
-    for await (const ev of adapter(envelope, { signal, log, span })) {
+    const adapterStream = adapter(envelope, { signal, log, span })
+    const heartbeated = withIdleHeartbeat(adapterStream, envelope.idleHeartbeatMs)
+    for await (const ev of heartbeated) {
+      // Idle events are synthetic — they're emitted *because* nothing
+      // else has happened. Don't reset the inter-frame clock (that
+      // would mask the very stall the heartbeat is reporting) and
+      // don't run them through the terminal/cooldown branches.
+      if (ev.type === 'idle') {
+        yield ev
+        continue
+      }
+
       const now = Date.now()
       const gap = now - lastFrameAt
       if (gap > maxInterFrameMs) maxInterFrameMs = gap

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "0.105.1",
+  "version": "0.106.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -87,7 +87,7 @@
     "@opentelemetry/exporter-trace-otlp-grpc": "^0.218.0",
     "@opentelemetry/sdk-node": "^0.218.0",
     "chalk": "^5.4.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.105.1"
+    "mohdel-thin-gate-linux-x64-gnu": "0.106.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.95.2",

package/src/lib/creators.js

@@ -39,6 +39,11 @@ const creators = {
     logo: 'minimax.svg',
     description: 'Minimax offers versatile Chinese-first chat and coding models tuned for fast, cost-aware assistants and enterprise integrations.'
   },
+  mistral: {
+    label: 'Mistral',
+    logo: 'mistral.svg',
+    description: 'Mistral AI ships strong open-weight and proprietary models with a focus on European hosting, multilingual quality, and efficient deployment.'
+  },
   moonshotai: {
     label: 'Moonshot AI',
     logo: 'moonshotai.svg',

package/src/lib/providers.js

@@ -95,6 +95,15 @@ const providers = {
     creators: ['xai'],
     contextSemantics: 'shared',
     outputCapStrategy: 'accept'
+  },
+  xiaomi: {
+    sdk: 'openai',
+    api: 'chatCompletions',
+    apiKeyEnv: 'XIAOMI_API_SK',
+    createConfiguration: apiKey => ({ baseURL: 'https://api.xiaomimimo.com/v1', apiKey }),
+    creators: ['xiaomi'],
+    contextSemantics: 'shared',
+    outputCapStrategy: 'accept'
   }
 }