@goodandready/dsh-subscriptions 0.4.23 → 0.5.0

package/lib/client.js

@@ -81,6 +81,8 @@ window.__ModuleLoader__.load({
     '.dsub-brandGrok{background:rgba(168,85,247,.15);color:#c084fc;border:1px solid rgba(168,85,247,.3)}' +
     '.dsub-brandAgy{background:rgba(59,130,246,.15);color:#60a5fa;border:1px solid rgba(59,130,246,.3)}' +
     '.dsub-brandOllama{background:rgba(107,114,128,.15);color:#9ca3af;border:1px solid rgba(107,114,128,.3)}' +
+    '.dsub-brandKimi{background:rgba(236,72,153,.15);color:#f472b6;border:1px solid rgba(236,72,153,.3)}' +
+    '.dsub-brandGlm{background:rgba(20,184,166,.15);color:#2dd4bf;border:1px solid rgba(20,184,166,.3)}' +
     '.dsub-accInfo{flex:1;min-width:0;display:flex;flex-direction:column;gap:3px}' +
     '.dsub-accNameRow{display:flex;align-items:center;justify-content:space-between;gap:8px}' +
     '.dsub-accName{font-size:13px;font-weight:600}' +
@@ -210,6 +212,8 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'checking': 'Checking…',
       'importToken': 'Import',
       'importTokenPlace': 'Paste an existing token',
+      'importLocalCli': 'Import from local CLI',
+      'importLocalSuccess': 'Imported from local CLI!',
       'reconnectRequired': 'Reconnect required',
       'manualTitle': 'If the browser did not come back',
       'windowPrimary': 'Primary window',
@@ -220,6 +224,8 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'checking': 'Проверяю…',
       'importToken': 'Внести',
       'importTokenPlace': 'Вставить уже готовый токен',
+      'importLocalCli': 'Импортировать из локального CLI',
+      'importLocalSuccess': 'Импортировано из локального CLI!',
       'reconnectRequired': 'Нужно переподключить',
       'manualTitle': 'Если браузер не вернулся сам',
       'windowPrimary': 'Основное окно',
@@ -607,6 +613,19 @@ const cssId = 'dsh-subscriptions/settings.module.css'
         setAccounts(data.accounts || [])
       }
 
+            const importLocalCli = async (provider, index) => {
+        setErr('')
+        const res = await fetch('/dsh-subscriptions/import-local', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ provider, index }),
+        })
+        const data = await res.json().catch(() => ({}))
+        if (!res.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        await load()
+        setInfo(t('importLocalSuccess'))
+      }
+
       const importToken = async (provider, index) => {
         setErr('')
         const tok = (tokenDraft[provider + ':' + index] || '').trim()
@@ -752,6 +771,11 @@ const cssId = 'dsh-subscriptions/settings.module.css'
                     type: 'button', className: 'dsub-mini',
                     onClick: () => importToken(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
                   }, t('importToken')),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini',
