@goodandready/dsh-subscriptions 0.1.0

package/lib/vendors/grok.js

@@ -0,0 +1,223 @@
+import { buildAuthorizeUrl } from '../oauth.js'
+import { modelCatalog, codexResponsesBody } from '../messages.js'
+import { formTokenRequest, codexResponsesStream, httpError, tokenBlobFromOAuth, readJson } from '../wire.js'
+import { emailFromToken } from '../jwt.js'
+import { asUsageSnapshot, grokBillingPercent } from '../usage.js'
+
+export const id = 'grok'
+
+const AUTH = 'https://auth.x.ai/oauth2/authorize'
+const TOKEN = 'https://auth.x.ai/oauth2/token'
+const SCOPE = 'openid profile email offline_access grok-cli:access api:access conversations:read conversations:write'
+const BILLING = 'https://cli-chat-proxy.grok.com/v1/billing?format=credits'
+const MODELS = 'https://api.x.ai/v1/models'
+const CLI_MODELS = 'https://cli-chat-proxy.grok.com/v1/models'
+const CATALOG_TTL_MS = 5 * 60 * 1000
+const catalogCache = new Map()
+
+async function cliCatalogCached(blob, cfg, fetchImpl) {
+  const key = String(blob.accessToken || '').slice(-24)
+  const hit = catalogCache.get(key)
+  if (hit && Date.now() - hit.at < CATALOG_TTL_MS) return hit.map
+  const map = await cliCatalog(blob, cfg, fetchImpl)
+  if (map.size > 0) catalogCache.set(key, { at: Date.now(), map })
+  return map
+}
+
+function grokReasoningBody(modelId, effort, catalogMap) {
+  const entry = catalogMap && catalogMap.get(modelId)
+  const reasoning = entry && entry.reasoning
+  if (!reasoning || !reasoning.efforts || !reasoning.efforts.length) return undefined
+  const allowed = new Set(reasoning.efforts.map((row) => row.id))
+  const pick = effort != null && effort !== '' ? String(effort) : ''
+  if (pick && allowed.has(pick)) return { effort: pick }
+  return undefined
+}
+
+function grokBodyForModel(modelId, body) {
+  if (!/multi-agent/i.test(String(modelId || ''))) return body
+  const next = { ...body }
+  delete next.tools
+  return next
+}
+
+
+export function providerInfo() {
+  return { id, name: 'Grok' }
+}
+
+export function defaults() {
+  return {
+    clientId: 'b1a00492-073a-47ea-816f-4c329264a828',
+    redirectUri: 'http://127.0.0.1:56121/callback',
+    baseUrl: 'https://api.x.ai/v1',
+    clientVersion: '0.2.103',
+    models: [
+      { id: 'grok-4', name: 'Grok 4' },
+      { id: 'grok-4-fast-reasoning', name: 'Grok 4 Fast Reasoning' },
+      { id: 'grok-code-fast-1', name: 'Grok Code Fast 1' },
+    ],
+  }
+}
+
+function isChatModel(modelId) {
+  return !/imagine|image-|video|embed/i.test(String(modelId || ''))
+}
+
+function grokModalities(modelId) {
+  return /code|embed/i.test(String(modelId || '')) ? ['text'] : ['text', 'image']
+}
+
+function identityHeaders(blob, config) {
+  return {
+    Authorization: `Bearer ${blob.accessToken}`,
+    'X-XAI-Token-Auth': 'xai-grok-cli',
+    'x-grok-client-identifier': 'grok-shell',
+    'x-grok-client-version': config.clientVersion || defaults().clientVersion,
+    'User-Agent': 'xai-grok-cli',
+  }
+}
+
+function streamHeaders(blob, config, extra) {
+  const base = String(config.baseUrl || defaults().baseUrl)
+  const headers = {
+    Authorization: `Bearer ${blob.accessToken}`,
+    ...(extra || {}),
+  }
+  if (/grok\.com/i.test(base)) Object.assign(headers, identityHeaders(blob, config))
+  return headers
+}
+
+export function authorizeUrl(cfg, pkce) {
+  return buildAuthorizeUrl({
+    authUrl: AUTH,
+    clientId: cfg.clientId,
+    redirectUri: cfg.redirectUri,
+    challenge: pkce.challenge,
+    state: pkce.state,
+    scope: SCOPE,
+  })
+}
+
+export async function exchangeCode(cfg, pkce, code, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    grant_type: 'authorization_code',
+    client_id: cfg.clientId,
+    code,
+    redirect_uri: cfg.redirectUri,
+    code_verifier: pkce.verifier,
+  }, fetchImpl)
+  const blob = tokenBlobFromOAuth(json)
+  return { ...blob, email: blob.email || emailFromToken(blob.accessToken), label: blob.label || 'Grok' }
+}
+
+export async function refresh(cfg, blob, fetchImpl) {
+  const json = await formTokenRequest(TOKEN, {
+    grant_type: 'refresh_token',
+    client_id: cfg.clientId,
+    refresh_token: blob.refreshToken,
+  }, fetchImpl)
+  return tokenBlobFromOAuth(json, { label: blob.label, email: blob.email })
+}
+
+async function cliCatalog(blob, cfg, fetchImpl) {
+  const res = await fetchImpl(CLI_MODELS, {
+    headers: { ...identityHeaders(blob, cfg), Accept: 'application/json' },
+  })
+  const json = await readJson(res)
+  const map = new Map()
+  for (const entry of json.data || []) {
+    if (!entry || !entry.id) continue
+    const efforts = (entry.reasoning_efforts || [])
+      .map((level) => (typeof level === 'string' ? { id: level, name: level } : (level && level.value && {
+        id: level.value,
+        name: level.label || level.value,
+      })))
+      .filter(Boolean)
+    const reasoning = entry.supports_reasoning_effort === true && efforts.length
+      ? {
+        efforts,
+        ...(entry.reasoning_effort && efforts.some((row) => row.id === entry.reasoning_effort)
+          ? { defaultEffort: entry.reasoning_effort }
+          : {}),
+      }
+      : undefined
+    map.set(entry.id, {
+      name: entry.name || entry.id,
+      ...(entry.description ? { description: entry.description } : {}),
+      ...(entry.context_window ? { contextWindow: entry.context_window } : {}),
+      ...(reasoning ? { reasoning } : {}),
+    })
+  }
+  return map
+}
+
+export async function listModels(blob, cfg, fetchImpl) {
+  const fallback = modelCatalog(id, (cfg.models || defaults().models).map((row) => (
+    typeof row === 'string' ? row : { ...row, inputModalities: grokModalities(row.id) }
+  )))
+  const impl = fetchImpl || fetch
+  try {
+    const [res, extra] = await Promise.all([
+      impl(MODELS, { headers: { Authorization: `Bearer ${blob.accessToken}`, Accept: 'application/json' } }),
+      cliCatalog(blob, cfg, impl).catch(() => new Map()),
+    ])
+    const json = await readJson(res)
+    const rows = []
+    for (const entry of json.data || []) {
+      const modelId = entry && entry.id
+      if (!modelId || !isChatModel(modelId)) continue
+      const enrich = extra.get(modelId) || {}
+      const note = /multi-agent/i.test(modelId)
+        ? 'Chat only in Harness until xAI grants multi-agent tool beta.'
+        : ''
+      rows.push({
+        id: modelId,
+        name: enrich.name || modelId,
+        inputModalities: grokModalities(modelId),
+        ...enrich,
+        ...(note ? { description: enrich.description ? `${enrich.description} ${note}` : note } : {}),
+      })
+    }
+    if (!rows.length) throw new Error('empty grok catalog')
+    return modelCatalog(id, rows)
+  } catch {
+    return fallback
+  }
+}
+
+export async function usage(blob, cfg, fetchImpl) {
+  try {
+    const res = await (fetchImpl || fetch)(BILLING, {
+      headers: { ...identityHeaders(blob, cfg), Accept: 'application/json' },
+    })
+    const json = await readJson(res)
+    return asUsageSnapshot(grokBillingPercent(json))
+  } catch {
+    return null
+  }
+}
+
+export async function* streamOnce({ blob, options, fetchImpl, headers, config, signal }) {
+  const base = (config.baseUrl || defaults().baseUrl).replace(/\/$/, '')
+  let body = codexResponsesBody(options, '')
+  if (!body.instructions) delete body.instructions
+  const catalog = await cliCatalogCached(blob, config, fetchImpl).catch(() => new Map())
+  const reasoning = grokReasoningBody(options.model, options.reasoningEffort, catalog)
+  if (reasoning) body.reasoning = reasoning
+  body = grokBodyForModel(options.model, body)
+  const res = await fetchImpl(`${base}/responses`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      ...streamHeaders(blob, config, {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+      }),
+    },
+    body: JSON.stringify(body),
+    signal,
+  })
+  if (!res.ok) throw httpError(res.status, await res.text())
+  yield* codexResponsesStream(res.body)
+}

