@goodandready/dsh-subscriptions 0.7.45 → 0.7.47

package/lib/antigravity-reasoning.js

@@ -0,0 +1,80 @@
+const FAMILIES = [
+  { re: /claude/i, budget: 1024, effort: 'high', levels: ['low', 'medium', 'high'] },
+  { re: /gpt-oss/i, budget: 8192, effort: 'medium', levels: ['low', 'medium', 'high'] },
+  { re: /gemini-3\./i, budgets: { low: 1024, medium: 8192, high: 24576 }, effort: 'medium', levels: ['low', 'medium', 'high'] },
+]
+
+function familyFor(model) {
+  return FAMILIES.find((family) => family.re.test(String(model || ''))) || null
+}
+
+function codedError(message, code) {
+  /** @type {Error & { code?: string }} */
+  const err = new Error(message)
+  err.code = code
+  return err
+}
+
+/** #826: family-specific Antigravity reasoning budget with explicit errors. */
+export function antigravityReasoning(model, effort, maxTokens) {
+  const family = familyFor(model)
+  if (!family) return { supported: false, thinkingBudget: null, effort: null, maxTokens }
+  const requested = String(effort || family.effort).toLowerCase()
+  if (!family.levels.includes(requested)) {
+    throw codedError('unsupported reasoning effort for ' + model + ': ' + requested, 'UNSUPPORTED_REASONING_EFFORT')
+  }
+  const thinkingBudget = family.budgets ? family.budgets[requested] : family.budget
+  if (maxTokens != null && Number(maxTokens) <= thinkingBudget) {
+    throw codedError('maxTokens must exceed thinking budget', 'UNSUPPORTED_REASONING_EFFORT')
+  }
+  return { supported: true, thinkingBudget, effort: requested, maxTokens }
+}
+
+function deref(schema, root, seen) {
+  if (!schema || typeof schema !== 'object') return schema
+  if (typeof schema.$ref === 'string') {
+    const ref = schema.$ref
+    if (!ref.startsWith('#/')) {
+      throw codedError('remote $ref is not supported', 'UNSUPPORTED_TOOL_SCHEMA')
+    }
+    if (seen.has(ref)) {
+      throw codedError('cyclic $ref is not supported', 'UNSUPPORTED_TOOL_SCHEMA')
+    }
+    const path = ref.slice(2).split('/').map((part) => part.replace(/~1/g, '/').replace(/~0/g, '~'))
+    let target = root
+    for (const key of path) target = target && target[key]
+    if (!target) {
+      throw codedError('missing local $ref: ' + ref, 'UNSUPPORTED_TOOL_SCHEMA')
+    }
+    return deref(target, root, new Set([...seen, ref]))
+  }
+  return schema
+}
+
+function strip(schema, root, seen) {
+  if (Array.isArray(schema)) return schema.map((item) => strip(item, root, seen))
+  if (!schema || typeof schema !== 'object') return schema
+  const resolved = deref(schema, root, seen)
+  if (resolved !== schema) return strip(resolved, root, seen)
+  const out = {}
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === '$schema' || key === '$id' || key === '$defs' || key === 'definitions') continue
+    out[key] = strip(value, root, seen)
+  }
+  if (Array.isArray(out.anyOf)) {
+    const variants = out.anyOf.filter((v) => v && typeof v === 'object')
+    if (variants.length === 1) return variants[0]
+    if (variants.every((v) => v.type === variants[0].type)) out.type = variants[0].type
+  }
+  if (Array.isArray(out.oneOf)) {
+    const variants = out.oneOf.filter((v) => v && typeof v === 'object')
+    if (variants.length === 1) return variants[0]
+    if (variants.every((v) => v.type === variants[0].type)) out.type = variants[0].type
+  }
+  return out
+}
+
+/** #826: expand local refs, reject cycles/remote refs, strip metadata, widen unions. */
+export function normalizeAntigravityToolSchema(schema) {
+  return strip(schema, schema, new Set())
+}

package/lib/claude-keychain.js

