@goodandready/dsh-clinebot 0.5.20 → 0.5.22

package/lib/models.js

@@ -52,12 +52,26 @@ export function getOriginalModelContext(nameOrId) {
   if (norm.includes('qwen')) return 1000000
   if (norm.includes('minimax')) return 1000000
   if (norm.includes('mimo')) return 1000000
+  if (norm.includes('glm-5.3') || norm.includes('glm-53')) return 1000000
+  if (norm.includes('deepseek-v4.1') || norm.includes('deepseek-v41')) return 1000000
   if (norm.includes('deepseek')) return 128000
   if (norm.includes('glm')) return 128000
   return 200000
 }
 
-function getOriginalModelProvider(nameOrId) {
+export function getOriginalModelMaxTokens(nameOrId) {
+  const norm = String(nameOrId || '').toLowerCase()
+  if (norm.includes('qwen')) return 131072
+  if (norm.includes('glm')) return 128000
+  if (norm.includes('minimax')) return 128000
+  if (norm.includes('kimi')) return 65536
+  if (norm.includes('deepseek-v4.1') || norm.includes('deepseek-v41')) return 65536
+  if (norm.includes('deepseek')) return 16384
+  if (norm.includes('mimo')) return 16384
+  return 16384
+}
+
+export function getOriginalModelProvider(nameOrId) {
   const norm = String(nameOrId || '').toLowerCase()
   if (norm.includes('kimi')) return 'Moonshot AI'
   if (norm.includes('qwen')) return 'Alibaba Cloud'
@@ -68,181 +82,102 @@ function getOriginalModelProvider(nameOrId) {
   return 'Original Vendor'
 }
 
+function createCuratedModel({
+  id, name, description,
+  ctx = 128000, maxTokens = 8192,
+  origCtx, origMax, origProv,
+  input = ['text'], category = 'general',
+  recommended = false, reasoningEfforts,
+}) {
+  const c = origCtx || getOriginalModelContext(id)
+  const p = origProv || getOriginalModelProvider(id)
+  const om = origMax || getOriginalModelMaxTokens(id)
+  return {
+    id, name, description,
+    clineContextLength: ctx, defaultContextLength: ctx, contextLength: ctx,
+    originalContextLength: c, originalProvider: p, originalMaxTokens: om,
+    maxTokens, defaultMaxTokens: maxTokens,
+    input, category, recommended, isCustom: false,
+    ...(reasoningEfforts ? { reasoningEfforts } : {}),
+  }
+}
+
 export const CLINE_MODELS = Object.freeze([
-  {
+  createCuratedModel({
     id: 'cline-pass/deepseek-v4-flash',
     name: 'DeepSeek V4 Flash',
     description: 'High-speed reasoning & code completion model optimized for agentic loops.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 128000,
-    originalProvider: 'DeepSeek',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'coding',
-    recommended: true,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'coding', recommended: true,
     reasoningEfforts: ['low', 'medium', 'high'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/deepseek-v4-pro',
     name: 'DeepSeek V4 Pro',
     description: 'Flagship reasoning and multi-turn architectural coding model.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 128000,
-    originalProvider: 'DeepSeek',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'coding',
-    recommended: true,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'coding', recommended: true,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/glm-5.2',
     name: 'GLM 5.2',
     description: 'Bilingual general & coding model with strong instruction following.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 128000,
-    originalProvider: 'Zhipu AI',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text'],
-    category: 'general',
-    recommended: false,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text'], category: 'general', recommended: false,
     reasoningEfforts: ['low', 'medium', 'high'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/kimi-k3',
     name: 'Kimi K3',
     description: 'Long-context reasoning & document synthesis model by Moonshot AI.',
-    clineContextLength: 200000,
-    defaultContextLength: 200000,
-    originalContextLength: 2000000,
-    originalProvider: 'Moonshot AI',
-    contextLength: 200000,
-    maxTokens: 8192,
-    input: ['text'],
-    category: 'reasoning',
-    recommended: true,
-    isCustom: false,
+    ctx: 200000, maxTokens: 8192, input: ['text'], category: 'reasoning', recommended: true,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/kimi-k2.7-code',
     name: 'Kimi K2.7 Code',
     description: 'Specialized coding model with agentic tool calling support.',
-    clineContextLength: 200000,
-    defaultContextLength: 200000,
-    originalContextLength: 2000000,
-    originalProvider: 'Moonshot AI',
-    contextLength: 200000,
-    maxTokens: 8192,
-    input: ['text'],
-    category: 'coding',
-    recommended: false,
-    isCustom: false,
-  },
-  {
+    ctx: 200000, maxTokens: 8192, input: ['text'], category: 'coding', recommended: false,
+  }),
+  createCuratedModel({
     id: 'cline-pass/kimi-k2.6',
     name: 'Kimi K2.6',
     description: 'Balanced long-context conversational model.',
-    clineContextLength: 200000,
-    defaultContextLength: 200000,
-    originalContextLength: 2000000,
-    originalProvider: 'Moonshot AI',
-    contextLength: 200000,
-    maxTokens: 8192,
-    input: ['text'],
-    category: 'general',
-    recommended: false,
-    isCustom: false,
-  },
-  {
+    ctx: 200000, maxTokens: 8192, input: ['text'], category: 'general', recommended: false,
+  }),
+  createCuratedModel({
     id: 'cline-pass/qwen3.7-max',
     name: 'Qwen 3.7 Max',
     description: 'Large-scale multimodal foundation model from Alibaba Cloud with reasoning support.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 1000000,
-    originalProvider: 'Alibaba Cloud',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'multimodal',
-    recommended: true,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'multimodal', recommended: true,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/qwen3.7-plus',
     name: 'Qwen 3.7 Plus',
     description: 'Fast, capable multimodal model with strong multilingual skills and reasoning.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 1000000,
-    originalProvider: 'Alibaba Cloud',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'multimodal',
-    recommended: false,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'multimodal', recommended: false,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/minimax-m3',
     name: 'MiniMax M3',
     description: 'High throughput reasoning and synthesis model.',
-    clineContextLength: 200000,
-    defaultContextLength: 200000,
-    originalContextLength: 1000000,
-    originalProvider: 'MiniMax',
-    contextLength: 200000,
-    maxTokens: 8192,
-    input: ['text'],
-    category: 'reasoning',
-    recommended: false,
-    isCustom: false,
+    ctx: 200000, maxTokens: 8192, input: ['text'], category: 'reasoning', recommended: false,
     reasoningEfforts: ['low', 'medium', 'high'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/mimo-v2.5',
     name: 'MiMo V2.5',
     description: 'Xiaomi MiMo efficient instruction model with reasoning and multimodal support.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 1000000,
-    originalProvider: 'Xiaomi',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'general',
-    recommended: false,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'general', recommended: false,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
-  {
+  }),
+  createCuratedModel({
     id: 'cline-pass/mimo-v2.5-pro',
     name: 'MiMo V2.5 Pro',
     description: 'Xiaomi MiMo advanced agentic reasoning model with multimodal support.',
-    clineContextLength: 128000,
-    defaultContextLength: 128000,
-    originalContextLength: 1000000,
-    originalProvider: 'Xiaomi',
-    contextLength: 128000,
-    maxTokens: 8192,
-    input: ['text', 'image'],
-    category: 'coding',
-    recommended: false,
-    isCustom: false,
+    ctx: 128000, maxTokens: 8192, input: ['text', 'image'], category: 'coding', recommended: false,
     reasoningEfforts: ['low', 'medium', 'high', 'max'],
-  },
+  }),
 ])
 
 /**
@@ -303,6 +238,7 @@ export function parsePlanIncludedModels(includedInput) {
       const isVision = /(vision|vl|multimodal|omni|image)/i.test(name)
       const hasReasoning = /(reason|think|r1|pro|flash|max|plus|k3|m3|glm|qwen|mimo)/i.test(name)
       const origCtx = getOriginalModelContext(name)
+      const origMax = getOriginalModelMaxTokens(name)
       const origProv = getOriginalModelProvider(name)
       matched.push({
         id: `cline-pass/${idPart}`,
@@ -311,9 +247,11 @@ export function parsePlanIncludedModels(includedInput) {
         clineContextLength: 200000,
         defaultContextLength: 200000,
         originalContextLength: origCtx,
+        originalMaxTokens: origMax,
         originalProvider: origProv,
         contextLength: 200000,
         maxTokens: 8192,
+        defaultMaxTokens: 8192,
         input: isVision ? ['text', 'image'] : ['text'],
         category: hasReasoning ? 'reasoning' : (isVision ? 'multimodal' : 'general'),
         recommended: false,
@@ -351,26 +289,31 @@ export function getAllModels(dynamicModels = [], modelContextOverrides = [], cus
     }
   }
 
+  const wildcardOv = overridesMap.get('*')
   function applyOverride(m) {
     const defaultCtx = m.clineContextLength || m.defaultContextLength || m.contextLength || 200000
+    const defaultMax = m.defaultMaxTokens || m.maxTokens || 8192
     const origCtx = m.originalContextLength || getOriginalModelContext(m.id)
+    const origMax = m.originalMaxTokens || getOriginalModelMaxTokens(m.id)
     const origProv = m.originalProvider || getOriginalModelProvider(m.id)
-    const ov = overridesMap.get(m.id)
+    const ov = overridesMap.get(m.id) || wildcardOv
     const activeCtx = ov && typeof ov.contextLength === 'number' && ov.contextLength > 0
       ? ov.contextLength
       : defaultCtx
     const activeMaxTokens = ov && typeof ov.maxTokens === 'number' && ov.maxTokens > 0
       ? ov.maxTokens
-      : m.maxTokens || 8192
+      : defaultMax
     return {
       ...m,
       contextLength: activeCtx,
       maxTokens: activeMaxTokens,
       defaultContextLength: defaultCtx,
       clineContextLength: defaultCtx,
+      defaultMaxTokens: defaultMax,
       originalContextLength: origCtx,
+      originalMaxTokens: origMax,
       originalProvider: origProv,
-      isContextOverridden: activeCtx !== defaultCtx,
+      isContextOverridden: activeCtx !== defaultCtx || activeMaxTokens !== defaultMax,
     }
   }
 
@@ -392,7 +335,9 @@ export function getAllModels(dynamicModels = [], modelContextOverrides = [], cus
           clineContextLength: curated.clineContextLength || curated.contextLength,
           defaultContextLength: curated.defaultContextLength || curated.contextLength,
           originalContextLength: curated.originalContextLength || getOriginalModelContext(curated.id),
+          originalMaxTokens: curated.originalMaxTokens || getOriginalModelMaxTokens(curated.id),
           originalProvider: curated.originalProvider || getOriginalModelProvider(curated.id),
+          defaultMaxTokens: curated.defaultMaxTokens || curated.maxTokens || 8192,
           input: dm.input && dm.input.length ? dm.input : curated.input,
           category: dm.category || curated.category,
           reasoningEfforts: dm.reasoningEfforts !== undefined ? dm.reasoningEfforts : curated.reasoningEfforts,
@@ -404,7 +349,9 @@ export function getAllModels(dynamicModels = [], modelContextOverrides = [], cus
         clineContextLength: dm.contextLength || 200000,
         defaultContextLength: dm.contextLength || 200000,
         originalContextLength: dm.originalContextLength || getOriginalModelContext(dm.id),
+        originalMaxTokens: dm.originalMaxTokens || getOriginalModelMaxTokens(dm.id),
         originalProvider: dm.originalProvider || getOriginalModelProvider(dm.id),
+        defaultMaxTokens: dm.maxTokens || 8192,
         unverified: false,
       })
     })

package/lib/provider-sync.js

@@ -239,6 +239,22 @@ export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
     }
   }
 
+  let existingModels = []
+  try {
+    if (typeof settings.describe === 'function') {
+      const descriptors = settings.describe()
+      const piAiDesc = Array.isArray(descriptors) ? descriptors.find((d) => d?.ns === LLM_PI_AI_NS) : null
+      const existingProv = piAiDesc?.value?.providers?.[PROVIDER_ID]
+      if (Array.isArray(existingProv?.models)) existingModels = existingProv.models
+    } else if (typeof settings.get === 'function') {
+      const piAiVal = settings.get(LLM_PI_AI_NS)
+      const existingProv = piAiVal?.providers?.[PROVIDER_ID]
+      if (Array.isArray(existingProv?.models)) existingModels = existingProv.models
+    }
+  } catch {
+    /* ignore read error */
+  }
+
   const providerObj = buildPiAiProvider({
     baseUrl: effectiveBaseUrl,
     apiKeyEnv: isProxy ? LOCAL_PROXY_KEY_ENV : (activeAcc?.apiKeyEnv || pub.apiKeyEnv),
@@ -246,6 +262,7 @@ export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
     dynamicModels: pub.dynamicModels,
     modelContextOverrides: pub.modelContextOverrides,
     customModels: pub.customModels,
+    existingModels,
     displayName: PROVIDER_DISPLAY_NAME,
   })
 
@@ -257,6 +274,10 @@ export async function upsertPiAiProvider(ctx, cfg, activeModelIds) {
     },
   ])
 
+  ctx?.logger?.info?.(
+    `[dsh-clinebot] Synchronized llm-pi-ai provider "${PROVIDER_ID}" with ${providerObj.models.length} models.`
+  )
+
   return providerObj
 }
 

package/lib/proxy-token.js

@@ -14,9 +14,9 @@ export const LOCAL_PROXY_KEY_ENV = 'CLINEBOT_LOCAL_PROXY_TOKEN'
 let cachedToken = null
 
 const require = createRequire(import.meta.url)
-let packageVersion = '0.5.20'
+let packageVersion = '0.5.22'
 try {
-  packageVersion = require('../package.json').version || '0.5.20'
+  packageVersion = require('../package.json').version || '0.5.22'
 } catch (err) {
   /* fallback to default version if manifest is unreadable */
 }
@@ -118,3 +118,23 @@ export function sendProxyTerminalError(res, { hadTimeout, is429Exhausted, lastEr
     },
   })
 }