package/lib/vendors/index.js

@@ -0,0 +1,17 @@
+import * as codex from './codex.js'
+import * as claude from './claude.js'
+import * as grok from './grok.js'
+import * as antigravity from './antigravity.js'
+
+export const vendors = {
+  codex,
+  claude,
+  grok,
+  antigravity,
+}
+
+export function getVendor(provider) {
+  const vendor = vendors[provider]
+  if (!vendor) throw new Error(`unknown provider: ${provider}`)
+  return vendor
+}

package/lib/wire.js

@@ -0,0 +1,200 @@
+import { iterateSse, jsonSse } from './sse.js'
+import { validationFromHttpError, validationRequiredError, googleRateLimitMessage } from './google-validation.js'
+
+export function httpError(status, bodyText, code) {
+  const snippet = String(bodyText || '').slice(0, 400)
+  const err = new Error(snippet ? `vendor http ${status}: ${snippet}` : `vendor http ${status}`)
+  err.status = status
+  if (code) {
+    err.code = code
+    return err
+  }
+  if (status === 429) err.code = 'RATE_LIMIT'
+  else if (status === 402) err.code = 'QUOTA'
+  else if (status === 401 || status === 403) err.code = 'VENDOR'
+  else if (/quota|rate.?limit|usage.?limit|billing/i.test(snippet)) {
+    err.code = status === 400 ? 'QUOTA' : 'RATE_LIMIT'
+  } else err.code = 'VENDOR'
+  return err
+}
+
+export function throwHttpError(status, bodyText) {
+  const validation = validationFromHttpError(status, bodyText)
+  if (validation) throw validationRequiredError(validation)
+  const hint = googleRateLimitMessage(status, bodyText)
+  if (hint) {
+    const err = httpError(status, bodyText, status === 429 ? 'RATE_LIMIT' : undefined)
+    err.message = `${hint} (${err.message})`
+    throw err
+  }
+  throw httpError(status, bodyText)
+}
+
+export async function readJson(res) {
+  const text = await res.text()
+  if (!res.ok) {
+    const validation = validationFromHttpError(res.status, text)
+    if (validation) throw validationRequiredError(validation)
+    throw httpError(res.status, text)
+  }
+  try { return JSON.parse(text) } catch { return {} }
+}
+
+export function tokenBlobFromOAuth(json, extra) {
+  const expiresIn = Number(json.expires_in) || 3600
+  return {
+    accessToken: json.access_token || json.accessToken || '',
+    refreshToken: json.refresh_token || json.refreshToken || '',
+    expiresAt: Date.now() + expiresIn * 1000,
+    idToken: json.id_token || json.idToken || '',
+    ...(extra || {}),
+  }
+}
+
+function openBlock(kind, index) {
+  return { kind, index, text: '', id: '', name: '' }
+}
+
+export async function* openaiChatStream(body) {
+  let next = 0
+  let textBlock = null
+  const tools = new Map()
+  let finish = { kind: 'stop' }
+  for await (const data of iterateSse(body)) {
+    const json = jsonSse(data)
+    if (!json) continue
+    const choice = (json.choices && json.choices[0]) || {}
+    const delta = choice.delta || json.delta || {}
+    if (typeof delta.content === 'string' && delta.content) {
+      if (!textBlock) {
+        textBlock = openBlock('text', next++)
+        yield { type: 'block-start', index: textBlock.index, blockType: 'text' }
+      }
+      yield { type: 'text-delta', index: textBlock.index, text: delta.content }
+    }
+    if (typeof delta.reasoning_content === 'string' && delta.reasoning_content) {
+      yield { type: 'reasoning-delta', index: 0, text: delta.reasoning_content }
+    }
+    for (const call of delta.tool_calls || []) {
+      let block = tools.get(call.index)
+      if (!block) {
+        block = openBlock('tool-call', next++)
+        tools.set(call.index, block)
+        yield { type: 'block-start', index: block.index, blockType: 'tool-call' }
+      }
+      if (call.id) block.id = call.id
+      if (call.function && call.function.name) block.name = call.function.name
+      const fragment = (call.function && call.function.arguments) || ''
+      yield {
+        type: 'tool-call-delta',
+        index: block.index,
+        id: block.id,
+        ...(block.name ? { name: block.name } : {}),
+        argumentsDelta: fragment,
+      }
+    }
+    if (json.usage) yield { type: 'usage', usage: json.usage }
+    if (choice.finish_reason === 'length') finish = { kind: 'length' }
+    else if (choice.finish_reason === 'tool_calls') finish = { kind: 'tool' }
+  }
+  yield { type: 'finish', reason: finish }
+}
+
+export { streamResponses as codexResponsesStream } from './responses-stream.js'
+
+export async function* anthropicStream(body) {
+  let index = 0
+  let textIndex = 0
+  for await (const data of iterateSse(body)) {
+    const json = jsonSse(data)
+    if (!json) continue
+    if (json.type === 'content_block_start') {
+      const block = json.content_block || {}
+      if (block.type === 'text') {
+        textIndex = json.index || index++
+        yield { type: 'block-start', index: textIndex, blockType: 'text' }
+      } else if (block.type === 'tool_use') {
+        yield { type: 'block-start', index: json.index || index++, blockType: 'tool-call' }
+        yield {
+          type: 'tool-call-delta',
+          index: json.index || 0,
+          id: block.id,
+          name: block.name,
+          argumentsDelta: '',
+        }
+      }
+    } else if (json.type === 'content_block_delta') {
+      const delta = json.delta || {}
+      if (delta.type === 'text_delta' && delta.text) {
+        yield { type: 'text-delta', index: json.index || textIndex, text: delta.text }
+      } else if (delta.type === 'input_json_delta' && delta.partial_json) {
+        yield {
+          type: 'tool-call-delta',
+          index: json.index || 0,
+          argumentsDelta: delta.partial_json,
+        }
+      }
+    } else if (json.type === 'message_delta' && json.usage) {
+      yield { type: 'usage', usage: json.usage }
+    }
+  }
+  yield { type: 'finish', reason: { kind: 'stop' } }
+}
+
+export async function* googleStream(body) {
+  let index = 0
+  let started = false
+  for await (const data of iterateSse(body)) {
+    const json = jsonSse(data)
+    const wrapped = json && json.response ? json.response : json
+    if (!wrapped) continue
+    const cand = wrapped.candidates && wrapped.candidates[0]
+    const parts = cand && cand.content && Array.isArray(cand.content.parts) ? cand.content.parts : []
+    for (const part of parts) {
+      if (part.text) {
+        if (!started) {
+          yield { type: 'block-start', index, blockType: 'text' }
+          started = true
+        }
+        yield { type: 'text-delta', index, text: part.text }
+      }
+      if (part.functionCall) {
+        yield { type: 'block-start', index: index + 1, blockType: 'tool-call' }
+        yield {
+          type: 'tool-call-delta',
+          index: index + 1,
+          name: part.functionCall.name,
+          argumentsDelta: JSON.stringify(part.functionCall.args || {}),
+        }
+      }
+    }
+    if (wrapped.usageMetadata) {
+      yield {
+        type: 'usage',
+        usage: {
+          input: wrapped.usageMetadata.promptTokenCount,
+          output: wrapped.usageMetadata.candidatesTokenCount,
+        },
+      }
+    }
+  }
+  yield { type: 'finish', reason: { kind: 'stop' } }
+}
+
+export async function formTokenRequest(url, params, fetchImpl, headers) {
+  const res = await fetchImpl(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', Accept: 'application/json', ...(headers || {}) },
+    body: new URLSearchParams(params),
+  })
+  return readJson(res)
+}
+
+export async function jsonTokenRequest(url, body, fetchImpl, headers) {
+  const res = await fetchImpl(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Accept: 'application/json', ...(headers || {}) },
+    body: JSON.stringify(body),
+  })
+  return readJson(res)
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@goodandready/dsh-subscriptions",
+  "version": "0.1.0",
+  "description": "Use ChatGPT Codex, Claude, Grok, and Antigravity subscriptions as DeepSeek Harness LLM providers via OAuth.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "oauth",
+    "chatgpt",
+    "claude",
+    "grok"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GooDAnDReaDY/dsh-subscriptions.git"
+  },
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-subscriptions",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-subscriptions/issues"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}