mohdel 0.112.0 → 0.114.0

package/README.md

@@ -1,6 +1,6 @@
 # Mohdel
 
-Self-hosted LLM gateway and SDK for Node — think LiteLLM, for the JS world. One `answer()` call for 11 providers; swap models by changing one string; get real per-call USD cost back on every result, with OpenTelemetry built in and process isolation when you need it. Your keys, your infra, no SaaS proxy in the path.
+Self-hosted LLM gateway and SDK for Node — think LiteLLM, for the JS world. One `answer()` call for 13 providers; swap models by changing one string; get real per-call USD cost back on every result, with OpenTelemetry built in and process isolation when you need it. Your keys, your infra, no SaaS proxy in the path.
 
 ```bash
 npm install -g mohdel
@@ -8,7 +8,7 @@ mo                                     # interactive setup — pick a provider,
 mo ask gemini/gemini-3-flash-preview "why is the sky blue"
 ```
 
-Providers: Anthropic, OpenAI, Gemini, Mistral, Groq, xAI, Cerebras, Fireworks, DeepSeek, OpenRouter, Novita. Node 22+, ES modules.
+Providers: Anthropic, OpenAI, Gemini, Mistral, Groq, xAI, Cerebras, Fireworks, DeepSeek, Qwen Cloud, Xiaomi, OpenRouter, Novita. Node 22+, ES modules.
 
 ## Why mohdel
 
@@ -306,6 +306,8 @@ What each provider supports through mohdel's unified interface:
 | DeepSeek | No | Yes | Yes | No | No | DSML tool-call fallback when model emits tags in content |
 | Fireworks | Yes | Yes | Yes | No | Yes (`reasoning_effort`) | OpenAI SDK + `baseURL`; model id auto-prefixed |
 | Mistral | No | Yes | Yes | No | No | `tool_choice: "any"` = required |
+| Qwen Cloud | No | Yes | No | No | Yes (`enable_thinking` + `thinking_budget`) | Alibaba DashScope intl; hybrid models think by default — effort `none` sends explicit off |
+| Xiaomi | No | 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 |
 | Novita | No | No | No | No | No | Image generation only |
 

package/js/session/adapters/_chat_completions.js

@@ -55,10 +55,14 @@ const DSML_PARAM_RE = /<\uFF5CDSML\uFF5Cparameter\s+name="([^"]+)"(?:\s+string="
  * @property {'openai'|'mistral'|'cerebras'} [toolChoiceFlavor]
  * @property {'user'|'safety_identifier'} [identifierField]
  *   Defaults to 'user'.
- * @property {'reasoning_effort'|'cerebras_zai'} [reasoningField]
+ * @property {'reasoning_effort'|'cerebras_zai'|'qwen'} [reasoningField]
  *   How to wire outputEffort into the request. `reasoning_effort`
  *   sets `args.reasoning_effort = effort`. `cerebras_zai` flips
  *   `args.disable_reasoning = false` instead (zai-family only).
+ *   `qwen` sets `args.enable_thinking` plus a numeric
+ *   `args.thinking_budget` from the spec's effort level — Qwen hybrid
+ *   models think by default, so `enable_thinking: false` must be sent
+ *   explicitly to switch thinking off.
  * @property {boolean} [parseDsml]
  *   Extract DeepSeek DSML function-call blocks from message content
  *   when native `tool_calls` is absent.