+
+
+/**
+ * Safely extract standard and reasoning token counts from usage object.
+ */
+export function extractUsageMetrics(usage) {
+  if (!usage || typeof usage !== 'object') {
+    return { promptTokens: 0, completionTokens: 0, reasoningTokens: 0, totalTokens: 0 }
+  }
+  const promptTokens = Number(usage.prompt_tokens) || 0
+  const completionTokens = Number(usage.completion_tokens) || 0
+  const reasoningTokens = Number(
+    usage.completion_tokens_details?.reasoning_tokens ||
+    usage.reasoning_tokens ||
+    usage.prompt_tokens_details?.reasoning_tokens ||
+    0
+  )
+  const totalTokens = Number(usage.total_tokens) || (promptTokens + completionTokens)
+  return { promptTokens, completionTokens, reasoningTokens, totalTokens }
+}

package/lib/routes/models.js

@@ -2,8 +2,8 @@ import { writeJson, readBody } from '../http.js'
 import { assertTrustedSettingsRequest } from '../access.js'
 import { publicConfig, plainConfig, Config } from '../config.js'
 import { resolveActiveAccountKey, resolvePathWithHome } from '../provider-sync.js'
-import { getAllModels, saveModelsDiskCache, getOriginalModelContext } from '../models.js'
-import { fetchUsageLimits } from '../cline-client.js'
+import { getAllModels, saveModelsDiskCache, getOriginalModelContext, getOriginalModelMaxTokens } from '../models.js'
+import { fetchUsageLimits, smokeChat } from '../cline-client.js'
 import { publicUsage } from '../http.js'
 
 export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderState }) {
@@ -129,15 +129,36 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
         let currentOverrides = Array.isArray(pub.modelContextOverrides) ? [...pub.modelContextOverrides] : []
 
         if (body.mode === 'all-original') {
-          // Set all models to their authentic original creator context limits
+          // Set all models to their authentic original creator context & token limits
           currentOverrides = allModels.map((m) => ({
             modelId: m.id,
             contextLength: m.originalContextLength || getOriginalModelContext(m.id),
-            maxTokens: m.maxTokens || 8192,
+            maxTokens: m.originalMaxTokens || getOriginalModelMaxTokens(m.id),
           }))
         } else if (body.mode === 'all-default' || body.mode === 'reset-all') {
           // Reset all overrides back to provider defaults
           currentOverrides = []
+        } else if (body.mode === 'apply-all') {
+          // Bulk apply limits across all models and set wildcard default
+          const rawCtx = Number(body.contextLength)
+          const contextLength = Number.isFinite(rawCtx) && rawCtx > 0 ? Math.max(1000, rawCtx) : undefined
+          const rawMax = Number(body.maxTokens)
+          const maxTokens = Number.isFinite(rawMax) && rawMax > 0 ? Math.max(256, rawMax) : undefined
+
+          currentOverrides = allModels.map((m) => {
+            const existing = currentOverrides.find((o) => o.modelId === m.id)
+            return {
+              modelId: m.id,
+              contextLength: contextLength !== undefined ? contextLength : (existing?.contextLength || m.contextLength),
+              maxTokens: maxTokens !== undefined ? maxTokens : (existing?.maxTokens || m.maxTokens),
+            }
+          })
+          currentOverrides = currentOverrides.filter((o) => o.modelId !== '*')
+          currentOverrides.push({
+            modelId: '*',
+            contextLength: contextLength || 200000,
+            maxTokens: maxTokens || 16384,
+          })
         } else if (Array.isArray(body.overrides)) {
           // Bulk array override
           currentOverrides = body.overrides
@@ -153,11 +174,19 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
             currentOverrides = currentOverrides.filter((o) => o.modelId !== modelId)
           } else {
             const rawCtx = Number(body.contextLength)
-            const contextLength = Number.isFinite(rawCtx) && rawCtx > 0 ? Math.max(1000, rawCtx) : 200000
             const rawMax = Number(body.maxTokens)
-            const maxTokens = Number.isFinite(rawMax) && rawMax > 0 ? Math.max(256, rawMax) : 8192
-
             const existingIdx = currentOverrides.findIndex((o) => o.modelId === modelId)
+            const existingEntry = existingIdx >= 0 ? currentOverrides[existingIdx] : null
+            const targetModel = allModels.find((m) => m.id === modelId)
+
+            const contextLength = Number.isFinite(rawCtx) && rawCtx > 0
+              ? Math.max(1000, rawCtx)
+              : (existingEntry?.contextLength || targetModel?.contextLength || 200000)
+
+            const maxTokens = Number.isFinite(rawMax) && rawMax > 0
+              ? Math.max(256, rawMax)
+              : (existingEntry?.maxTokens || targetModel?.maxTokens || 8192)
+
             const newEntry = { modelId, contextLength, maxTokens }
             if (existingIdx >= 0) {
               currentOverrides[existingIdx] = newEntry
@@ -211,4 +240,38 @@ export function registerModelsRoutes(ctx, { live, getSettingsApi, syncProviderSt
       }
     },
   }), 'dsh-clinebot: /usage')
