@goodandready/dsh-subscriptions 0.6.64 → 0.6.65

package/README.md

@@ -207,6 +207,12 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **In-App Toast Alerts (`enableToasts`)**: Lightweight floating toast alerts in the DSH chat interface notifying you when accounts enter quarantine, recover from cooldowns, or exceed quota safety thresholds.
 * **Automated Webhook Integration**: Instant event notifications dispatched via `notifyQuarantineEntered` and `notifyQuarantineReleased`.
 
+### 19. 🧠 Session Reasoning Effort Management & Contract Matrix (v0.6.65)
+* **Session-Scoped Reasoning Effort Control (#505)**: Dynamically adjust reasoning effort (`low`, `medium`, `high`, `max`) or disable reasoning (`off`) per conversation session via REST endpoints (`GET`, `POST`, `DELETE /dsh-subscriptions/session-reasoning`).
+* **Model-Switch Invariant & Safety Guard**: Automatic suppression of reasoning parameters when switching from a reasoning model (e.g. `o1`) to a standard model (e.g. `gpt-4o`), avoiding upstream HTTP 400 parameter errors.
+* **Extended Multi-Vendor Capability**: Native reasoning support across Codex (`o1`, `o3`), Claude (`claude-3-7-sonnet*`, `claude-4.6+` thinking tokens & budgets), Antigravity/Gemini (`thinkingConfig`), Grok (`grok-3-mini`), and Kimi (`k1.5`).
+* **Comprehensive Adapter Contract Matrix (#521)**: Automated offline wire contract verification (`test/contract-matrix.test.mjs`) testing 8 providers across 7 wire protocol capabilities (`stream`, `tools`, `reasoning`, `usage`, `caching`, `auth_errors`, `rate_limit`).
+
 ### 18. 🔑 Antigravity Client Secret & Resilient CLI Refresh (v0.6.60)
 * **Client Secret in Schema (`antigravityClientSecret`)**: Configure custom Google Cloud OAuth client secrets with automatic mask redaction (`••••••`), resolving token refresh rejections for confidential OAuth clients.
 * **Zero-Config CLI Token Refresh**: Bundled public application credentials for the standard Gemini / Antigravity CLI client (`Google Gemini CLI Client ID` / `Google Gemini CLI Client Secret`), ensuring imported CLI sessions keep refreshing indefinitely without dying after 1 hour.

package/README.ru.md

@@ -183,6 +183,12 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **Всплывающие уведомления (Toast Alerts)**: Легковесные всплывающие тосты в веб-интерфейсе DSH при событиях карантина (с отображением причины), восстановлении доступа и критическом расходе квоты. Включение управляется параметром `enableToasts` (по умолчанию `true`).
 * **Интеграция с вебхуками**: Автоматическая отправка уведомлений через `notifyQuarantineEntered` и `notifyQuarantineReleased`.
 
+### 15. 🧠 Управление Reasoning Effort в сессии и матрица контрактов (v0.6.65)
+* **Управление глубиной рассуждений в сессии (#505)**: Динамическая настройка усилия рассуждений (`low`, `medium`, `high`, `max`) или отключение (`off`) в рамках диалога через REST API (`GET`, `POST`, `DELETE /dsh-subscriptions/session-reasoning`).
+* **Безопасность при смене модели**: Автоматическое подавление параметров рассуждений при переключении с reasoning-модели (напр. `o1`) на обычную (напр. `gpt-4o`), предотвращающее ошибки HTTP 400 от upstream API.
+* **Поддержка ведущих вендоров**: Codex (`o1`, `o3`), Claude (`claude-3-7-sonnet*`, `claude-4.6+` thinking budget), Antigravity/Gemini (`thinkingConfig`), Grok (`grok-3-mini`) и Kimi (`k1.5`).
+* **Матрица контрактных проверок адаптеров (#521)**: Тестовый набор (`test/contract-matrix.test.mjs`) для 8 провайдеров по 7 ключевым возможностям протокола (`stream`, `tools`, `reasoning`, `usage`, `caching`, `auth_errors`, `rate_limit`).
+
 ### 14. 🔑 Antigravity Client Secret и надежный refresh CLI-токенов (v0.6.60)
 * **Client Secret в схеме настроек (`antigravityClientSecret`)**: Поддержка ввода пользовательского Google Cloud OAuth Client Secret с автоматическим маскированием (`••••••`), устраняющая ошибки обновления токенов для конфиденциальных OAuth-клиентов.
 * **Бесшовный refresh сессий из CLI**: Встроенные официальные публичные учетные данные Gemini / Antigravity CLI (`Google Gemini CLI Client ID` / `Google Gemini CLI Client Secret`), предотвращающие отказ Google OAuth через 1 час после импорта через `From CLI`.

package/lib/adapter.js

@@ -1,3 +1,4 @@
+import { resolveEffectiveReasoning, getModelReasoningCapabilities } from './reasoning-effort.js'
 import { inferModelCapabilities, isDeprecatedId } from './models-catalog.js'
 import { fetchWithTimeout } from "./http.js"
 import { LlmAdapter, LlmError, attributionHeaders } from '@deepseek-ai/dsh-llm'
@@ -95,6 +96,11 @@ export class SubscriptionAdapter extends LlmAdapter {
   async resolveModel(provider, model) {
     const rows = await this.listModels(provider)
     const found = rows.find((row) => row && row.id === model)
+    const caps = getModelReasoningCapabilities(provider, model, rows)
+    const reasoningMeta = found && found.reasoning ? found.reasoning : (caps.supported ? {
+      efforts: caps.levels.map((lvl) => ({ id: lvl, name: lvl.charAt(0).toUpperCase() + lvl.slice(1) })),
+      ...(caps.defaultEffort ? { defaultEffort: caps.defaultEffort } : {}),
+    } : undefined)
     if (found) {
       return {
         provider,
@@ -103,10 +109,10 @@ export class SubscriptionAdapter extends LlmAdapter {
         ...(found.description ? { description: found.description } : {}),
         ...(found.inputModalities ? { inputModalities: found.inputModalities } : {}),
         ...(found.contextWindow ? { context: { contextWindow: found.contextWindow } } : {}),
-        ...(found.reasoning ? { reasoning: found.reasoning } : {}),
+        ...(reasoningMeta ? { reasoning: reasoningMeta } : {}),
       }
     }
-    return { provider, id: model, name: model }
+    return { provider, id: model, name: model, ...(reasoningMeta ? { reasoning: reasoningMeta } : {}) }
   }
 
   async prepareCall(provider, model, signal) {
@@ -136,9 +142,13 @@ export class SubscriptionAdapter extends LlmAdapter {
       const effectiveDrainSafetyPercent = options.drainSafetyPercent !== undefined
         ? options.drainSafetyPercent
         : (typeof deps.drainSafetyPercent === 'function' ? deps.drainSafetyPercent() : (deps.drainSafetyPercent ?? 5))
+      const sessionId = options.sessionId || options.session_id || options.conversationId
+      const effectiveReasoning = resolveEffectiveReasoning(sessionId, options)
       const decisionTrace = {}
       const streamOptions = {
         ...options,
+        ...(effectiveReasoning.effort ? { reasoningEffort: effectiveReasoning.effort } : {}),
+        ...(effectiveReasoning.budgetTokens ? { thinkingBudget: effectiveReasoning.budgetTokens } : {}),
         _decisionTrace: decisionTrace,
         autoPacing: effectiveAutoPacing,
         drainBeforeReset: effectiveDrainBeforeReset,

package/lib/client.js

@@ -609,7 +609,14 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "wizardRecommendations": "Recommendations & Next Steps",
       "wizardCopy": "Copy Masked Diagnostic Report",
       "cachePinnedBadge": "Cache Pinned",
-      "field.enableToasts": "Show popup toast notifications on quarantine or quota events"
+      "field.enableToasts": "Show popup toast notifications on quarantine or quota events",
+      "reasoningEffortTitle": "Reasoning Effort Control",
+      "reasoningEffortDesc": "Configure reasoning depth for models with extended thinking capabilities.",
+      "reasoningLevelLow": "Low",
+      "reasoningLevelMed": "Medium",
+      "reasoningLevelHigh": "High",
+      "reasoningLevelMax": "Max",
+      "reasoningLevelOff": "Off"
 };
 
     const zh = {
@@ -867,7 +874,14 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "wizardRecommendations": "排查建议与修复步骤",
       "wizardCopy": "复制脱敏诊断报告",
       "cachePinnedBadge": "缓存粘性",
-      "field.enableToasts": "当账户发生隔离或额度达到警戒线时显示即时弹窗提醒"
+      "field.enableToasts": "当账户发生隔离或额度达到警戒线时显示即时弹窗提醒",
+      "reasoningEffortTitle": "推理强度控制",
+      "reasoningEffortDesc": "为具备扩展思考能力的模型配置推理深度与思考预算。",
+      "reasoningLevelLow": "低",
+      "reasoningLevelMed": "中",
+      "reasoningLevelHigh": "高",
+      "reasoningLevelMax": "最高",
+      "reasoningLevelOff": "关闭"
 };
     // #51: live countdown to the quota window reset (account.quota.resetAt).
                 function cleanErrorMessage(raw) {
@@ -1971,6 +1985,20 @@ const cssId = 'dsh-subscriptions/settings.module.css'
               })
             ),
           ),
+          React.createElement('details', { className: 'dsub-group' },
+            React.createElement('summary', { className: 'dsub-groupHead' }, '🧠 ' + t('reasoningEffortTitle')),
+            React.createElement('div', { className: 'dsub-sub', style: { marginTop: '4px' } }, t('reasoningEffortDesc')),
+            React.createElement('div', { style: { display: 'flex', flexWrap: 'wrap', gap: '8px', marginTop: '10px' } },
+              ['off', 'low', 'medium', 'high', 'max'].map((lvl) => {
+                const label = lvl === 'off' ? t('reasoningLevelOff') : (lvl.charAt(0).toUpperCase() + lvl.slice(1))
+                return React.createElement('span', {
+                  key: lvl,
+                  className: 'dsub-model-tag',
+                  style: { padding: '4px 10px', fontSize: '12px', cursor: 'default' }
+                }, '⚙️ ' + label)
+              })
+            )
+          ),
           React.createElement('details', { className: 'dsub-details' },
             React.createElement('summary', { className: 'dsub-summary' }, t('advancedSettings')),
             React.createElement('div', { className: 'dsub-block' },

package/lib/diagnostics.js

@@ -1,3 +1,4 @@
+import { getSessionReasoningStats } from './reasoning-effort.js'
 import { defaultConcurrencyQueue } from './concurrency-queue.js'
 import { calculateCacheMetrics } from './analytics.js'
 import { getSessionPinStats } from './session-pin.js'
@@ -52,6 +53,7 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
     cache: calculateCacheMetrics(rows),
     queue: defaultConcurrencyQueue.stats(),
     pins: getSessionPinStats(),
+    reasoning: getSessionReasoningStats(),
     decisions: {
       recent: rows.filter((r) => r && r.decisionTrace).slice(0, 10).map((r) => ({
         ts: r.ts,

package/lib/messages.js

@@ -289,8 +289,14 @@ export function codexResponsesBody(options, fallbackInstructions, vendorCfg) {
     instructions,
     input,
     ...(responsesTools && responsesTools.length ? { tools: responsesTools } : {}),
-    // #93: reasoning effort chosen in the native picker flows to the protocol.
-    ...(options.reasoningEffort ? { reasoning: { effort: String(options.reasoningEffort) } } : {}),
+    // #93, #505: reasoning effort chosen flows to the protocol only when supported and not 'off'
+    ...((() => {
+      const eff = options && String(options.reasoningEffort || '').toLowerCase().trim()
+      if (eff && eff !== 'off' && /^(low|medium|high)$/.test(eff)) {
+        return { reasoning: { effort: eff } }
+      }
+      return {}
+    })()),
     // #93: verbosity comes from the codexVerbosity setting (low/medium/high).
     ...(vendorCfg && /^(low|medium|high)$/.test(String(vendorCfg.verbosity || ''))
       ? { text: { verbosity: String(vendorCfg.verbosity) } } : {}),
@@ -501,6 +507,18 @@ export function googleContents(options) {
     generationConfig: {
       ...(options.temperature != null ? { temperature: options.temperature } : {}),
       ...(options.maxTokens != null ? { maxOutputTokens: options.maxTokens } : {}),
+      ...((() => {
+        const budget = options && (options.thinkingBudget || options.budgetTokens || (options.thinking && options.thinking.budget_tokens))
+        if (budget != null && Number(budget) >= 0) {
+          return { thinkingConfig: { thinkingBudget: Number(budget) } }
+        }
+        const eff = options && String(options.reasoningEffort || '').toLowerCase().trim()
+        if (eff === 'off') return { thinkingConfig: { thinkingBudget: 0 } }
+        if (eff === 'low') return { thinkingConfig: { thinkingBudget: 1024 } }
+        if (eff === 'medium') return { thinkingConfig: { thinkingBudget: 8192 } }
+        if (eff === 'high') return { thinkingConfig: { thinkingBudget: 24576 } }
+        return {}
+      })()),
     },
   }
 }

package/lib/reasoning-effort.js

@@ -0,0 +1,323 @@
+// Reasoning effort management and model capability mapping (#505).
+// Enforces 0 Cyrillic characters.
+
+/**
+ * Known default effort levels per vendor.
+ * @type {Record<string, string[]>}
+ */
+export const DEFAULT_VENDOR_EFFORTS = {
+  codex: ['low', 'medium', 'high'],
+  claude: ['low', 'medium', 'high'],
+  antigravity: ['low', 'medium', 'high'],
+  grok: ['low', 'medium', 'high'],
+  kimi: ['low', 'medium', 'high', 'max'],
+  cursor: ['low', 'medium', 'high', 'max'],
+}
+
+/**
+ * Inspect model and catalog to determine supported reasoning levels.
+ * @param {string} provider
+ * @param {string} modelId
+ * @param {Array<any>} [catalog]
+ * @returns {{ supported: boolean, levels: string[], defaultEffort?: string }}
+ */
+export function getModelReasoningCapabilities(provider, modelId, catalog = []) {
+  const p = String(provider || '').toLowerCase().trim()
+  const id = String(modelId || '').toLowerCase().trim()
+
+  // 1. Check catalog entry if provided
+  if (Array.isArray(catalog) && catalog.length) {
+    const entry = catalog.find((m) => m && (m.id === id || m.slug === id || m.name === id))
+    if (entry && entry.reasoning && Array.isArray(entry.reasoning.efforts) && entry.reasoning.efforts.length) {
+      const levels = entry.reasoning.efforts.map((row) => (typeof row === 'string' ? row : row.id)).filter(Boolean)
+      if (levels.length) {
+        return {
+          supported: true,
+          levels,
+          defaultEffort: entry.reasoning.defaultEffort || 'medium',
+        }
+      }
+    }
+  }
+
+  // 2. Vendor-specific heuristics
+  if (p === 'claude') {
+    // Claude 3.7+ Sonnet (both hybrid thinking and adaptive)
+    if (/claude-(?:3[.-]7|37)-sonnet/.test(id)) {
+      return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'medium' }
+    }
+    // Claude 4.6+ Sonnet / Opus
+    const m = /^claude-(opus|sonnet|haiku|fable)(?:-(\d+))?(?:-(\d+))?/.exec(id)
+    if (m) {
+      const [, family, maj, min] = m
+      const major = maj ? Number(maj) : null
+      const minor = min ? Number(min) : null
+      const atLeast = (wantMaj, wantMin) => (
+        major === null || major > wantMaj || (major === wantMaj && (minor === null || minor >= wantMin))
+      )
+      if ((family === 'sonnet' || family === 'opus') && atLeast(4, 6)) {
+        const levels = ['low', 'medium', 'high']
+        if (family === 'opus') {
+          if (atLeast(4, 7)) levels.push('xhigh')
+          levels.push('max')
+        }
+        return { supported: true, levels, defaultEffort: 'medium' }
+      }
+    }
+    return { supported: false, levels: [] }
+  }
+
+  if (p === 'codex') {
+    // OpenAI reasoning models: o1, o3, gpt-5.1-codex, or models containing 'reasoning'
+    if (
+      id.startsWith('o1') ||
+      id.startsWith('o3') ||
+      id.includes('reasoning') ||
+      id.includes('codex')
+    ) {
+      return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'medium' }
+    }
+    return { supported: false, levels: [] }
+  }
+
+  if (p === 'antigravity') {
+    if (
+      id.includes('thinking') ||
+      id.includes('gemini-3.1-pro') ||
+      id.includes('gemini-3.6-flash') ||
+      id.includes('gemini-3.7-flash') ||
+      id.includes('gemini-3.8-flash')
+    ) {
+      return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'medium' }
+    }
+    return { supported: false, levels: [] }
+  }
+
+  if (p === 'grok') {
+    if (id.includes('reasoning') || id === 'grok-3-mini') {
+      return { supported: true, levels: ['low', 'medium', 'high'], defaultEffort: 'medium' }
+    }
+    return { supported: false, levels: [] }
+  }
+
+  if (p === 'kimi') {
+    if (id.includes('k1.5') || id.includes('reasoning')) {
+      return { supported: true, levels: ['low', 'medium', 'high', 'max'], defaultEffort: 'medium' }
+    }
+    return { supported: false, levels: [] }
+  }
+
+  return { supported: false, levels: [] }
+}
+
+/**
+ * Extract raw effort and budget from incoming request options.
+ * @param {any} options
+ * @returns {{ effort?: string, budgetTokens?: number }}
+ */
+export function extractReasoningOptions(options) {
+  if (!options || typeof options !== 'object') return {}
+  let effort = options.reasoningEffort
+  if (!effort && options.reasoning && typeof options.reasoning.effort === 'string') {
+    effort = options.reasoning.effort
+  }
+  if (!effort && options.thinking && typeof options.thinking.effort === 'string') {
+    effort = options.thinking.effort
+  }
+  if (!effort && typeof options.effort === 'string') {
+    effort = options.effort
+  }
+
+  let budgetTokens = options.thinkingBudget ?? options.budgetTokens
+  if (budgetTokens == null && options.thinking && options.thinking.budget_tokens != null) {
+    budgetTokens = options.thinking.budget_tokens
+  }
+
+  const normalizedEffort = typeof effort === 'string' ? effort.toLowerCase().trim() : undefined
+  const normalizedBudget = typeof budgetTokens === 'number' && !Number.isNaN(budgetTokens) ? budgetTokens : undefined
+
+  return {
+    ...(normalizedEffort ? { effort: normalizedEffort } : {}),
+    ...(normalizedBudget != null ? { budgetTokens: normalizedBudget } : {}),
+  }
+}
+
+/**
+ * Validate effort level against model capabilities.
+ * @param {string} provider
+ * @param {string} modelId
+ * @param {string|undefined} effort
+ * @param {Array<any>} [catalog]
+ * @returns {{ valid: boolean, effort?: string, reason?: string }}
+ */
+export function validateReasoningEffort(provider, modelId, effort, catalog = []) {
+  if (!effort) return { valid: true, effort: undefined }
+  const eff = String(effort).toLowerCase().trim()
+  if (eff === 'off' || eff === 'none') {
+    return { valid: true, effort: 'off' }
+  }
+
+  const caps = getModelReasoningCapabilities(provider, modelId, catalog)
+  if (!caps.supported) {
+    return { valid: false, reason: 'model_not_reasoning' }
+  }
+
+  if (!caps.levels.includes(eff)) {
+    return { valid: false, reason: 'unsupported_effort_level' }
+  }
+
+  return { valid: true, effort: eff }
+}
+
+const DEFAULT_TTL_MS = 60 * 60 * 1000 // 1 hour
+const MAX_STORED_SESSIONS = 500
+
+/**
+ * @typedef {Object} SessionReasoningRecord
+ * @property {string} provider
+ * @property {string} model
+ * @property {string} effort
+ * @property {number} [budgetTokens]
+ * @property {number} updatedAt
+ * @property {number} expiresAt
+ */
+
+/** @type {Map<string, SessionReasoningRecord>} */
+const sessionReasoningStore = new Map()
+
+/**
+ * Store session-scoped reasoning configuration.
+ * @param {string} sessionId
+ * @param {object} params
+ * @param {string} params.provider
+ * @param {string} params.model
+ * @param {string} params.effort
+ * @param {number} [params.budgetTokens]
+ * @param {number} [params.ttlMs]
+ * @param {Array<any>} [catalog]
+ * @returns {{ ok: boolean, error?: string }}
+ */
+export function setSessionReasoning(sessionId, { provider, model, effort, budgetTokens, ttlMs = DEFAULT_TTL_MS }, catalog = []) {
+  if (!sessionId || typeof sessionId !== 'string') {
+    return { ok: false, error: 'invalid_session_id' }
+  }
+
+  const validation = validateReasoningEffort(provider, model, effort, catalog)
+  if (!validation.valid) {
+    return { ok: false, error: validation.reason }
+  }
+
+  if (sessionReasoningStore.size >= MAX_STORED_SESSIONS) {
+    pruneSessionReasoning()
+  }
+
+  const now = Date.now()
+  sessionReasoningStore.set(sessionId, {
+    provider: String(provider || ''),
+    model: String(model || ''),
+    effort: validation.effort || 'off',
+    budgetTokens: typeof budgetTokens === 'number' ? budgetTokens : undefined,
+    updatedAt: now,
+    expiresAt: now + ttlMs,
+  })
+
+  return { ok: true }
+}
+
+/**
+ * Retrieve session-scoped reasoning configuration.
+ * @param {string} sessionId
+ * @param {number} [now]
+ * @returns {SessionReasoningRecord|null}
+ */
+export function getSessionReasoning(sessionId, now = Date.now()) {
+  if (!sessionId) return null
+  const record = sessionReasoningStore.get(sessionId)
+  if (!record) return null
+  if (record.expiresAt <= now) {
+    sessionReasoningStore.delete(sessionId)
+    return null
+  }
+  // Sliding TTL extension
+  record.expiresAt = now + DEFAULT_TTL_MS
+  return record
+}
+
+/**
+ * Clear session-scoped reasoning configuration.
+ * @param {string} sessionId
+ * @returns {boolean}
+ */
+export function clearSessionReasoning(sessionId) {
+  if (!sessionId) return false
+  return sessionReasoningStore.delete(sessionId)
+}
+
+/**
+ * Prune expired session reasoning entries.
+ * @param {number} [now]
+ * @returns {number} count of pruned sessions
+ */
+export function pruneSessionReasoning(now = Date.now()) {
+  let pruned = 0
+  for (const [id, record] of sessionReasoningStore.entries()) {
+    if (record.expiresAt <= now) {
+      sessionReasoningStore.delete(id)
+      pruned++
+    }
+  }
+  return pruned
+}
+
+/**
+ * Get internal store statistics.
+ * @returns {{ activeSessions: number }}
+ */
+export function getSessionReasoningStats() {
+  return { activeSessions: sessionReasoningStore.size }
+}
+
+/**
+ * Resolve effective reasoning effort for a request turn.
+ * Automatically guards against model switching: if the session has a stored
+ * reasoning effort but the target model is non-reasoning, the parameter is suppressed.
+ * @param {string|undefined} sessionId
+ * @param {any} options
+ * @param {Array<any>} [catalog]
+ * @returns {{ effort?: string, budgetTokens?: number }}
+ */
+export function resolveEffectiveReasoning(sessionId, options, catalog = []) {
+  const extracted = extractReasoningOptions(options)
+  const provider = options && options.provider
+  const targetModel = options && options.model
+
+  // 1. Explicit request-level option takes precedence
+  if (extracted.effort || extracted.budgetTokens) {
+    const val = validateReasoningEffort(provider, targetModel, extracted.effort, catalog)
+    if (val.valid) {
+      return {
+        effort: val.effort === 'off' ? 'off' : val.effort,
+        budgetTokens: extracted.budgetTokens,
+      }
+    }
+    // If invalid (e.g. non-reasoning model), suppress so request does not fail
+    return { effort: undefined, budgetTokens: undefined }
+  }
+
+  // 2. Fall back to session-scoped configuration
+  if (sessionId) {
+    const record = getSessionReasoning(sessionId)
+    if (record && record.effort) {
+      // Validate that the target model currently being invoked supports reasoning
+      const val = validateReasoningEffort(provider, targetModel, record.effort, catalog)
+      if (val.valid && val.effort !== 'off') {
+        return {
+          effort: val.effort,
+          budgetTokens: record.budgetTokens,
+        }
+      }
+    }
+  }
+
+  return { effort: undefined, budgetTokens: undefined }
+}

package/lib/routes/status.js

@@ -1,3 +1,11 @@
+import {
+  getModelReasoningCapabilities,
+  setSessionReasoning,
+  getSessionReasoning,
+  clearSessionReasoning,
+  DEFAULT_VENDOR_EFFORTS,
+  validateReasoningEffort,
+} from '../reasoning-effort.js'
 import { defaultConcurrencyQueue } from '../concurrency-queue.js'
 import { calculateAnalytics } from '../analytics.js'
 import { runDiagnosticWizard } from '../diagnostic-wizard.js'
@@ -614,4 +622,72 @@ export function registerStatusRoutes(ctx, state) {
       writeJson(res, 200, { ok: true, report })
     }),
   }), 'dsh-subscriptions: /diagnostic-wizard')
+
+  // #505: Session-scoped reasoning effort management
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/session-reasoning',
+    handler: safeJsonHandler(async (req, res) => {
+      if (!isTrustedSettingsRequest(req, ctx)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+
+      const q = queryOf(req)
+      if (req.method === 'GET') {
+        const sessionId = q.get('sessionId') || ''
+        const provider = q.get('provider') || ''
+        const model = q.get('model') || ''
+        const current = sessionId ? getSessionReasoning(sessionId) : null
+        const caps = model ? getModelReasoningCapabilities(provider, model) : { supported: false, levels: [] }
+        writeJson(res, 200, {
+          ok: true,
+          sessionId: sessionId || null,
+          effort: (current && current.effort) || (caps.supported ? caps.defaultEffort : null),
+          budgetTokens: (current && current.budgetTokens) || null,
+          capabilities: caps,
+          defaults: DEFAULT_VENDOR_EFFORTS,
+  validateReasoningEffort,
+        })
+        return
+      }
+
+      if (req.method === 'POST') {
+        let body = {}
+        try { body = JSON.parse((await readBody(req, 64 * 1024)).toString('utf8') || '{}') } catch { /* ignore */ }
+        const { sessionId, provider, model, effort, budgetTokens } = body
+        if (!sessionId) {
+          writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'sessionId is required' } })
+          return
+        }
+        const val = validateReasoningEffort(provider, model, effort)
+        if (!val.valid) {
+          writeJson(res, 400, { ok: false, error: { code: val.reason || 'invalid_effort', message: 'invalid reasoning effort for model' } })
+          return
+        }
+        const result = setSessionReasoning(sessionId, { provider, model, effort, budgetTokens })
+        if (!result.ok) {
+          writeJson(res, 400, { ok: false, error: { code: result.error || 'validation_failed', message: 'invalid reasoning effort for model' } })
+          return
+        }
+        writeJson(res, 200, { ok: true, sessionId, effort: effort || 'off', model: model || null })
+        return
+      }
+
+      if (req.method === 'DELETE') {
+        let body = {}
+        try { body = JSON.parse((await readBody(req, 64 * 1024)).toString('utf8') || '{}') } catch { /* ignore */ }
+        const sessionId = q.get('sessionId') || body.sessionId
+        if (!sessionId) {
+          writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'sessionId is required' } })
+          return
+        }
+        const cleared = clearSessionReasoning(sessionId)
+        writeJson(res, 200, { ok: true, sessionId, cleared })
+        return
+      }
+
+      writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET, POST, DELETE only' } })
+    }),
+  }), 'dsh-subscriptions: /session-reasoning')
 }