+                    title: t('importLocalCli'),
+                    onClick: () => importLocalCli(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
+                  }, '📥 CLI'),
                 ),
                 React.createElement('div', { className: 'dsub-row' },
                   React.createElement('input', {
@@ -1120,6 +1144,8 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       if (p.includes('claude') || p.includes('anthropic')) return { label: 'Claude', cls: 'dsub-brandClaude', icon: '✳' }
       if (p.includes('grok') || p.includes('xai')) return { label: 'Grok', cls: 'dsub-brandGrok', icon: '✦' }
       if (p.includes('antigravity') || p.includes('google') || p.includes('gemini')) return { label: 'AGY', cls: 'dsub-brandAgy', icon: '◆' }
+      if (p.includes('kimi')) return { label: 'Kimi', cls: 'dsub-brandKimi', icon: '🌙' }
+      if (p.includes('glm') || p.includes('zcode')) return { label: 'GLM', cls: 'dsub-brandGlm', icon: '⚡' }
       if (p.includes('ollama')) return { label: 'Ollama', cls: 'dsub-brandOllama', icon: '🦙' }
       return { label: (p.charAt(0).toUpperCase() || 'P'), cls: 'dsub-brandCodex', icon: '●' }
     }

package/lib/import-auth.js

@@ -0,0 +1,163 @@
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+function homeFile(...parts) {
+  return join(homedir(), ...parts)
+}
+
+async function readJson(path) {
+  try {
+    const text = await readFile(path, 'utf8')
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+export async function discoverLocalCliSessions() {
+  const detected = {}
+
+  // 1. Codex CLI
+  const codex = await readJson(homeFile('.codex', 'auth.json'))
+  if (codex && (codex.access_token || codex.accessToken || (codex.tokens && codex.tokens.access_token))) {
+    const tok = codex.tokens || codex
+    detected.codex = {
+      provider: 'codex',
+      path: homeFile('.codex', 'auth.json'),
+      email: codex.email || codex.account || '',
+      hasRefreshToken: !!(tok.refresh_token || tok.refreshToken),
+    }
+  }
+
+  // 2. Grok CLI / Hermes
+  const grokPaths = [
+    homeFile('.grok', 'auth.json'),
+    homeFile('.hermes', 'auth.json'),
+  ]
+  for (const p of grokPaths) {
+    const grok = await readJson(p)
+    if (grok && (grok.access_token || grok.token || (grok.tokens && grok.tokens.access_token))) {
+      detected.grok = {
+        provider: 'grok',
+        path: p,
+        email: grok.email || grok.account || '',
+        hasRefreshToken: !!(grok.refresh_token || (grok.tokens && grok.tokens.refresh_token)),
+      }
+      break
+    }
+  }
+
+  // 3. Antigravity / Gemini CLI
+  const agyPaths = [
+    homeFile('.gemini', 'antigravity-cli', 'antigravity-oauth-token'),
+    homeFile('.cli-proxy-api', 'antigravity.json'),
+  ]
+  for (const p of agyPaths) {
+    const agy = await readJson(p)
+    const tok = agy && agy.token ? agy.token : agy
+    if (tok && (tok.access_token || tok.accessToken)) {
+      detected.antigravity = {
+        provider: 'antigravity',
+        path: p,
+        email: agy.email || tok.account || '',
+        hasRefreshToken: !!(tok.refresh_token || tok.refreshToken),
+      }
+      break
+    }
+  }
+
+  // 4. Kimi Code Plan
+  const kimi = await readJson(homeFile('.kimi-code', 'credentials', 'kimi-code.json'))
+  if (kimi && (kimi.access_token || kimi.token)) {
+    detected.kimi = {
+      provider: 'kimi',
+      path: homeFile('.kimi-code', 'credentials', 'kimi-code.json'),
+      email: kimi.email || kimi.account || '',
+      hasRefreshToken: !!(kimi.refresh_token || kimi.refreshToken),
+    }
+  }
+
+  // 5. GLM ZCode
+  const glmPaths = [
+    homeFile('.zcode', 'v2', 'config.json'),
+    homeFile('.zcode', 'cli', 'config.json'),
+    homeFile('.zcode', 'config.json'),
+  ]
+  for (const p of glmPaths) {
+    const glm = await readJson(p)
+    if (glm && (glm.apiKey || glm.api_key || (glm.provider && glm.provider.apiKey))) {
+      detected.glm = {
+        provider: 'glm',
+        path: p,
+        email: 'ZCode CLI Account',
+        hasRefreshToken: false,
+      }
+      break
+    }
+  }
+
+  return detected
+}
+
+export async function loadLocalCliBlob(provider) {
+  const discovered = await discoverLocalCliSessions()
+  const info = discovered[provider]
+  if (!info) throw new Error(`no local CLI session found for ${provider}`)
+
+  const raw = await readJson(info.path)
+  if (!raw) throw new Error(`failed to read local CLI file: ${info.path}`)
+
+  if (provider === 'codex') {
+    const tok = raw.tokens || raw
+    return {
+      accessToken: tok.access_token || tok.accessToken || '',
+      refreshToken: tok.refresh_token || tok.refreshToken || '',
+      expiresAt: tok.expires_at || tok.expiresAt || (Date.now() + 3600 * 1000),
+      email: raw.email || raw.account || '',
+      accountId: raw.account_id || raw.accountId || '',
+    }
+  }
+
+  if (provider === 'grok') {
+    const tok = raw.tokens || raw
+    return {
+      accessToken: tok.access_token || tok.token || '',
+      refreshToken: tok.refresh_token || '',
+      expiresAt: tok.expires_at || tok.expiresAt || (Date.now() + 3600 * 1000),
+      email: raw.email || raw.account || '',
+    }
+  }
+
+  if (provider === 'antigravity') {
+    const tok = raw.token || raw
+    return {
+      accessToken: tok.access_token || tok.accessToken || '',
+      refreshToken: tok.refresh_token || tok.refreshToken || '',
+      expiresAt: tok.expiry || tok.expires_at || tok.expiresAt || (Date.now() + 3600 * 1000),
+      email: raw.email || tok.account || '',
+      projectId: raw.project_id || raw.projectId || tok.project_id || '',
+    }
+  }
+
+  if (provider === 'kimi') {
+    return {
+      accessToken: raw.access_token || raw.token || '',
+      refreshToken: raw.refresh_token || '',
+      expiresAt: raw.expires_at || (Date.now() + 86400 * 1000),
+      email: raw.email || raw.account || '',
+    }
+  }
+
+  if (provider === 'glm') {
+    const apiKey = raw.apiKey || raw.api_key || (raw.provider && raw.provider.apiKey) || ''
+    return {
+      accessToken: apiKey,
+      refreshToken: '',
+      expiresAt: Date.now() + 30 * 86400 * 1000,
+      email: 'ZCode CLI',
+    }
+  }
+
+  throw new Error(`unsupported local CLI import for provider ${provider}`)
+}

package/lib/index.js

@@ -1,3 +1,4 @@
+import { discoverLocalCliSessions, loadLocalCliBlob } from './import-auth.js'
 import { readFileSync } from 'node:fs'
 import z from '@deepseek-ai/schemastery'
 import { PROVIDERS, oauthRef, parseOauthRef, isProvider, displayName, droppedCredentialRefs } from './refs.js'
@@ -1123,6 +1124,53 @@ export function apply(ctx, config) {
     },
   }), 'dsh-subscriptions: /check')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/discover-local',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } })
+        return
+      }
+      try {
+        const detected = await discoverLocalCliSessions()
+        writeJson(res, 200, { ok: true, detected })
+      } catch (e) {
+        writeJson(res, 500, { ok: false, error: { message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /discover-local')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/import-local',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const body = await readBody(req).catch(() => null)
+      if (!body || !body.provider) {
+        writeJson(res, 400, { ok: false, error: { code: 'bad_request', message: 'missing provider' } })
+        return
+      }
+      try {
+        const blob = await loadLocalCliBlob(body.provider)
+        const slot = normalizeSlots(live().slots).find((s) => s.provider === body.provider && s.index === (Number(body.index) || 1))
+        const ref = slot ? slot.ref : `${body.provider.toUpperCase()}_OAUTH_${Number(body.index) || 1}`
+        await store.saveBlob(ref, blob)
+        writeJson(res, 200, { ok: true, ref, provider: body.provider, email: blob.email || '' })
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /import-local')
+
+
   // HTTP-прокси к API провайдера через subscriptions.request.
   // Same-origin only, allowlist путей, ротация и квота как у моделей.
   // Токен наружу не отдаётся — наружу только ответ провайдера.

package/lib/refs.js

@@ -4,6 +4,8 @@ export const BUILTIN_PROVIDERS = Object.freeze([
   'claude',
   'grok',
   'antigravity',
+  'kimi',
+  'glm',
 ])
 
 const dynamicIds = new Set()
@@ -39,6 +41,8 @@ const DISPLAY = {
   claude: 'Claude',
   grok: 'Grok',
   antigravity: 'Antigravity',
+  kimi: 'Moonshot Kimi',
+  glm: 'Zhipu GLM',
 }
 
 export function displayName(provider) {

package/lib/vendors/codex.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto'
+import { randomUUID, createHash } from 'node:crypto'
 import { buildAuthorizeUrl } from '../oauth.js'
 import { codexResponsesBody, modelCatalog } from '../messages.js'
 import { chatgptAccountId, emailFromToken } from '../jwt.js'
@@ -206,19 +206,49 @@ export async function usage(blob, cfg, fetchImpl) {
 export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
   const base = (config.baseUrl || defaults().baseUrl).replace(/\/$/, '')
   const body = codexResponsesBody(options, INSTRUCTIONS, config)
+  const sessionId = deriveSessionId(options)
+
+  // Prompt Cache Affinity
+  body.prompt_cache_key = sessionId
+  delete body.session_id
+  delete body.prompt_cache_retention
+  delete body.prompt_cache_options
+
+  const isFast = !!(config && config.fastMode) || String((options && options.model) || '').toLowerCase().endsWith('-fast')
+  if (isFast) {
+    body.service_tier = 'priority'
+  }
+
+  const codexHeaders = {
+    'Content-Type': 'application/json',
+    Accept: 'text/event-stream',
+    'session-id': sessionId,
+    'x-client-request-id': sessionId,
+    ...(isFast ? { 'x-codex-routing-hint': `model=${(options && options.model) || 'gpt-5.6-luna'};tier=priority` } : {}),
+  }
+
   const res = await fetchImpl(`${base}/responses`, {
     method: 'POST',
     headers: {
       ...headers,
-      ...identityHeaders(blob, config, {
-        'Content-Type': 'application/json',
-        Accept: 'text/event-stream',
-        'session-id': randomUUID(),
-      }),
+      ...identityHeaders(blob, config, codexHeaders),
     },
     body: JSON.stringify(body),
     signal,
   })
   if (!res.ok) throw httpError(res.status, await res.text())
   yield* codexResponsesStream(res.body)
-}
+}
+export function deriveSessionId(options) {
+  const explicit = (options && (options.sessionId || options.session_id || options.conversationId || options.prompt_cache_key))
+  if (typeof explicit === 'string' && explicit.trim()) {
+    return explicit.trim().replace(/[^A-Za-z0-9._:-]/g, '-').slice(0, 64)
+  }
+  const firstUserMsg = (options && options.messages || []).find((m) => m.role === 'user')
+  const text = (firstUserMsg && (typeof firstUserMsg.content === 'string' ? firstUserMsg.content : JSON.stringify(firstUserMsg.content))) || ''
+  if (text) {
+    const hash = createHash('sha256').update(text.slice(0, 500)).digest('hex').slice(0, 32)
+    return `dsh-sub-${hash}`
+  }
+  return randomUUID()
+}

package/lib/vendors/glm.js

@@ -0,0 +1,113 @@
+import { LlmError } from '@deepseek-ai/dsh-llm'
+import { openaiMessages, openaiTools } from '../messages.js'
+import { openaiChatStream, readJson, httpError } from '../wire.js'
+import { asUsageSnapshot } from '../usage.js'
+
+export const id = 'glm'
+
+export const GLM_CODING_URL = 'https://api.z.ai/api/coding/paas/v4/chat/completions'
+export const GLM_QUOTA_URL = 'https://api.z.ai/api/monitor/usage/quota/limit'
+export const GLM_USER_AGENT = 'ZCode/3.10.1'
+
+export const GLM_MODELS = [
+  {
+    id: 'glm-4-plus',
+    name: 'GLM-4-Plus (Coding Plan)',
+    contextWindow: 131072,
+    maxTokens: 4096,
+    inputModalities: ['text'],
+    reasoning: { efforts: [{ id: 'low', name: 'Low' }, { id: 'high', name: 'High' }, { id: 'max', name: 'Max' }] },
+  },
+  {
+    id: 'glm-4-flash',
+    name: 'GLM-4-Flash (High Speed)',
+    contextWindow: 131072,
+    maxTokens: 4096,
+    inputModalities: ['text', 'image'],
+  },
+  {
+    id: 'glm-zero-preview',
+    name: 'GLM Zero (Thinking)',
+    contextWindow: 131072,
+    maxTokens: 8192,
+    inputModalities: ['text'],
+  },
+]
+
+export function providerInfo() {
+  return { id, name: 'Zhipu GLM' }
+}
+
+export function defaults() {
+  return {
+    codingUrl: GLM_CODING_URL,
+    quotaUrl: GLM_QUOTA_URL,
+    models: GLM_MODELS.map((m) => m.id),
+  }
+}
+
+export function authorizeUrl() {
+  return 'https://chat.z.ai/api/oauth/authorize'
+}
+
+export async function listModels() {
+  return GLM_MODELS
+}
+
+export async function usage(blob, config, fetchImpl) {
+  try {
+    const impl = fetchImpl || fetch
+    const url = (config && config.quotaUrl) || GLM_QUOTA_URL
+    const token = blob && (blob.accessToken || blob.access_token)
+    if (!token) return null
+    const res = await impl(url, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'User-Agent': GLM_USER_AGENT,
+        Accept: 'application/json',
+      },
+    })
+    if (!res.ok) return null
+    const json = await readJson(res)
+    if (json && json.data && json.data.percentage != null) {
+      return asUsageSnapshot(Math.round(json.data.percentage))
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+  const impl = fetchImpl || fetch
+  const url = (config && config.codingUrl) || GLM_CODING_URL
+  const token = blob && (blob.accessToken || blob.access_token)
+  if (!token) throw new LlmError('GLM not authenticated', 'AUTH')
+
+  const body = {
+    model: options.model || 'glm-4-plus',
+    messages: openaiMessages(options),
+    stream: true,
+    ...(options.maxTokens != null ? { max_tokens: options.maxTokens } : {}),
+    ...(options.temperature != null ? { temperature: options.temperature } : {}),
+  }
+
+  const tools = openaiTools(options)
+  if (tools && tools.length) body.tools = tools
+
+  const res = await impl(url, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+      'User-Agent': GLM_USER_AGENT,
+      'X-Coding-Plan-Boost': '1.5',
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+
+  if (!res.ok) throw httpError(res.status, await res.text())
+  yield* openaiChatStream(res.body)
+}

package/lib/vendors/grok.js

@@ -197,11 +197,32 @@ export async function check(blob, cfg, fetchImpl) {
 
 export async function usage(blob, cfg, fetchImpl) {
   try {
-    const res = await (fetchImpl || fetch)(BILLING, {
+    const impl = fetchImpl || fetch
+    const res = await impl(BILLING, {
       headers: { ...identityHeaders(blob, cfg), Accept: 'application/json' },
     })
     const json = await readJson(res)
-    const snap = asUsageSnapshot(grokBillingPercent(json))
+    let pct = grokBillingPercent(json)
+    if (pct == null) {
+      // Fallback to gRPC-web GetGrokCreditsConfig
+      try {
+        const gRes = await impl('https://grok.com/rest/app-chat/get-grok-credits-config', {
+          method: 'POST',
+          headers: {
+            ...identityHeaders(blob, cfg),
+            'Content-Type': 'application/grpc-web+proto',
+            'X-User-Agent': 'grpc-web-javascript/0.1',
+          },
+          body: Buffer.from([0, 0, 0, 0, 0]),
+        })
+        if (gRes.ok) {
+          const buf = await gRes.arrayBuffer()
+          const decoded = decodeGrokCreditsFrame(Buffer.from(buf))
+          if (decoded != null) pct = decoded
+        }
+      } catch {}
+    }
+    const snap = asUsageSnapshot(pct)
     if (snap) snap.windows = usageWindows(json)
     return snap
   } catch {
@@ -233,4 +254,82 @@ export async function* streamOnce({ blob, options, fetchImpl, headers, config, s
   })
   if (!res.ok) throw httpError(res.status, await res.text())
   yield* codexResponsesStream(res.body)
-}
+}
+
+function readVarint(bytes, offset) {
+  let value = 0, shift = 0, index = offset
+  while (index < bytes.length) {
+    const byte = bytes[index]
+    index += 1
+    value += (byte & 0x7f) * (2 ** shift)
+    if ((byte & 0x80) === 0) return { value, next: index }
+    shift += 7
+    if (shift > 63) return undefined
+  }
+  return undefined
+}
+function readLength(bytes, offset, size) {
+  if (offset + size > bytes.length) return undefined
+  return { bytes: bytes.subarray(offset, offset + size), next: offset + size }
+}
+function decodeFields(bytes) {
+  const fields = new Map()
+  let offset = 0
+  while (offset < bytes.length) {
+    const tag = readVarint(bytes, offset)
+    if (!tag) break
+    const fieldNumber = Math.floor(tag.value / 8)
+    const wireType = tag.value % 8
+    offset = tag.next
+    if (fieldNumber <= 0) return undefined
+    let value
+    if (wireType === 0) {
+      const next = readVarint(bytes, offset)
+      if (!next) return undefined
+      value = { wireType, value: next.value }
+      offset = next.next
+    } else if (wireType === 5) {
+      const next = readLength(bytes, offset, 4)
+      if (!next) return undefined
+      value = { wireType, bytes: next.bytes }
+      offset = next.next
+    } else if (wireType === 1) {
+      const next = readLength(bytes, offset, 8)
+      if (!next) return undefined
+      value = { wireType, bytes: next.bytes }
+      offset = next.next
+    } else if (wireType === 2) {
+      const length = readVarint(bytes, offset)
+      if (!length) return undefined
+      const next = readLength(bytes, length.next, length.value)
+      if (!next) return undefined
+      value = { wireType, bytes: next.bytes }
+      offset = next.next
+    } else return undefined
+    if (!fields.has(fieldNumber)) fields.set(fieldNumber, value)
+  }
+  return fields
+}
+function float32Le(field) {
+  if (!field || field.wireType !== 5 || !field.bytes || field.bytes.length < 4) return undefined
+  const val = Buffer.from(field.bytes).readFloatLE(0)
+  return Number.isFinite(val) ? val : undefined
+}
+export function decodeGrokCreditsFrame(buffer) {
+  try {
+    const bytes = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer)
+    if (!bytes.length) return undefined
+    const payload = bytes.length > 5 && bytes[0] === 0 ? bytes.subarray(5) : bytes
+    const top = decodeFields(payload)
+    if (!top) return undefined
+    const nested = top.get(1)?.wireType === 2 ? decodeFields(top.get(1).bytes) : undefined
+    const credits = nested ?? top
+    if (!credits) return undefined
+    const ratio = float32Le(credits.get(1))
+    if (ratio == null) return undefined
+    const pct = ratio <= 1 ? Math.round(ratio * 100) : Math.round(ratio)
+    return Math.max(0, Math.min(100, pct))
+  } catch {
+    return undefined
+  }
+}

package/lib/vendors/index.js

@@ -2,9 +2,11 @@ import * as codex from './codex.js'
 import * as claude from './claude.js'
 import * as grok from './grok.js'
 import * as antigravity from './antigravity.js'
+import * as kimi from './kimi.js'
+import * as glm from './glm.js'
 import { createVendorFromProfile } from '../vendor-factory.js'
 
-const builtins = { codex, claude, grok, antigravity }
+const builtins = { codex, claude, grok, antigravity, kimi, glm }
 
 const customVendors = new Map()
 

package/lib/vendors/kimi.js

@@ -0,0 +1,120 @@
+import { LlmError } from '@deepseek-ai/dsh-llm'
+import { openaiMessages, openaiTools } from '../messages.js'
+import { openaiChatStream, readJson, httpError } from '../wire.js'
+import { asUsageSnapshot } from '../usage.js'
+
+export const id = 'kimi'
+
+export const KIMI_CLIENT_ID = '17e5f671-d194-4dfb-9706-5516cb48c098'
+export const KIMI_DEVICE_URL = 'https://auth.kimi.com/api/oauth/device_authorization'
+export const KIMI_TOKEN_URL = 'https://auth.kimi.com/api/oauth/token'
+export const KIMI_API_BASE = 'https://api.kimi.com/coding/v1'
+
+export const KIMI_MODELS = [
+  {
+    id: 'kimi-for-coding',
+    name: 'Kimi for Coding (256k)',
+    contextWindow: 262144,
+    maxTokens: 32000,
+    inputModalities: ['text', 'image'],
+    reasoning: { efforts: [{ id: 'off', name: 'Off' }, { id: 'low', name: 'Low' }, { id: 'medium', name: 'Medium' }, { id: 'high', name: 'High' }, { id: 'max', name: 'Max' }] },
+  },
+  {
+    id: 'kimi-for-coding-highspeed',
+    name: 'Kimi for Coding High Speed',
+    contextWindow: 262144,
+    maxTokens: 32000,
+    inputModalities: ['text', 'image'],
+  },
+  {
+    id: 'k3',
+    name: 'Kimi K3 (Fast)',
+    contextWindow: 131072,
+    maxTokens: 16384,
+    inputModalities: ['text'],
+  },
+]
+
+export function providerInfo() {
+  return { id, name: 'Moonshot Kimi' }
+}
+
+export function defaults() {
+  return {
+    clientId: KIMI_CLIENT_ID,
+    deviceUrl: KIMI_DEVICE_URL,
+    tokenUrl: KIMI_TOKEN_URL,
+    apiBase: KIMI_API_BASE,
+    models: KIMI_MODELS.map((m) => m.id),
+  }
+}
+
+export function authorizeUrl() {
+  return 'https://auth.kimi.com/device'
+}
+
+export async function listModels() {
+  return KIMI_MODELS
+}
+
+export async function usage(blob, config, fetchImpl) {
+  try {
+    const impl = fetchImpl || fetch
+    const base = (config && config.apiBase) || KIMI_API_BASE
+    const token = blob && (blob.accessToken || blob.access_token)
+    if (!token) return null
+    const res = await impl(`${base}/usages`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: 'application/json',
+      },
+    })
+    if (!res.ok) return null
+    const json = await readJson(res)
+    // Kimi usages returns remaining fraction or total/used
+    if (json && json.usage_percent != null) return asUsageSnapshot(json.usage_percent)
+    if (json && json.used != null && json.total != null && json.total > 0) {
+      return asUsageSnapshot(Math.round((json.used / json.total) * 100))
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+  const impl = fetchImpl || fetch
+  const base = (config && config.apiBase) || KIMI_API_BASE
+  const token = blob && (blob.accessToken || blob.access_token)
+  if (!token) throw new LlmError('Kimi not authenticated', 'AUTH')
+
+  const body = {
+    model: options.model || 'kimi-for-coding',
+    messages: openaiMessages(options),
+    stream: true,
+    ...(options.maxTokens != null ? { max_tokens: options.maxTokens } : {}),
+    ...(options.temperature != null ? { temperature: options.temperature } : {}),
+  }
+
+  if (options.reasoningEffort && options.reasoningEffort !== 'off') {
+    body.thinking = { effort: options.reasoningEffort }
+  }
+
+  const tools = openaiTools(options)
+  if (tools && tools.length) body.tools = tools
+
+  const res = await impl(`${base}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+      'User-Agent': 'dsh-plugin-oauth-subs',
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+
+  if (!res.ok) throw httpError(res.status, await res.text())
+  yield* openaiChatStream(res.body)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.4.23",
+  "version": "0.5.0",
   "description": "Use ChatGPT Codex, Claude, Grok, and Antigravity subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",