@@ -0,0 +1,49 @@
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+const SERVICE = 'Claude Code-credentials'
+
+export function validClaudeBlob(blob) {
+  if (!blob || typeof blob !== 'object') return false
+  if (typeof blob.accessToken !== 'string' || !blob.accessToken) return false
+  if (typeof blob.refreshToken !== 'string' || !blob.refreshToken) return false
+  return Number.isFinite(Number(blob.expiresAt))
+}
+
+export function mergeClaudeCredentials(current, cli) {
+  if (!validClaudeBlob(current)) return validClaudeBlob(cli) ? { ...cli } : null
+  if (!validClaudeBlob(cli)) return { ...current }
+  const currentExpiry = Number(current.expiresAt) || 0
+  const cliExpiry = Number(cli.expiresAt) || 0
+  if (cli.accessToken && cli.accessToken !== current.accessToken && cliExpiry > currentExpiry) {
+    return { ...current, ...cli }
+  }
+  return { ...current }
+}
+
+export function canWriteClaudeKeychain(currentBlob, expectedAccessToken) {
+  return Boolean(currentBlob && expectedAccessToken && currentBlob.accessToken === expectedAccessToken)
+}
+
+/** macOS-only read; returns null on any failure so accounts stay usable. */
+export async function readClaudeKeychain({ exec = execFileAsync, service = SERVICE } = {}) {
+  if (process.platform !== 'darwin') return null
+  try {
+    const { stdout } = await exec('/usr/bin/security', ['find-generic-password', '-s', service, '-w'])
+    const blob = JSON.parse(String(stdout || '').trim())
+    return validClaudeBlob(blob) ? blob : null
+  } catch { return null }
+}
+
+/** Write back only when the stored blob still owns the expected old access token. */
+export async function writeClaudeKeychain(blob, expectedAccessToken, { exec = execFileAsync, service = SERVICE, account = 'claude' } = {}) {
+  if (process.platform !== 'darwin') return false
+  if (!validClaudeBlob(blob) || !expectedAccessToken) return false
+  const current = await readClaudeKeychain({ exec, service })
+  if (!canWriteClaudeKeychain(current, expectedAccessToken)) return false
+  try {
+    await exec('/usr/bin/security', ['add-generic-password', '-U', '-s', service, '-a', account, '-w', JSON.stringify(blob)])
+    return true
+  } catch { return false }
+}

package/lib/client.js