package/lib/vendors/claude.js

@@ -33,15 +33,29 @@ export function providerInfo() {
 const BASE_EFFORT_LEVELS = ['low', 'medium', 'high']
 
 export function effortLevelsForModel(modelId) {
-  const m = /^claude-(opus|sonnet|haiku|fable)(?:-(\d+))?(?:-(\d+))?/.exec(String(modelId || ''))
-  if (!m) return null
-  const [, family, majorRaw, minorRaw] = m
-  if (family === 'haiku' || family === 'fable') return null
-  const major = majorRaw ? Number(majorRaw) : null
-  const minor = minorRaw ? Number(minorRaw) : null
+  const s = String(modelId || '').toLowerCase()
+  let m = /^claude-(opus|sonnet|haiku|fable)(?:-(\d+))?(?:-(\d+))?/.exec(s)
+  let family, major, minor
+  if (m) {
+    family = m[1]
+    major = m[2] ? Number(m[2]) : null
+    minor = m[3] ? Number(m[3]) : null
+  } else {
+    m = /^claude-(\d+)[-.](\d+)-(opus|sonnet|haiku|fable)/.exec(s)
+    if (m) {
+      major = Number(m[1])
+      minor = Number(m[2])
+      family = m[3]
+    }
+  }
+  if (!family || family === 'haiku' || family === 'fable') return null
   const atLeast = (wantMajor, wantMinor) => (
     major === null || major > wantMajor || (major === wantMajor && (minor === null || minor >= wantMinor))
   )
+  // Claude 3.7+ Sonnet supports extended thinking
+  if (family === 'sonnet' && major === 3 && minor !== null && minor >= 7) {
+    return [...BASE_EFFORT_LEVELS]
+  }
   // Adaptive thinking / effort exist from Opus 4.6 and Sonnet 4.6 onward.
   if (!atLeast(4, 6)) return null
   const levels = [...BASE_EFFORT_LEVELS]
@@ -174,6 +188,11 @@ export async function listModels(blob, cfg, fetchImpl) {
 // selection) leaves the request untouched so behavior stays opt-in.
 function applyClaudeThinking(payload, options) {
   const effort = options && String(options.reasoningEffort || '')
+  const budget = options && (options.thinkingBudget || options.budgetTokens || (options.thinking && options.thinking.budget_tokens))
+  if (budget && Number(budget) > 0) {
+    payload.thinking = { type: 'enabled', budget_tokens: Math.max(1024, Number(budget)) }
+    return payload
+  }
   if (!effort || effort === 'off') return payload
   const levels = effortLevelsForModel(payload && payload.model)
   if (!levels || !levels.includes(effort)) return payload

package/lib/wire.js

@@ -275,6 +275,8 @@ export async function* anthropicStream(body) {
           id: toolId,
           argumentsDelta: delta.partial_json,
         }
+      } else if (delta.type === 'thinking_delta' && delta.thinking) {
+        yield { type: 'reasoning-delta', index: json.index ?? 0, text: delta.thinking }
       }
     } else if (json.type === 'message_delta') {
       sawTerminal = true
@@ -354,7 +356,9 @@ export async function* googleStream(body) {
     }
     const parts = cand && cand.content && Array.isArray(cand.content.parts) ? cand.content.parts : []
     for (const part of parts) {
-      if (part.text) {
+      if (part.thought && part.text) {
+        yield { type: 'reasoning-delta', index, text: part.text }
+      } else if (part.text) {
         if (!started) {
           yield { type: 'block-start', index, blockType: 'text' }
           started = true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.64",
+  "version": "0.6.65",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",