+
+  // POST /dsh-clinebot/models/probe — benchmark TTFT latency for specific model
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/models/probe',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+      if (!assertTrustedSettingsRequest(req, res)) return
+      try {
+        const bodyBuf = await readBody(req)
+        let body = {}
+        try { body = JSON.parse(bodyBuf.toString('utf8')) } catch { body = {} }
+        const pub = publicConfig(live())
+        const activeKey = await resolveActiveAccountKey(ctx, live())
+        if (!activeKey.value) {
+          return writeJson(res, 400, { ok: false, error: 'API key not found' })
+        }
+        const modelId = body.modelId || body.model || pub.defaultModel
+        const result = await smokeChat(pub.baseUrl, activeKey.value, {
+          model: modelId,
+          timeoutMs: Math.min(pub.smokeTimeoutMs || 25000, 15000),
+        })
+        return writeJson(res, 200, {
+          ok: result.ok,
+          modelId,
+          latencyMs: result.latencyMs,
+          status: result.status,
+          error: result.error || null,
+        })
+      } catch (err) {
+        return writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /models/probe')
 }

package/lib/routes/proxy.js

@@ -27,6 +27,7 @@ import {
   isAuthorizedProxyRequest,
   USER_AGENT,
   sendProxyTerminalError,
+  extractUsageMetrics,
 } from '../proxy-token.js'
 
 export { hasDisallowedBrowserOrigin, isAuthorizedProxyRequest, USER_AGENT }