@@ -300,6 +300,10 @@ window.__ModuleLoader__.load({
       "discovered": "discovered",
       "shown": "shown",
       "searchModels": "Search models by name or id",
+      "compact": "Compact",
+      "heatmap": "Heatmap · last 24h",
+      "editModels": "Edit models",
+      "hidden": "hidden",
       "tabRouting": "Routing",
       "tabModels": "Models",
       "tabVault": "Vault",
@@ -725,6 +729,10 @@ window.__ModuleLoader__.load({
       "discovered": "已发现",
       "shown": "已显示",
       "searchModels": "按名称或 ID 搜索模型",
+      "compact": "紧凑模式",
+      "heatmap": "热力图 · 最近 24 小时",
+      "editModels": "编辑模型",
+      "hidden": "隐藏",
       "tabRouting": "路由",
       "tabModels": "模型",
       "tabVault": "Vault",

package/lib/client.panels.js

@@ -191,16 +191,39 @@ window.__ModuleLoader__.load({
       const [sort, setSort] = React.useState('risk')
       const [usage, setUsage] = React.useState({})
       const [speed, setSpeed] = React.useState('standard')
+      const [analytics, setAnalytics] = React.useState(null)
+      const [compact, setCompact] = React.useState(false)
+      const [editing, setEditing] = React.useState(false)
+      const [draft, setDraft] = React.useState({})
       const usageRef = React.useRef({ inflight: {}, gen: {} })
       const pull = () => fetch('/dsh-subscriptions/config', { cache: 'no-store' })
         .then((res) => res.json())
         .then((cfg) => {
           setData(cfg)
           setSpeed((cfg.config && cfg.config.codexSubagentSpeed) || 'standard')
+          setDraft(JSON.parse(JSON.stringify((cfg.config && cfg.config.modelOverrides) || {})))
           if (!provider && cfg.accounts && cfg.accounts.length) setProvider(cfg.accounts[0].provider)
         })
         .catch(() => {})
-      React.useEffect(() => { pull() }, [])
+      React.useEffect(() => {
+        pull()
+        fetch('/dsh-subscriptions/analytics', { cache: 'no-store' })
+          .then((res) => res.json())
+          .then((out) => setAnalytics((out && out.analytics) || null))
+          .catch(() => {})
+      }, [])
+      const saveOverrides = () => {
+        if (!data || !data.config) return
+        fetch('/dsh-subscriptions/config', {
+          method: 'PUT',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ config: Object.assign({}, data.config, { modelOverrides: draft }), revision: data.revision }),
+        }).then(() => { setEditing(false); pull() }).catch(() => {})
+      }
+      const cancelOverrides = () => {
+        setDraft(JSON.parse(JSON.stringify((data && data.config && data.config.modelOverrides) || {})))
+        setEditing(false)
+      }
       const loadUsage = (row) => {
         const key = row.provider + ':' + row.index
         if (usageRef.current.inflight[key]) return
@@ -264,10 +287,53 @@ window.__ModuleLoader__.load({
               u && u.value ? h('span', { className: 'dsub-dim' }, JSON.stringify(u.value).slice(0, 180)) : null),
           )
         }),
-        h('div', { className: 'dsub-h' }, t('modelEditor') + ' · ' + t('discovered') + ' ' + models.length + ' · ' + t('shown') + ' ' + shown.length),
+        h('div', { className: 'dsub-row' },
+          h('label', { className: 'dsub-sub' }, h('input', { type: 'checkbox', checked: compact, onChange: (e) => setCompact(e.target.checked) }), ' ' + t('compact')),
+        ),
+        h('div', { className: 'dsub-h' }, t('heatmap')),
+        h('div', { className: 'dsub-row', style: { gap: 2 } },
+          ((analytics && analytics.hourly) || []).slice(-24).map((hour, i) => h('span', {
+            key: i,
+            title: (hour && hour.requests || 0) + ' req',
+            style: { display: 'inline-block', width: 8, height: 18, background: 'rgba(88,166,255,' + Math.min(1, ((hour && hour.requests) || 0) / 10 + 0.1) + ')' },
+          }))),
+        h('div', { className: 'dsub-row' },
+          h('span', { className: 'dsub-h' }, t('modelEditor') + ' · ' + t('discovered') + ' ' + models.length + ' · ' + t('shown') + ' ' + shown.length),
+          h('button', { type: 'button', className: 'dsub-mini', onClick: () => setEditing(!editing) }, t('editModels')),
+          editing ? h('button', { type: 'button', className: 'dsub-mini', onClick: saveOverrides }, t('save')) : null,
+          editing ? h('button', { type: 'button', className: 'dsub-mini', onClick: cancelOverrides }, t('cancel')) : null,
+        ),
         h('input', { className: 'dsub-grow', value: query, placeholder: t('searchModels'), onChange: (e) => setQuery(e.target.value) }),
         shown.slice(0, 40).map((m) => h('div', { key: m.id, className: 'dsub-row' },
-          h('span', { className: 'dsub-h' }, m.independent ? '★ ' : ''), h('span', { className: 'dsub-sub' }, m.name || m.id), h('span', { className: 'dsub-dim' }, m.id))),
+          h('span', { className: 'dsub-h' }, m.independent ? '★ ' : ''),
+          editing
+            ? h('input', {
+              className: 'dsub-grow',
+              value: (draft[m.id] && draft[m.id].name) || '',
+              placeholder: m.name || m.id,
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { [m.id]: Object.assign({}, d[m.id], { name: e.target.value }) })),
+            })
+            : h('span', { className: 'dsub-sub' }, (draft[m.id] && draft[m.id].name) || m.name || m.id),
+          editing ? h('input', {
+            type: 'number',
+            className: 'dsub-inp',
+            style: { width: '90px', minWidth: '90px' },
+            value: (draft[m.id] && draft[m.id].contextWindow) || '',
+            placeholder: 'ctx',
+            onChange: (e) => setDraft((d) => Object.assign({}, d, { [m.id]: Object.assign({}, d[m.id], { contextWindow: Number(e.target.value) || undefined }) })),
+          }) : null,
+          editing ? h('select', {
+            className: 'dsub-select',
+            value: (draft[m.id] && draft[m.id].reasoningEffort) || '',
+            onChange: (e) => setDraft((d) => Object.assign({}, d, { [m.id]: Object.assign({}, d[m.id], { reasoningEffort: e.target.value || undefined }) })),
+          }, ['', 'low', 'medium', 'high'].map((level) => h('option', { key: level || 'default', value: level }, level || 'effort'))) : null,
+          editing ? h('label', { className: 'dsub-dim' },
+            h('input', {
+              type: 'checkbox',
+              checked: !!(draft[m.id] && draft[m.id].hidden),
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { [m.id]: Object.assign({}, d[m.id], { hidden: e.target.checked }) })),
+            }), ' ' + t('hidden')) : null,
+          h('span', { className: 'dsub-dim' }, m.id))),
       )
     }
 

package/lib/config-schema.js

