@goodandready/dsh-subscriptions 0.6.64 → 0.6.66

package/README.md

@@ -207,6 +207,18 @@ 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`.
 
+### 20. 🤖 Native Copilot CLI SDK Mode & Local Tool Calling (v0.6.66)
+* **Direct Copilot CLI Integration (#508)**: Native driver `copilot-cli.js` supporting execution via local `copilot` / `github-copilot-cli` binaries with zero network token emulation risk.
+* **Smart Mode Switching (`copilotMode`)**: Choose between `auto` (prefers local CLI with graceful web API fallback), `cli` (strict CLI SDK execution), and `web` (direct OAuth/API).
+* **Multi-Source Credential Detection**: Automatically discovers tokens from GitHub CLI (`gh hosts.yml`), Copilot config files (`hosts.json`, `apps.json`), and environment variables (`GITHUB_COPILOT_TOKEN`, `GH_TOKEN`).
+* **Full Tool-Calling & Streaming**: Seamless translation of CLI process output into real-time streaming chunks and multi-turn tool-call deltas.
+
+### 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,18 @@ const res = await ctx.subscriptions.request('codex', '/backend-api/codex/images/
 * **Всплывающие уведомления (Toast Alerts)**: Легковесные всплывающие тосты в веб-интерфейсе DSH при событиях карантина (с отображением причины), восстановлении доступа и критическом расходе квоты. Включение управляется параметром `enableToasts` (по умолчанию `true`).
 * **Интеграция с вебхуками**: Автоматическая отправка уведомлений через `notifyQuarantineEntered` и `notifyQuarantineReleased`.
 
+### 16. 🤖 Нативный режим Copilot CLI SDK и локальный Tool Calling (v0.6.66)
+* **Прямая интеграция с Copilot CLI (#508)**: Драйвер `copilot-cli.js` для работы через локальный бинарник `copilot` / `github-copilot-cli` без риска сетевых блокировок при эмуляции токенов.
+* **Гибкие режимы работы (`copilotMode`)**: Поддержка режимов `auto` (приоритет CLI с автоматическим fallback на web-API), `cli` (строгий режим CLI SDK) и `web` (прямое подключение по OAuth/API).
+* **Многоканальное обнаружение учетных данных**: Чтение токенов из `gh hosts.yml`, `hosts.json`, `apps.json` и переменных окружения (`GITHUB_COPILOT_TOKEN`, `GH_TOKEN`).
+* **Потоковая передача и вызовы инструментов**: Полная поддержка real-time стриминга и событий `tool-call-delta` при исполнении через CLI.
+
+### 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

@@ -395,6 +395,13 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "codexVerbosityLow": "Low",
       "codexVerbosityMedium": "Medium",
       "codexVerbosityHigh": "High",
+      "copilotMode": "Copilot execution mode",
+      "copilotModeHint": "Execution mode: auto (prefer local CLI with web fallback), cli (strict CLI SDK), or web (direct API).",
+      "copilotModeAuto": "Auto (CLI with Web fallback)",
+      "copilotModeCli": "CLI Only (Local copilot-cli)",
+      "copilotModeWeb": "Web Only (Direct API)",
+      "copilotCliPath": "Custom Copilot CLI path",
+      "copilotCliPathHint": "Optional path to copilot or github-copilot-cli binary.",
       "ollamaFallback": "Ollama local fallback",
       "ollamaFallbackHint": "Automatically route queries to a local Ollama instance when cloud quota is exhausted.",
       "ollamaBaseUrl": "Ollama Base URL",
@@ -609,7 +616,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 = {
@@ -653,6 +667,13 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       "codexVerbosityLow": "低",
       "codexVerbosityMedium": "中",
       "codexVerbosityHigh": "高",
+      "copilotMode": "Copilot 执行模式",
+      "copilotModeHint": "执行模式：auto（优先本地 CLI，带 Web 回退）、cli（仅本地 CLI）、web（仅直连 API）。",
+      "copilotModeAuto": "自动（优先本地 CLI）",
+      "copilotModeCli": "仅本地 CLI",
+      "copilotModeWeb": "仅直连 API",
+      "copilotCliPath": "自定义 Copilot CLI 路径",
+      "copilotCliPathHint": "可选的 copilot 或 github-copilot-cli 二进制文件路径。",
       "ollamaFallback": "Ollama 本地模型自动兜底",
       "ollamaFallbackHint": "当云端配额耗尽或服务商故障时，自动将请求转发给本地 Ollama 实例。",
       "ollamaBaseUrl": "Ollama 服务基础 URL",
@@ -867,7 +888,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) {
@@ -1890,6 +1918,32 @@ const cssId = 'dsh-subscriptions/settings.module.css'
           ),
           React.createElement('div', { className: 'dsub-sub' },
             t('codexVerbosityHint')),
+          React.createElement('div', { className: 'dsub-row' },
+            React.createElement('span', { className: 'dsub-h' }, t('copilotMode')),
+            React.createElement('select', {
+              className: 'dsub-select',
+              value: draft.copilotMode || 'auto',
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { copilotMode: e.target.value })),
+            },
+              React.createElement('option', { value: 'auto' }, t('copilotModeAuto')),
+              React.createElement('option', { value: 'cli' }, t('copilotModeCli')),
+              React.createElement('option', { value: 'web' }, t('copilotModeWeb')),
+            ),
+          ),
+          React.createElement('div', { className: 'dsub-sub' },
+            t('copilotModeHint')),
+          React.createElement('div', { className: 'dsub-row' },
+            React.createElement('span', { className: 'dsub-h' }, t('copilotCliPath')),
+            React.createElement('input', {
+              className: 'dsub-input',
+              type: 'text',
+              value: draft.copilotCliPath || '',
+              placeholder: 'copilot',
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { copilotCliPath: e.target.value })),
+            }),
+          ),
+          React.createElement('div', { className: 'dsub-sub' },
+            t('copilotCliPathHint')),
           ),
           React.createElement('details', { className: 'dsub-group', open: true },
             React.createElement('summary', { className: 'dsub-groupHead' }, t('groupFallback')),
@@ -1971,6 +2025,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/config-schema.js

@@ -96,6 +96,10 @@ export const Config = z.object({
     .description('Custom model catalog for Codex.'),
   claudeSystemPrefix: z.string().volatile().default('')
     .description('System prompt prefix for Claude.'),
+  copilotMode: z.string().volatile().default('auto')
+    .description('#508 Execution mode for GitHub Copilot: auto (prefer CLI if available), cli (require copilot CLI), or web (direct web/OAuth API).'),
+  copilotCliPath: z.string().volatile().default('')
+    .description('#508 Custom binary path for copilot-cli (empty detects in PATH and ~/.npm-global).'),
   claudeCcVersion: z.string().volatile().default('')
     .description('Claude Code version header for billing attribution (default: 2.1.289.7e2).'),
   claudeModels: z.array(z.any()).volatile().default([])

package/lib/diagnostics.js

@@ -1,3 +1,5 @@
+import { copilotCliInfo } from './vendors/copilot.js'
+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 +54,8 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
     cache: calculateCacheMetrics(rows),
     queue: defaultConcurrencyQueue.stats(),
     pins: getSessionPinStats(),
+    reasoning: getSessionReasoningStats(),
+    copilotCli: copilotCliInfo(cfg),
     decisions: {
       recent: rows.filter((r) => r && r.decisionTrace).slice(0, 10).map((r) => ({
         ts: r.ts,

package/lib/import-auth.js

@@ -3,6 +3,7 @@ import { readFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 import { readClaudeCredentials } from './vendors/claude-cli.js'
+import { readCopilotCredentials } from './vendors/copilot-cli.js'
 import { normalizeExpiresAt } from './blob.js'
 import { isGoogleClientId, extractGoogleClientIdFromJwt, emailFromToken } from './jwt.js'
 import { DEFAULT_CLI_CLIENT_ID, DEFAULT_CLI_CLIENT_SECRET } from './vendors/antigravity.js'
@@ -264,6 +265,19 @@ async function discoverLocalCliSessionsInner() {
     detected['claude-cli'] = claudeEntry
   }
 
+  // 9. GitHub Copilot token and CLI credentials
+  const copilotCreds = await readCopilotCredentials(activeHome)
+  if (copilotCreds) {
+    const copilotEntry = {
+      provider: 'copilot',
+      source: copilotCreds.source || 'file',
+      path: copilotCreds.path || 'copilot-cli',
+      email: copilotCreds.email || 'GitHub Copilot User',
+      hasRefreshToken: !!copilotCreds.refreshToken,
+    }
+    detected.copilot = copilotEntry
+    detected['copilot-cli'] = copilotEntry
+  }
   // 9. GitHub Copilot token
   const copilotPaths = [
     homeFile('.config', 'github-copilot', 'hosts.json'),
@@ -317,6 +331,17 @@ export async function loadLocalCliBlob(provider, options = {}) {
   }
 
   if (canonical === 'copilot') {
+    const creds = await readCopilotCredentials(options && options.home)
+    if (creds && creds.accessToken) {
+      return {
+        accessToken: creds.accessToken,
+        refreshToken: creds.refreshToken || creds.accessToken,
+        githubToken: creds.githubToken || creds.accessToken,
+        expiresAt: creds.expiresAt || 0,
+        email: creds.email || 'GitHub Copilot User',
+        label: creds.label || creds.email || 'GitHub Copilot',
+      }
+    }
     let tok = process.env.GITHUB_COPILOT_TOKEN || process.env.GH_TOKEN || ''
     let email = 'GitHub Copilot User'
     if (info.source === 'file' && info.path) {

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/accounts.js

@@ -258,7 +258,7 @@ export function registerAccountsRoutes(ctx, state) {
         body = null
       }
       const rawProv = body && body.provider
-      const prov = (rawProv === 'claude-cli') ? 'claude' : rawProv
+      const prov = (rawProv === 'claude-cli') ? 'claude' : (rawProv === 'copilot-cli') ? 'copilot' : rawProv
       if (!prov || !isProvider(prov)) {
         writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'unknown or missing provider' } })
         return

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/vendors/copilot-cli.js

@@ -0,0 +1,400 @@
+// Native copilot-cli SDK mode with local tool calling (#508).
+// Enforces 0 Cyrillic characters.
+
+import { readFile } from 'node:fs/promises'
+import { existsSync, accessSync, constants } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, delimiter } from 'node:path'
+import { spawn } from 'node:child_process'
+import { LlmError } from '@deepseek-ai/dsh-llm'
+
+/**
+ * Standard candidate binary names for GitHub Copilot CLI.
+ */
+export const COPILOT_CLI_BINARIES = [
+  'copilot',
+  'copilot.cmd',
+  'copilot.exe',
+  'github-copilot-cli',
+  'github-copilot-cli.cmd',
+  'copilot-cli',
+  'gh-copilot',
+]
+
+/**
+ * Read GitHub Copilot credentials from local environments or config files.
+ * @param {string} [home] Test seam for home directory
+ * @param {NodeJS.ProcessEnv} [env] Test seam for process environment
+ * @returns {Promise<{ accessToken: string, githubToken: string, refreshToken?: string, expiresAt?: number, email?: string, label?: string, source: string, path?: string } | null>}
+ */
+export async function readCopilotCredentials(home, env = process.env) {
+  const activeHome = home || homedir()
+
+  // 1. Environment variables
+  const envToken = env.GITHUB_COPILOT_TOKEN || env.GH_TOKEN || env.GITHUB_TOKEN || env.COPILOT_API_KEY
+  if (envToken && typeof envToken === 'string' && envToken.trim()) {
+    const clean = envToken.trim()
+    return {
+      accessToken: clean,
+      githubToken: clean,
+      refreshToken: clean,
+      expiresAt: 0,
+      email: 'GitHub Copilot User',
+      label: 'copilot-env',
+      source: 'env',
+      path: env.GITHUB_COPILOT_TOKEN ? 'GITHUB_COPILOT_TOKEN' : (env.GH_TOKEN ? 'GH_TOKEN' : 'GITHUB_TOKEN'),
+    }
+  }
+
+  // 2. Known configuration files
+  const fileCandidates = [
+    join(activeHome, '.config', 'github-copilot', 'hosts.json'),
+    join(activeHome, '.config', 'github-copilot', 'apps.json'),
+    join(activeHome, '.copilot-cli', 'config.json'),
+    join(activeHome, '.config', 'gh', 'hosts.yml'),
+  ]
+
+  for (const filePath of fileCandidates) {
+    try {
+      if (!existsSync(filePath)) continue
+      const content = await readFile(filePath, 'utf8')
+      if (filePath.endsWith('.json')) {
+        const json = JSON.parse(content)
+        if (!json) continue
+        const gh = json['github.com'] || json
+        const tok = gh.oauth_token || gh.token || gh.access_token || gh.accessToken
+        if (tok) {
+          return {
+            accessToken: String(tok),
+            githubToken: String(tok),
+            refreshToken: String(tok),
+            expiresAt: 0,
+            email: gh.user || 'GitHub Copilot User',
+            label: gh.user || 'copilot-cli',
+            source: 'file',
+            path: filePath,
+          }
+        }
+      } else if (filePath.endsWith('.yml') || filePath.endsWith('.yaml')) {
+        const lines = content.split('\n')
+        let inGithub = false
+        let user = ''
+        let oauthToken = ''
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (/^github\.com:/.test(trimmed)) {
+            inGithub = true
+            continue
+          }
+          if (inGithub) {
+            if (/^[a-zA-Z0-9.-]+:/.test(trimmed) && !trimmed.startsWith('oauth_token') && !trimmed.startsWith('user')) {
+              break
+            }
+            const userMatch = /user:\s*([^\s#]+)/.exec(trimmed)
+            if (userMatch) user = userMatch[1]
+            const tokenMatch = /oauth_token:\s*([^\s#]+)/.exec(trimmed)
+            if (tokenMatch) oauthToken = tokenMatch[1]
+          }
+        }
+        if (oauthToken) {
+          return {
+            accessToken: oauthToken,
+            githubToken: oauthToken,
+            refreshToken: oauthToken,
+            expiresAt: 0,
+            email: user || 'GitHub Copilot User',
+            label: user || 'gh-hosts',
+            source: 'file',
+            path: filePath,
+          }
+        }
+      }
+    } catch {
+      // Continue to next candidate
+    }
+  }
+
+  return null
+}
+
+/**
+ * Locate Copilot CLI binary on system.
+ * @param {string} [customPath] Explicit user-configured path
+ * @param {NodeJS.ProcessEnv} [env] Process environment
+ * @param {string} [platform] Process platform
+ * @returns {string|null} Resolved executable path or null
+ */
+export function findCopilotCli(customPath, env = process.env, platform = process.platform) {
+  if (customPath && typeof customPath === 'string' && customPath.trim()) {
+    const p = customPath.trim()
+    try {
+      if (existsSync(p)) return p
+    } catch { /* best-effort */ }
+  }
+
+  const pathVar = env.PATH || ''
+  const pathDirs = pathVar.split(delimiter).filter(Boolean)
+
+  const home = env.HOME || env.USERPROFILE || homedir()
+  if (home) {
+    pathDirs.push(
+      join(home, '.npm-global', 'bin'),
+      join(home, '.local', 'bin'),
+      join(home, 'AppData', 'Roaming', 'npm'),
+    )
+  }
+
+  for (const dir of pathDirs) {
+    for (const bin of COPILOT_CLI_BINARIES) {
+      const fullPath = join(dir, bin)
+      try {
+        if (existsSync(fullPath)) {
+          if (platform !== 'win32') {
+            try {
+              accessSync(fullPath, constants.X_OK)
+            } catch {
+              continue
+            }
+          }
+          return fullPath
+        }
+      } catch {
+        // Continue searching
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Verify Copilot CLI availability and return status.
+ * @param {{ customPath?: string, env?: NodeJS.ProcessEnv }} [options]
+ * @returns {{ available: boolean, path?: string, error?: string }}
+ */
+export function isCopilotCliAvailable(options = {}) {
+  const binary = findCopilotCli(options.customPath, options.env)
+  if (binary) {
+    return { available: true, path: binary }
+  }
+  return { available: false, error: 'copilot_binary_not_found' }
+}
+
+/**
+ * Translate DSH turn options to Copilot CLI arguments and environment.
+ * @param {any} options
+ * @param {any} [blob]
+ * @param {string} [binaryPath]
+ * @returns {{ args: string[], env: NodeJS.ProcessEnv, inputPayload: string }}
+ */
+export function prepareCopilotCliInvocation(options, blob = {}, _binaryPath = 'copilot') {
+  const model = options.model || 'claude-3.7-sonnet'
+  const token = blob.accessToken || blob.githubToken || blob.refreshToken || ''
+
+  const args = [
+    '--model', model,
+    '--stream',
+    '--json',
+  ]
+
+  if (options.temperature != null) {
+    args.push('--temperature', String(options.temperature))
+  }
+  if (options.maxTokens != null) {
+    args.push('--max-tokens', String(options.maxTokens))
+  }
+
+  if (Array.isArray(options.tools) && options.tools.length) {
+    args.push('--tools', JSON.stringify(options.tools))
+  }
+
+  const env = {
+    ...process.env,
+    ...(token ? {
+      GITHUB_TOKEN: token,
+      GH_TOKEN: token,
+      GITHUB_COPILOT_TOKEN: token,
+      COPILOT_API_KEY: token,
+    } : {}),
+  }
+
+  const inputPayload = JSON.stringify({
+    model,
+    messages: options.messages || (options.prompt ? [{ role: 'user', content: options.prompt }] : []),
+    tools: options.tools || [],
+  })
+
+  return { args, env, inputPayload }
+}
+
+/**
+ * Stream execution from local Copilot CLI process.
+ * Yields canonical DSH events: block-start, text-delta, tool-call-delta, finish, usage.
+ * @param {object} params
+ * @param {string} params.binaryPath
+ * @param {any} params.options
+ * @param {any} [params.blob]
+ * @param {any} [params.config]
+ * @param {AbortSignal} [params.signal]
+ * @param {Function} [params.spawnImpl] Test seam for child_process.spawn
+ * @returns {AsyncGenerator<any, void, unknown>}
+ */
+export async function* streamCopilotCli({ binaryPath, options, blob, _config, signal, spawnImpl }) {
+  if (signal && signal.aborted) {
+    throw new LlmError('Request aborted by client', 'ABORTED')
+  }
+
+  const { args, env, inputPayload } = prepareCopilotCliInvocation(options, blob, binaryPath)
+  const spawner = spawnImpl || spawn
+
+  let child
+  try {
+    child = spawner(binaryPath, args, {
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+  } catch (err) {
+    throw new LlmError(`Failed to spawn Copilot CLI: ${err && err.message ? err.message : err}`, 'INTERNAL_ERROR')
+  }
+
+  if (signal) {
+    const abortHandler = () => {
+      try { child.kill('SIGTERM') } catch { /* best-effort */ }
+    }
+    signal.addEventListener('abort', abortHandler, { once: true })
+  }
+
+  if (child.stdin) {
+    child.stdin.write(inputPayload)
+    child.stdin.end()
+  }
+
+  let textStarted = false
+  let toolIndex = 0
+  let sawTools = false
+  const toolCallMap = new Map()
+
+  let stdoutBuffer = ''
+  let stderrBuffer = ''
+
+  if (child.stderr) {
+    child.stderr.on('data', (d) => { stderrBuffer += d.toString() })
+  }
+
+  const chunkQueue = []
+  let resolveNext = null
+  let processEnded = false
+  let processError = null
+
+  child.stdout.on('data', (chunk) => {
+    stdoutBuffer += chunk.toString()
+    let newlineIndex
+    while ((newlineIndex = stdoutBuffer.indexOf('\n')) >= 0) {
+      const line = stdoutBuffer.slice(0, newlineIndex).trim()
+      stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1)
+      if (line) {
+        chunkQueue.push(line)
+        if (resolveNext) {
+          const r = resolveNext
+          resolveNext = null
+          r()
+        }
+      }
+    }
+  })
+
+  child.on('error', (err) => {
+    processError = err
+    if (resolveNext) {
+      const r = resolveNext
+      resolveNext = null
+      r()
+    }
+  })
+
+  child.on('close', (code) => {
+    processEnded = true
+    if (stdoutBuffer.trim()) {
+      chunkQueue.push(stdoutBuffer.trim())
+      stdoutBuffer = ''
+    }
+    if (code !== 0 && !chunkQueue.length) {
+      processError = new LlmError(`Copilot CLI exited with code ${code}: ${stderrBuffer.trim() || 'unknown error'}`, 'VENDOR')
+    }
+    if (resolveNext) {
+      const r = resolveNext
+      resolveNext = null
+      r()
+    }
+  })
+
+  while (true) {
+    if (chunkQueue.length) {
+      const line = chunkQueue.shift()
+      const raw = line.startsWith('data:') ? line.slice(5).trim() : line
+      if (raw === '[DONE]') break
+
+      let parsed = null
+      try { parsed = JSON.parse(raw) } catch { /* text fragment */ }
+
+      if (parsed) {
+        // 1. Text delta
+        const text = parsed.text || parsed.delta?.content || parsed.content || (parsed.choices && parsed.choices[0]?.delta?.content)
+        if (typeof text === 'string' && text) {
+          if (!textStarted) {
+            yield { type: 'block-start', index: 0, blockType: 'text' }
+            textStarted = true
+          }
+          yield { type: 'text-delta', index: 0, text }
+        }
+
+        // 2. Tool calls
+        const toolCalls = parsed.tool_calls || parsed.delta?.tool_calls || (parsed.choices && parsed.choices[0]?.delta?.tool_calls) || (parsed.tool_call ? [parsed.tool_call] : null)
+        if (Array.isArray(toolCalls)) {
+          sawTools = true
+          for (const tc of toolCalls) {
+            const id = tc.id || `call_${toolIndex}`
+            const name = tc.name || (tc.function && tc.function.name)
+            const argsDelta = tc.argumentsDelta || tc.arguments || (tc.function && tc.function.arguments) || ''
+            let idx = toolCallMap.get(id)
+            if (idx === undefined) {
+              idx = ++toolIndex
+              toolCallMap.set(id, idx)
+              yield { type: 'block-start', index: idx, blockType: 'tool-call' }
+            }
+            yield {
+              type: 'tool-call-delta',
+              index: idx,
+              id,
+              ...(name ? { name } : {}),
+              argumentsDelta: typeof argsDelta === 'string' ? argsDelta : JSON.stringify(argsDelta),
+            }
+          }
+        }
+
+        // 3. Usage
+        if (parsed.usage) {
+          yield { type: 'usage', usage: parsed.usage }
+        }
+      } else if (raw) {
+        // Plain text stdout line
+        if (!textStarted) {
+          yield { type: 'block-start', index: 0, blockType: 'text' }
+          textStarted = true
+        }
+        yield { type: 'text-delta', index: 0, text: raw }
+      }
+    } else if (processEnded) {
+      if (processError) throw processError
+      break
+    } else {
+      await new Promise((res) => { resolveNext = res })
+      if (processError && !chunkQueue.length) throw processError
+    }
+  }
+
+  yield {
+    type: 'finish',
+    reason: { kind: sawTools ? 'tool-calls' : 'stop' },
+  }
+}

package/lib/vendors/copilot.js

@@ -2,6 +2,7 @@ import { LlmError } from "@deepseek-ai/dsh-llm"
 import { openaiMessages, openaiTools, modelCatalog } from "../messages.js"
 import { fetchWithTimeout } from "../http.js"
 import { openaiChatStream, readJson, httpError } from "../wire.js"
+import { findCopilotCli, streamCopilotCli, isCopilotCliAvailable, COPILOT_CLI_BINARIES } from "./copilot-cli.js"
 
 export const id = "copilot"
 
@@ -53,6 +54,14 @@ const COPILOT_MODELS = [
   }
 ]
 
+export function copilotCliInfo(config = {}) {
+  const status = isCopilotCliAvailable({ customPath: config && config.copilotCliPath })
+  return {
+    ...status,
+    supportedBinaries: COPILOT_CLI_BINARIES,
+  }
+}
+
 export function providerInfo() {
   return { id, name: "GitHub Copilot" }
 }
@@ -280,7 +289,28 @@ export async function usage(blob, config, fetchImpl) {
   }
 }
 
-export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal, spawnImpl }) {
+  const mode = (config && config.copilotMode) || (blob && blob.copilotMode) || 'auto'
+  const customPath = (config && config.copilotCliPath) || (blob && blob.copilotCliPath) || ''
+
+  if (mode !== 'web') {
+    const cliPath = findCopilotCli(customPath)
+    if (cliPath) {
+      try {
+        let yieldedAny = false
+        for await (const chunk of streamCopilotCli({ binaryPath: cliPath, options, blob, config, signal, spawnImpl })) {
+          yieldedAny = true
+          yield chunk
+        }
+        if (yieldedAny) return
+      } catch (err) {
+        if (mode === 'cli') throw err
+        // In auto mode, fallback seamlessly to web / OAuth execution
+      }
+    } else if (mode === 'cli') {
+      throw new LlmError('GitHub Copilot CLI binary not found on system', 'NOT_CONFIGURED')
+    }
+  }
   const impl = fetchImpl || fetch
   let copilotToken = blob && blob.accessToken
   const githubToken = blob && (blob.refreshToken || blob.githubToken)

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.66",
   "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",