@@ -120,7 +121,7 @@ export function createChatCompletionsHandler(ctx, { live, getSettingsApi, syncPr
         return
       }
 
-      const routeResult = resolveSessionAccount(sessionId, pool, pub.activeAccount, pub.accountMode)
+      const routeResult = resolveSessionAccount(sessionId, pool, pub.activeAccount, pub.accountMode, body?.model, pub.modelRoutes)
       const targetAccount = routeResult.account
       lastTargetAccount = targetAccount
 
@@ -297,6 +298,7 @@ export function createChatCompletionsHandler(ctx, { live, getSettingsApi, syncPr
 
         let promptTokens = 0
         let completionTokens = 0
+        let reasoningTokens = 0
         let totalTokens = 0
         let buffer = ''
         let streamError = null
@@ -350,9 +352,11 @@ export function createChatCompletionsHandler(ctx, { live, getSettingsApi, syncPr
               try {
                 const parsed = JSON.parse(trimmed.slice(5).trim())
                 if (parsed.usage) {
-                  promptTokens = parsed.usage.prompt_tokens || promptTokens
-                  completionTokens = parsed.usage.completion_tokens || completionTokens
-                  totalTokens = parsed.usage.total_tokens || totalTokens
+                  const u = extractUsageMetrics(parsed.usage)
+                  promptTokens = u.promptTokens || promptTokens
+                  completionTokens = u.completionTokens || completionTokens
+                  reasoningTokens = u.reasoningTokens || reasoningTokens
+                  totalTokens = u.totalTokens || totalTokens
                 }
               } catch {}
             }
@@ -419,6 +423,7 @@ export function createChatCompletionsHandler(ctx, { live, getSettingsApi, syncPr
           accountId: targetAccount.id || targetAccount.label,
           promptTokens,
           completionTokens,
+          reasoningTokens,
           totalTokens: totalTokens || (promptTokens + completionTokens),
           isError: isStreamFailed,
           statsPath: pub.statsPath
@@ -495,12 +500,14 @@ export function createChatCompletionsHandler(ctx, { live, getSettingsApi, syncPr
       }
 
       cleanupClientListeners()
+      const nonStreamUsage = extractUsageMetrics(resJson?.usage)
       recordUsage({
         model: body.model,
         accountId: targetAccount.id || targetAccount.label,
-        promptTokens: resJson?.usage?.prompt_tokens || 0,
-        completionTokens: resJson?.usage?.completion_tokens || 0,
-        totalTokens: resJson?.usage?.total_tokens || 0,
+        promptTokens: nonStreamUsage.promptTokens,
+        completionTokens: nonStreamUsage.completionTokens,
+        reasoningTokens: nonStreamUsage.reasoningTokens,
+        totalTokens: nonStreamUsage.totalTokens,
         isError: false,
         statsPath: pub.statsPath
       })
@@ -582,4 +589,4 @@ export function registerProxyRoutes(ctx, routeEnv) {
     path: '/dsh-clinebot/v1/models',
     handler: modelsHandler,
   }), 'dsh-clinebot: /v1/models')
-}
+}

package/lib/routes/settings.js

@@ -3,7 +3,7 @@ import { assertTrustedSettingsRequest } from '../access.js'
 import { publicConfig, plainConfig, Config } from '../config.js'
 import { buildStatus } from '../provider-sync.js'
 import { saveCredentialKey, smokeChat, DEFAULT_API_KEY_ENV } from '../cline-client.js'
-import { getStatsSummary, resetStats } from '../stats-storage.js'
+import { getStatsSummary, resetStats, exportStatsAsCsv } from '../stats-storage.js'
 
 export function registerSettingsRoutes(ctx, { live, getSettingsApi, syncProviderState, triggerAutoDiscover }) {
   // 1. GET /dsh-clinebot/status
@@ -212,4 +212,23 @@ export function registerSettingsRoutes(ctx, { live, getSettingsApi, syncProvider
       }
     },
   }), 'dsh-clinebot: /stats/reset')
+
+  // 6. GET /dsh-clinebot/stats/export — export token telemetry as CSV
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-clinebot/stats/export',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') return writeJson(res, 405, { ok: false, error: 'GET only' })
+      if (!assertTrustedSettingsRequest(req, res)) return
+      try {
+        const csv = exportStatsAsCsv()
+        res.statusCode = 200
+        res.setHeader('Content-Type', 'text/csv; charset=utf-8')
+        res.setHeader('Content-Disposition', 'attachment; filename="clinebot-stats.csv"')
+        res.end(csv)
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: String(err?.message || err) })
+      }
+    },
+  }), 'dsh-clinebot: /stats/export')
 }