@@ -171,6 +171,8 @@ export const Config = z.object({
     .description('#788 Per-provider model glob rules. First match wins; account may be a ref, label or index.'),
   tiers: z.array(z.any()).volatile().default([])
     .description('#817 Named picker tiers: { id, name, members: [accountRef] }. No cross-tier fallback.'),
+  modelOverrides: z.any().volatile().default({})
+    .description('#807 Per-model editor overrides: display name, hidden, context window, default reasoning effort.'),
   rotationStrategy: z.string().volatile().default('round-robin')
     .description('Load balancing strategy among available accounts: round-robin (balanced), least-loaded (fair-share quota), quota-aware (urgent quota first), or priority (sequential).'),
   poolEnabled: z.boolean().volatile().default(true)

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 { readClaudeKeychain } from './claude-keychain.js'
 import { readCopilotCredentials } from './vendors/copilot-cli.js'
 import { normalizeExpiresAt } from './blob.js'
 import { isGoogleClientId, extractGoogleClientIdFromJwt, emailFromToken } from './jwt.js'
@@ -250,11 +251,17 @@ async function discoverLocalCliSessionsInner() {
   }
 
   // 8. Claude CLI Direct Import
-  const claudeCreds = await readClaudeCredentials(activeHome)
+  const fileCreds = await readClaudeCredentials(activeHome)
+  const keychainCreds = fileCreds ? null : await readClaudeKeychain()
+  const claudeCreds = fileCreds || (keychainCreds ? {
+    ...keychainCreds,
+    sourcePath: 'macOS Keychain (Claude Code-credentials)',
+    email: keychainCreds.email || '',
+  } : null)
   if (claudeCreds) {
     const claudeEntry = {
       provider: 'claude',
-      source: 'file',
+      source: fileCreds ? 'file' : 'keychain',
       path: claudeCreds.sourcePath || homeFile('.claude', '.credentials.json'),
       email: claudeCreds.email || 'Claude Code CLI User',
       hasRefreshToken: !!claudeCreds.refreshToken,

package/lib/media-reference.js

@@ -0,0 +1,38 @@
+export const MAX_REFERENCE_IMAGES = 5
+
+/** #801: validate attachment refs before any generation call. */
+export function validateReferenceImages(refs) {
+  if (refs == null) return { ok: true, refs: [] }
+  if (!Array.isArray(refs)) {
+    return { ok: false, error: 'referenceImages must be an array' }
+  }
+  const clean = refs.map((ref) => String(ref || '').trim()).filter(Boolean)
+  if (!clean.length) return { ok: false, error: 'referenceImages must not be empty' }
+  if (clean.length > MAX_REFERENCE_IMAGES) return { ok: false, error: 'at most 5 reference images are allowed' }
+  if (new Set(clean).size !== clean.length) return { ok: false, error: 'duplicate reference images are not allowed' }
+  return { ok: true, refs: clean }
+}
+
+/** #801: provider-specific image-edit request bodies. */
+export function referenceImageRequest(provider, { prompt, references = [], model, size } = {}) {
+  const checked = validateReferenceImages(references)
+  if (!checked.ok) {
+    const err = new Error(checked.error)
+    err.code = 'INVALID_MEDIA_REFERENCE'
+    throw err
+  }
+  if (provider === 'grok') {
+    return {
+      model: model || 'grok-2-image',
+      prompt,
+      image_urls: checked.refs,
+      ...(size ? { size } : {}),
+    }
+  }
+  return {
+    model: model || 'gpt-image-1',
+    prompt,
+    images: checked.refs.map((ref) => ({ image_url: ref })),
+    ...(size ? { size } : {}),
+  }
+}

package/lib/vendors/antigravity.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto'
 import { buildAuthorizeUrl } from '../oauth.js'
 import { googleContents } from '../messages.js'
+import { antigravityReasoning, normalizeAntigravityToolSchema } from '../antigravity-reasoning.js'
 import { formTokenRequest, googleStream, throwHttpError, tokenBlobFromOAuth , readErrorBody } from '../wire.js'
 import { fetchWithTimeout } from '../http.js'
 import { emailFromToken, avatarFromToken, scopesFromToken } from '../jwt.js'
@@ -221,6 +222,17 @@ export async function* streamOnce({ blob, options, fetchImpl, headers, signal, s
       if (tiered) {
         if (!request.generationConfig) request.generationConfig = {}
         request.generationConfig.thinkingConfig = /** @type {any} */ ({ thinkingLevel: tiered.thinkingLevel })
+      } else {
+        const reasoning = antigravityReasoning(options.model, options.reasoningEffort, options.maxTokens)
+        if (reasoning.supported) {
+          if (!request.generationConfig) request.generationConfig = {}
+          request.generationConfig.thinkingConfig = /** @type {any} */ ({ thinkingBudget: reasoning.thinkingBudget })
+        }
+      }
+      for (const declaration of (request.tools && request.tools[0] && request.tools[0].functionDeclarations) || []) {
+        if (declaration && declaration.parameters) {
+          declaration.parameters = normalizeAntigravityToolSchema(declaration.parameters)
+        }
       }
       const { envelope, sessionId } = streamEnvelope({
         projectId: ready.projectId,

package/package.json

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