@@ -351,6 +355,11 @@ function buildRequest (envelope, spec, config) {
       if (effort !== 'none') delete args.temperature
       if (config.reasoningField === 'cerebras_zai' && /zai/i.test(bareOf(envelope.model))) {
         args.disable_reasoning = (effort === 'none')
+      } else if (config.reasoningField === 'qwen') {
+        args.enable_thinking = (effort !== 'none')
+        if (effort !== 'none' && typeof headroom === 'number') {
+          args.thinking_budget = headroom
+        }
       } else {
         args.reasoning_effort = effort
       }

package/js/session/adapters/_errors.js

@@ -243,6 +243,10 @@ const providerOverrides = {
     if (code === 'rate_limit_exceeded') return tierResult(detail)
     return undefined
   },
+  qwen (_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/_pricing.js

@@ -27,8 +27,15 @@ import { getSpec, setCatalog } from './_catalog.js'
  * Optional fields fall back to other prices when absent:
  *   - `thinkingPrice` → `outputPrice`
  *   - `cacheWritePrice` → `inputPrice` (graceful for non-caching providers)
+ *   - `cacheWrite1hPrice` → `cacheWritePrice` (graceful when only one write tier is priced)
  *   - `cacheReadPrice` → `inputPrice`
  *
+ * `cacheWrite1hInputTokens` is the 1h-TTL subset of `cacheWriteInputTokens`
+ * (Anthropic bills 1h writes at a higher rate than 5m). The 5m portion is
+ * `cacheWriteInputTokens - cacheWrite1hInputTokens`. When the 1h field is
+ * absent or the catalog has no `cacheWrite1hPrice`, the whole write bills at
+ * `cacheWritePrice` — identical to the single-tier behaviour.
+ *
  * Token-counting convention: this function is purely additive across
  * `inputTokens`, `cacheWriteInputTokens`, `cacheReadInputTokens`,
  * `outputTokens`, and `thinkingTokens`. Adapters normalize provider-specific
@@ -36,7 +43,8 @@ import { getSpec, setCatalog } from './_catalog.js'
  *
  * @param {any} spec  Catalog entry, or `undefined`.
  * @param {{inputTokens?: number, outputTokens?: number, thinkingTokens?: number,
- *          cacheWriteInputTokens?: number, cacheReadInputTokens?: number}} usage
+ *          cacheWriteInputTokens?: number, cacheWrite1hInputTokens?: number,
+ *          cacheReadInputTokens?: number}} usage
  * @returns {number}
  */
 export function computeCost (spec, usage) {
@@ -45,6 +53,8 @@ export function computeCost (spec, usage) {
   const o = usage.outputTokens ?? 0
   const t = usage.thinkingTokens ?? 0
   const cw = usage.cacheWriteInputTokens ?? 0
+  const cw1h = Math.min(cw, usage.cacheWrite1hInputTokens ?? 0)
+  const cw5m = Math.max(0, cw - cw1h)
   const cr = usage.cacheReadInputTokens ?? 0
   const ip = resolveTier(spec.inputPrice, i)
   const op = resolveTier(spec.outputPrice, i)
@@ -53,9 +63,11 @@ export function computeCost (spec, usage) {
   const tpFinal = typeof tp === 'number' ? tp : op
   const cwp = resolveTier(spec.cacheWritePrice, i)
   const cwpFinal = typeof cwp === 'number' ? cwp : ip
+  const cw1hp = resolveTier(spec.cacheWrite1hPrice, i)
+  const cw1hpFinal = typeof cw1hp === 'number' ? cw1hp : cwpFinal
   const crp = resolveTier(spec.cacheReadPrice, i)
   const crpFinal = typeof crp === 'number' ? crp : ip
-  const total = (i * ip + cw * cwpFinal + cr * crpFinal + o * op + t * tpFinal) / 1_000_000
+  const total = (i * ip + cw5m * cwpFinal + cw1h * cw1hpFinal + cr * crpFinal + o * op + t * tpFinal) / 1_000_000
   return round(total)
 }
 

package/js/session/adapters/anthropic.js

@@ -114,6 +114,7 @@ export async function * anthropic (envelope, deps = {}) {
   let inputTokens = 0
   let outputTokens = 0
   let cacheWriteTokens = 0
+  let cacheWrite1hTokens = 0
   let cacheReadTokens = 0
   let thinkingChars = 0
   let status = STATUS_COMPLETED
@@ -140,6 +141,12 @@ export async function * anthropic (envelope, deps = {}) {
           if (event.message?.usage?.cache_creation_input_tokens) {
             cacheWriteTokens = event.message.usage.cache_creation_input_tokens
           }
+          // cache_creation breaks the write total down by TTL (5m + 1h).
+          // Surface the 1h subset so the cost layer can price it separately;
+          // a request may mix TTLs, so both tiers can be non-zero.
+          if (event.message?.usage?.cache_creation?.ephemeral_1h_input_tokens) {
+            cacheWrite1hTokens = event.message.usage.cache_creation.ephemeral_1h_input_tokens
+          }
           if (event.message?.usage?.cache_read_input_tokens) {
             cacheReadTokens = event.message.usage.cache_read_input_tokens
           }
@@ -249,6 +256,7 @@ export async function * anthropic (envelope, deps = {}) {
       outputTokens: messageOutputTokens,
       thinkingTokens: estimatedThinkingTokens,
       ...(cacheWriteTokens > 0 && { cacheWriteInputTokens: cacheWriteTokens }),
+      ...(cacheWrite1hTokens > 0 && { cacheWrite1hInputTokens: cacheWrite1hTokens }),
       ...(cacheReadTokens > 0 && { cacheReadInputTokens: cacheReadTokens }),
       cost: costFor(
         catalogKey(envelope.model),
@@ -257,6 +265,7 @@ export async function * anthropic (envelope, deps = {}) {
           outputTokens: messageOutputTokens,
           thinkingTokens: estimatedThinkingTokens,
           cacheWriteInputTokens: cacheWriteTokens,
+          cacheWrite1hInputTokens: cacheWrite1hTokens,
           cacheReadInputTokens: cacheReadTokens
         }
       ),

package/js/session/adapters/gemini.js

@@ -104,6 +104,7 @@ export async function * gemini (envelope, deps = {}) {
   let inputTokens = 0
   let outputTokens = 0
   let thinkingTokens = 0
+  let cacheReadTokens = 0
   let status = STATUS_COMPLETED
   /** @type {string | undefined} */
   let warning
@@ -164,6 +165,9 @@ export async function * gemini (envelope, deps = {}) {
         if (typeof chunk.usageMetadata.thoughtsTokenCount === 'number') {
           thinkingTokens = chunk.usageMetadata.thoughtsTokenCount
         }
+        if (typeof chunk.usageMetadata.cachedContentTokenCount === 'number') {
+          cacheReadTokens = chunk.usageMetadata.cachedContentTokenCount
+        }
       }
     }
   } catch (e) {
@@ -186,18 +190,23 @@ export async function * gemini (envelope, deps = {}) {
   }
 
   const end = String(process.hrtime.bigint())
+  // Implicit caching reports cachedContentTokenCount as a SUBSET of
+  // promptTokenCount. Convert to mohdel's additive convention by subtracting
+  // the cached portion before pricing, matching the OpenAI adapter.
+  const regularInputTokens = Math.max(0, inputTokens - cacheReadTokens)
   /** @type {import('#core/events.js').DoneEvent} */
   const done = {
     type: 'done',
     result: {
       status,
       output: currentOutput() || null,
-      inputTokens,
+      inputTokens: regularInputTokens,
       outputTokens,
       thinkingTokens,
+      ...(cacheReadTokens > 0 && { cacheReadInputTokens: cacheReadTokens }),
       cost: costFor(
         catalogKey(envelope.model),
-        { inputTokens, outputTokens, thinkingTokens }
+        { inputTokens: regularInputTokens, outputTokens, thinkingTokens, cacheReadInputTokens: cacheReadTokens }
       ),
       timestamps: { start, first: first ?? end, end }
     }

package/js/session/adapters/index.js

@@ -23,6 +23,7 @@ import { mistral } from './mistral.js'
 import { novita } from './novita.js'
 import { openai } from './openai.js'
 import { openrouter } from './openrouter.js'
+import { qwen } from './qwen.js'
 import { xai } from './xai.js'
 import { xiaomi } from './xiaomi.js'
 
@@ -39,6 +40,7 @@ export const adapters = Object.freeze({
   novita,
   openai,
   openrouter,
+  qwen,
   xai,
   xiaomi
 })

package/js/session/adapters/qwen.js

@@ -0,0 +1,37 @@
+/**
+ * Qwen Cloud adapter — OpenAI-compatible chat completions against
+ * Alibaba's international DashScope endpoint. Reasoning arrives as
+ * the standard `reasoning_content` field handled by the shared core;
+ * thinking is wired via `reasoningField: 'qwen'` (`enable_thinking`
+ * + `thinking_budget`) because Qwen hybrid models think by default.
+ *
+ * @module session/adapters/qwen
+ */
+
+import OpenAI from 'openai'
+
+import { runChatCompletions } from './_chat_completions.js'
+import { streamingDispatcher } from './_dispatcher.js'
+
+const BASE_URL = 'https://dashscope-intl.aliyuncs.com/compatible-mode/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 * qwen (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: 'qwen',
+    reasoningField: 'qwen'
+  }, {
+    signal: deps.signal,
+    log: deps.log,
+    span: deps.span
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mohdel",
-  "version": "0.112.0",
+  "version": "0.114.0",
   "license": "MIT",
   "author": {
     "name": "Christophe Le Bars",
@@ -84,10 +84,10 @@
   },
   "optionalDependencies": {
     "@clack/prompts": "^1.5.1",
-    "@opentelemetry/exporter-trace-otlp-grpc": "^0.218.0",
-    "@opentelemetry/sdk-node": "^0.218.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.219.0",
+    "@opentelemetry/sdk-node": "^0.219.0",
     "chalk": "^5.4.0",
-    "mohdel-thin-gate-linux-x64-gnu": "0.112.0"
+    "mohdel-thin-gate-linux-x64-gnu": "0.114.0"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.104.1",

package/src/cli/onboard.js

@@ -83,6 +83,13 @@ const PROVIDER_INFO = {
     url: 'https://novita.ai/dashboard/key',
     hint: 'Create an API key at novita.ai → Dashboard → API Key',
     free: false
+  },
+  qwen: {
+    label: 'Qwen Cloud',
+    description: 'Qwen 3.7 Max/Plus, 3.6 Flash — reasoning, coding, long context. Free quota for new users.',
+    url: 'https://home.qwencloud.com/api-keys',
+    hint: 'Create an API key at home.qwencloud.com → API Keys',
+    free: false
   }
 }
 

package/src/lib/providers.js

@@ -88,6 +88,15 @@ const providers = {
     },
     creators: []
   },
+  qwen: {
+    sdk: 'openai',
+    api: 'chatCompletions',
+    apiKeyEnv: 'QWEN_API_SK',
+    createConfiguration: apiKey => ({ baseURL: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1', apiKey }),
+    creators: ['alibaba'],
+    contextSemantics: 'shared',
+    outputCapStrategy: 'accept'
+  },
   xai: {
     sdk: 'openai',
     apiKeyEnv: 'XAI_API_SK',