@goodandready/dsh-subscriptions 0.6.65 → 0.6.66

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`.
 
+### 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.

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`.
 
+### 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.

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",
@@ -660,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",
@@ -1904,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')),

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,4 @@
+import { copilotCliInfo } from './vendors/copilot.js'
 import { getSessionReasoningStats } from './reasoning-effort.js'
 import { defaultConcurrencyQueue } from './concurrency-queue.js'
 import { calculateCacheMetrics } from './analytics.js'
@@ -54,6 +55,7 @@ export async function createDiagnosticsReport({ live, store, history, NS, pkgVer
     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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.65",
+  "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",