@goodandready/dsh-subscriptions 0.1.0

package/lib/client.js

@@ -0,0 +1,248 @@
+window.__ModuleLoader__.load({
+  id: '@goodandready/dsh-subscriptions',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    const React = require('react')
+
+    const CSS =
+      '.dsub-wrap{display:flex;flex-direction:column;gap:22px;padding:4px 0;max-width:760px}' +
+      '.dsub-block{display:flex;flex-direction:column;gap:10px}' +
+      '.dsub-h{font-size:14px;font-weight:600;color:var(--dsw-alias-label-primary)}' +
+      '.dsub-sub{font-size:12px;color:var(--dsw-alias-label-secondary)}' +
+      '.dsub-card{display:flex;flex-direction:column;gap:8px;padding:10px;border:1px solid var(--dsw-alias-border-l2);border-radius:8px}' +
+      '.dsub-row{display:flex;gap:8px;align-items:center;flex-wrap:wrap}' +
+      '.dsub-row input,.dsub-field input,.dsub-row select{background:var(--dsw-alias-bg-layer-1);border:1px solid var(--dsw-alias-border-l1);color:var(--dsw-alias-label-primary);border-radius:6px;padding:6px 8px;font-size:13px}' +
+      '.dsub-grow{flex:1;min-width:180px}' +
+      '.dsub-field{display:flex;flex-direction:column;gap:4px;font-size:12px;color:var(--dsw-alias-label-secondary)}' +
+      '.dsub-mini{border:1px solid var(--dsw-alias-border-l2);background:transparent;color:var(--dsw-alias-label-primary);border-radius:6px;height:28px;padding:0 8px;cursor:pointer}' +
+      '.dsub-save{background:var(--dsw-alias-brand-primary);color:#fff;border:none;border-radius:6px;padding:7px 14px;font-size:13px;cursor:pointer}' +
+      '.dsub-ok{font-size:12px;color:var(--dsw-alias-state-success-primary)}' +
+      '.dsub-bad{font-size:12px;color:var(--dsw-alias-state-error-primary)}' +
+      '.dsub-badge{font-size:11px;padding:2px 8px;border-radius:999px;border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-secondary);white-space:nowrap}' +
+      '.dsub-badge-on{color:var(--dsw-alias-state-success-primary);border-color:currentColor}' +
+      '.dsub-badge-warn{color:var(--dsw-alias-state-warning-primary);border-color:currentColor}' +
+      '.dsub-link{background:none;border:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-size:12px;padding:0}' +
+      '.dsub-verify{font-size:12px;color:var(--dsw-alias-state-warning-primary)}' +
+      '.dsub-verify a{color:var(--dsw-alias-brand-primary)}'
+
+    const cssId = 'dsh-subscriptions/settings.module.css'
+    if (typeof document !== 'undefined' && !document.querySelector('style[data-plugin-css="' + cssId + '"]')) {
+      const tag = document.createElement('style')
+      tag.textContent = CSS
+      tag.setAttribute('data-plugin', 'dsh-subscriptions')
+      tag.dataset.pluginCss = cssId
+      document.head.appendChild(tag)
+    }
+
+    function badgeFor(account) {
+      if (!account || !account.configured) return 'Not connected'
+      if (account.validationUrl) return 'Verify account'
+      if (account.cooldownUntil && account.cooldownUntil > Date.now()) return 'Cooling down'
+      if (account.usagePercent != null && account.usagePercent >= 100) return 'Usage 100%'
+      return 'Connected'
+    }
+
+    function SubsSection() {
+      const [draft, setDraft] = React.useState(null)
+      const [accounts, setAccounts] = React.useState([])
+      const [providers, setProviders] = React.useState([])
+      const [paste, setPaste] = React.useState({})
+      const [saved, setSaved] = React.useState(false)
+      const [err, setErr] = React.useState('')
+
+      const applyPayload = (data) => {
+        setDraft(JSON.parse(JSON.stringify((data && data.config) || {})))
+        setAccounts((data && data.accounts) || [])
+        setProviders((data && data.providers) || [])
+      }
+
+      const reload = () => fetch('/dsh-subscriptions/config', { cache: 'no-store' })
+        .then((res) => res.json())
+        .then(applyPayload)
+
+      React.useEffect(() => {
+        let alive = true
+        reload().catch((e) => { if (alive) setErr(String(e && e.message ? e.message : e)) })
+        return () => { alive = false }
+      }, [])
+
+      if (!draft) return React.createElement('div', { className: 'dsub-wrap' }, 'Loading\u2026')
+
+      const slots = Array.isArray(draft.slots) ? draft.slots : []
+      const setSlots = (next) => setDraft((d) => Object.assign({}, d, { slots: next }))
+      const accountOf = (provider, index) => accounts.find((a) => a.provider === provider && a.index === index) || {}
+
+      const save = async () => {
+        setErr(''); setSaved(false)
+        const res = await fetch('/dsh-subscriptions/config', {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(draft),
+        })
+        const data = await res.json().catch(() => ({}))
+        if (!res.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        applyPayload(data)
+        setSaved(true); setTimeout(() => setSaved(false), 2000)
+      }
+
+      const connect = async (provider, index) => {
+        setErr('')
+        const res = await fetch('/dsh-subscriptions/oauth/start?provider=' + encodeURIComponent(provider) + '&index=' + encodeURIComponent(index), { cache: 'no-store' })
+        const data = await res.json().catch(() => ({}))
+        if (!res.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        if (data.url) window.open(data.url, '_blank', 'noopener')
+      }
+
+      const complete = async (provider, index) => {
+        setErr('')
+        const key = provider + ':' + index
+        const url = paste[key] || ''
+        const res = await fetch('/dsh-subscriptions/oauth/complete', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ provider: provider, index: index, url: url }),
+        })
+        const data = await res.json().catch(() => ({}))
+        if (!res.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        setAccounts(data.accounts || [])
+        setPaste((p) => Object.assign({}, p, { [key]: '' }))
+      }
+
+      const logout = async (provider, index) => {
+        setErr('')
+        const res = await fetch('/dsh-subscriptions/logout', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ provider: provider, index: index }),
+        })
+        const data = await res.json().catch(() => ({}))
+        if (!res.ok) throw new Error((data.error && data.error.message) || ('HTTP ' + res.status))
+        setAccounts(data.accounts || [])
+      }
+
+      const addSlot = (provider) => {
+        const used = slots.filter((s) => s.provider === provider).map((s) => s.index)
+        let index = 1
+        while (used.indexOf(index) >= 0) index++
+        setSlots(slots.concat([{ provider: provider, index: index, label: '' }]))
+      }
+
+      const names = providers.length ? providers : [
+        { id: 'codex', name: 'ChatGPT Codex' },
+        { id: 'claude', name: 'Claude' },
+        { id: 'grok', name: 'Grok' },
+        { id: 'antigravity', name: 'Antigravity' },
+      ]
+
+      return React.createElement('div', { className: 'dsub-wrap' },
+        React.createElement('div', { className: 'dsub-block' },
+          React.createElement('div', { className: 'dsub-h' }, 'Subscriptions'),
+          React.createElement('div', { className: 'dsub-sub' },
+            'Log in with a consumer subscription. Tokens stay on the host credentials store. The browser never reads them back. After Connect, if the provider lands on localhost or a vendor page, paste the redirected URL or the code here.'),
+          React.createElement('label', { className: 'dsub-row' },
+            React.createElement('input', {
+              type: 'checkbox',
+              checked: !!draft.useWebCallback,
+              onChange: (e) => setDraft((d) => Object.assign({}, d, { useWebCallback: e.target.checked })),
+            }),
+            React.createElement('span', null, 'Use this Web UI origin as OAuth redirect_uri'),
+          ),
+          React.createElement('div', { className: 'dsub-sub' },
+            'Leave off unless you registered your own OAuth client for this origin. Vendor CLI clients usually require their published redirect URI plus the paste step.'),
+        ),
+        names.map((prov) => {
+          const rows = slots
+            .map((slot, i) => ({ slot: slot, i: i }))
+            .filter((row) => row.slot.provider === prov.id)
+          return React.createElement('div', { className: 'dsub-block', key: prov.id },
+            React.createElement('div', { className: 'dsub-h' }, prov.name),
+            rows.map((row) => {
+              const account = accountOf(row.slot.provider, row.slot.index)
+              const key = row.slot.provider + ':' + row.slot.index
+              const on = !!account.configured
+              return React.createElement('div', { className: 'dsub-card', key: key },
+                React.createElement('div', { className: 'dsub-row' },
+                  React.createElement('input', {
+                    className: 'dsub-grow',
+                    value: row.slot.label || '',
+                    placeholder: account.label || ('Account ' + row.slot.index),
+                    onChange: (e) => {
+                      const next = slots.slice()
+                      next[row.i] = Object.assign({}, next[row.i], { label: e.target.value })
+                      setSlots(next)
+                    },
+                  }),
+                  React.createElement('span', { className: 'dsub-badge' + (account.validationUrl ? ' dsub-badge-warn' : (on ? ' dsub-badge-on' : '')) }, badgeFor(account)),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini',
+                    onClick: () => connect(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
+                  }, on ? 'Reconnect' : 'Connect'),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini',
+                    disabled: !on,
+                    onClick: () => logout(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
+                  }, 'Disconnect'),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini', title: 'Remove slot',
+                    onClick: () => {
+                      const slot = row.slot
+                      Promise.resolve(on ? logout(slot.provider, slot.index) : null)
+                        .then(() => setSlots(slots.filter((_, k) => k !== row.i)))
+                        .catch((e) => setErr(String(e.message || e)))
+                    },
+                  }, '\u00d7'),
+                ),
+                React.createElement('div', { className: 'dsub-row' },
+                  React.createElement('input', {
+                    className: 'dsub-grow',
+                    value: paste[key] || '',
+                    placeholder: 'Paste redirected URL or code',
+                    onChange: (e) => setPaste((p) => Object.assign({}, p, { [key]: e.target.value })),
+                  }),
+                  React.createElement('button', {
+                    type: 'button', className: 'dsub-mini',
+                    onClick: () => complete(row.slot.provider, row.slot.index).catch((e) => setErr(String(e.message || e))),
+                  }, 'Submit code'),
+                ),
+                account.accountNotice ? React.createElement('div', { className: 'dsub-verify' }, account.accountNotice) : null,
+                account.validationUrl ? React.createElement('div', { className: 'dsub-verify' },
+                  'Google requires one-time account verification. ',
+                  React.createElement('a', { href: account.validationUrl, target: '_blank', rel: 'noopener noreferrer' }, 'Open verification link'),
+                  ' then reconnect.',
+                ) : null,
+                account.paidTierName ? React.createElement('span', { className: 'dsub-sub' }, 'Plan: ' + account.paidTierName) : null,
+                account.ref ? React.createElement('span', { className: 'dsub-sub' }, 'Stored as ' + account.ref) : null,
+              )
+            }),
+            React.createElement('button', {
+              type: 'button', className: 'dsub-mini',
+              onClick: () => addSlot(prov.id),
+            }, '+ Add account'),
+          )
+        }),
+        React.createElement('div', { className: 'dsub-row' },
+          React.createElement('button', {
+            type: 'button', className: 'dsub-save',
+            onClick: () => save().catch((e) => setErr(String(e.message || e))),
+          }, 'Save'),
+          saved ? React.createElement('span', { className: 'dsub-ok' }, 'Saved') : null,
+          err ? React.createElement('span', { className: 'dsub-bad' }, err) : null,
+        ),
+      )
+    }
+
+    function registerSettings(ctx) {
+      ctx.slots.inject('settings.section', () => ctx.slots.register(
+        { name: 'settings.section', id: '@goodandready/dsh-subscriptions', order: 28, label: () => 'Subscriptions', inject: () => ({ ctx: ctx }) },
+        SubsSection,
+      ))
+    }
+
+    exports.inject = ['slots']
+    exports.apply = function apply(ctx) {
+      registerSettings(ctx)
+    }
+    return module.exports
+  },
+})

package/lib/code-assist.js

@@ -0,0 +1,250 @@
+import { randomUUID } from 'node:crypto'
+import { httpError, readJson } from './wire.js'
+import { validationFromLoadCodeAssist, validationFromHttpError, noticeFromLoadCodeAssist, validationRequiredError } from './google-validation.js'
+import { asUsageSnapshot, deepestUsedPercent } from './usage.js'
+
+export const CODE_ASSIST_PROD = 'https://cloudcode-pa.googleapis.com/v1internal'
+export const CODE_ASSIST_STREAM = 'https://daily-cloudcode-pa.googleapis.com/v1internal'
+export const CODE_ASSIST = CODE_ASSIST_PROD
+
+function antigravityPlatform() {
+  if (process.platform === 'win32') return 'WINDOWS'
+  if (process.platform === 'darwin') return 'MACOS'
+  return 'LINUX'
+}
+
+export function antigravityMetadata(projectId) {
+  const meta = {
+    ideType: 'ANTIGRAVITY',
+    platform: antigravityPlatform(),
+    pluginType: 'GEMINI',
+  }
+  if (projectId) meta.duetProject = projectId
+  return meta
+}
+
+export function antigravityIdentityHeaders(projectId) {
+  const uaPlat = process.platform === 'darwin' ? 'darwin/amd64' : process.platform === 'win32' ? 'windows/amd64' : 'linux/amd64'
+  return {
+    'user-agent': `antigravity/1.18.3 ${uaPlat}`,
+    'X-Goog-Api-Client': 'google-cloud-sdk vscode_cloudshelleditor/0.1',
+    'Client-Metadata': JSON.stringify(antigravityMetadata(projectId)),
+  }
+}
+
+export function assistHeaders(token, extra) {
+  return {
+    Authorization: `Bearer ${token}`,
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    ...(extra || {}),
+  }
+}
+
+export async function postAssist(fetchImpl, method, token, body, extraHeaders) {
+  const res = await fetchImpl(`${CODE_ASSIST}:${method}`, {
+    method: 'POST',
+    headers: assistHeaders(token, extraHeaders),
+    body: JSON.stringify(body || {}),
+  })
+  return readJson(res)
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function projectFrom(obj) {
+  if (!obj || typeof obj !== 'object') return ''
+  if (typeof obj.cloudaicompanionProject === 'string') return obj.cloudaicompanionProject
+  const nested = obj.cloudaicompanionProject
+  if (nested && typeof nested === 'object') return String(nested.id || nested.name || '')
+  if (obj.response && obj.response.cloudaicompanionProject) {
+    const r = obj.response.cloudaicompanionProject
+    return typeof r === 'string' ? r : String(r.id || r.name || '')
+  }
+  return ''
+}
+
+export function accountFromLoad(load) {
+  const current = load && load.currentTier && typeof load.currentTier === 'object' ? load.currentTier : {}
+  const paidTierId = load?.paidTier?.id ? String(load.paidTier.id) : ''
+  return {
+    projectId: projectFrom(load),
+    tierId: String(current.id || paidTierId || 'free-tier'),
+    paidTierId,
+    paidTierName: load?.paidTier?.name ? String(load.paidTier.name) : '',
+  }
+}
+
+export async function resolveProjectId(fetchImpl, token, metadata, extraHeaders, currentProjectId) {
+  const load = await postAssist(fetchImpl, 'loadCodeAssist', token, { metadata }, extraHeaders)
+  const validation = validationFromLoadCodeAssist(load)
+  if (validation) throw validationRequiredError(validation)
+  const account = accountFromLoad(load)
+  if (account.projectId) return { ...account, load }
+  if (currentProjectId) return { ...account, projectId: currentProjectId, load }
+  return { ...account, projectId: '', load }
+}
+
+function pickOnboardTier(load) {
+  const current = load?.currentTier
+  const paidTierId = load?.paidTier?.id ? String(load.paidTier.id) : ''
+  if (paidTierId === 'g1-pro-tier') return 'standard-tier'
+  for (const tier of load?.allowedTiers || []) {
+    if (tier?.isDefault && tier?.id) return String(tier.id)
+  }
+  return String(current?.id || 'free-tier')
+}
+
+export async function discoverProject(fetchImpl, token, metadata, extraHeaders) {
+  const resolved = await resolveProjectId(fetchImpl, token, metadata, extraHeaders, '')
+  const { load } = resolved
+  const account = accountFromLoad(load)
+  if (account.projectId) {
+    return {
+      projectId: account.projectId,
+      tierId: account.paidTierId || account.tierId,
+      paidTierId: account.paidTierId,
+      paidTierName: account.paidTierName,
+    }
+  }
+  const tierId = pickOnboardTier(load)
+  const onboardBody = {
+    tierId,
+    metadata,
+    ...(tierId !== 'free-tier' && tierId !== 'FREE' ? { cloudaicompanionProject: metadata.duetProject } : {}),
+  }
+  let op = await postAssist(fetchImpl, 'onboardUser', token, onboardBody, extraHeaders).catch(() => null)
+  let n = 0
+  while (op && op.done === false && op.name && n < 8) {
+    await sleep(400)
+    try {
+      op = await postAssist(fetchImpl, 'loadCodeAssist', token, { metadata }, extraHeaders)
+    } catch {
+      break
+    }
+    n += 1
+  }
+  const projectId = projectFrom(op) || account.projectId
+  const after = accountFromLoad(op && op.response ? op.response : load)
+  return {
+    projectId,
+    tierId: after.paidTierId || tierId,
+    paidTierId: after.paidTierId,
+    paidTierName: after.paidTierName,
+  }
+}
+
+function catalogFallback(fallbackIds, provider) {
+  return (fallbackIds || []).map((row) => {
+    if (typeof row === 'string') return { provider, id: row, name: row }
+    const id = row && (row.id || row.name)
+    if (!id) return null
+    return { provider, id, name: row.name || id }
+  }).filter(Boolean)
+}
+
+function catalogRows(json) {
+  const raw = json?.models ?? json?.availableModels ?? json?.data ?? []
+  if (Array.isArray(raw)) return raw.map((row) => (typeof row === 'string' ? { id: row } : row))
+  if (raw && typeof raw === 'object') {
+    return Object.entries(raw).map(([id, row]) => ({ ...(row || {}), id }))
+  }
+  return []
+}
+
+export async function fetchAvailableModels(fetchImpl, token, extraHeaders, fallbackIds, provider) {
+  try {
+    const json = await postAssist(fetchImpl, 'fetchAvailableModels', token, {}, extraHeaders)
+    const out = []
+    for (const row of catalogRows(json)) {
+      if (!row) continue
+      if (typeof row === 'string') {
+        if (row && !row.startsWith('chat_')) out.push({ provider, id: row, name: row })
+        continue
+      }
+      if (row.isInternal) continue
+      const raw = String(row.id || row.name || row.model || '').replace(/^models\//, '')
+      if (!raw || raw.startsWith('chat_')) continue
+      const display = row.displayName ?? row.display_name
+      if (display === '') continue
+      out.push({
+        provider,
+        id: raw,
+        name: display || raw,
+        ...(row.recommended ? { description: 'Recommended' } : {}),
+        ...(row.maxTokens ? { contextWindow: row.maxTokens } : {}),
+      })
+    }
+    if (out.length) {
+      out.sort((a, b) => Number(Boolean(b.description)) - Number(Boolean(a.description)) || a.name.localeCompare(b.name))
+      return out
+    }
+  } catch { /* catalog fallback */ }
+  return catalogFallback(fallbackIds, provider)
+}
+
+export async function retrieveQuotaPercent(fetchImpl, token, extraHeaders) {
+  try {
+    const json = await postAssist(fetchImpl, 'retrieveUserQuota', token, {}, extraHeaders)
+    return asUsageSnapshot(deepestUsedPercent(json))
+  } catch {
+    return null
+  }
+}
+
+const G1_CREDIT_TYPE = 'GOOGLE_ONE_AI'
+
+export function streamEnvelope({ projectId, model, request, userAgent, sessionId, paidTierId }) {
+  const session = sessionId || randomUUID()
+  const body = { ...(request || {}) }
+  if (!body.session_id) body.session_id = session
+  const envelope = {
+    ...(projectId ? { project: projectId } : {}),
+    model,
+    user_prompt_id: randomUUID(),
+    request: body,
+    userAgent,
+  }
+  if (paidTierId === 'g1-pro-tier') envelope.enabled_credit_types = [G1_CREDIT_TYPE]
+  return { envelope, sessionId: session }
+}
+
+export { httpError }
+
+export async function inspectGoogleAccount(fetchImpl, token, { metadata, extraHeaders, projectId }) {
+  try {
+    const { projectId: resolvedProject, load } = await resolveProjectId(
+      fetchImpl,
+      token,
+      metadata,
+      extraHeaders,
+      projectId || '',
+    )
+    const validation = validationFromLoadCodeAssist(load)
+    if (validation) return { validation, notice: null, projectId: resolvedProject }
+    const notice = noticeFromLoadCodeAssist(load)
+    const account = accountFromLoad(load)
+    return {
+      validation: null,
+      notice,
+      projectId: resolvedProject,
+      paidTierId: account.paidTierId,
+      paidTierName: account.paidTierName,
+    }
+  } catch (err) {
+    if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {
+      return {
+        validation: {
+          message: String(err.message || ''),
+          validationUrl: err.validationUrl,
+          learnMoreUrl: err.learnMoreUrl || '',
+        },
+        notice: null,
+        projectId: projectId || '',
+      }
+    }
+    return { validation: null, notice: null, projectId: projectId || '' }
+  }
+}

package/lib/gemini-schema.js

@@ -0,0 +1,67 @@
+const TYPE_MAP = {
+  string: 'string',
+  number: 'number',
+  integer: 'integer',
+  boolean: 'boolean',
+  array: 'array',
+  object: 'object',
+}
+
+function asType(value) {
+  if (Array.isArray(value)) {
+    const nullable = value.includes('null')
+    const first = value.find((item) => item && item !== 'null')
+    return { type: TYPE_MAP[String(first || 'string').toLowerCase()] || 'string', nullable }
+  }
+  if (typeof value === 'string' && TYPE_MAP[value.toLowerCase()]) {
+    return { type: TYPE_MAP[value.toLowerCase()], nullable: false }
+  }
+  return null
+}
+
+export function toGeminiSchema(schema, depth) {
+  const level = Number(depth) || 0
+  if (level > 12) return { type: 'string' }
+  if (!schema || typeof schema !== 'object') return { type: 'string' }
+  if (Array.isArray(schema)) return toGeminiSchema(schema[0] || { type: 'string' }, level + 1)
+
+  const typed = asType(schema.type)
+  let type = typed ? typed.type : null
+  if (!type) {
+    if (schema.properties) type = 'object'
+    else if (schema.items) type = 'array'
+    else type = 'string'
+  }
+  const out = { type }
+  if (typed && typed.nullable) out.nullable = true
+  if (schema.description) out.description = String(schema.description)
+  if (type === 'object') {
+    const props = schema.properties
+    if (props && typeof props === 'object' && !Array.isArray(props)) {
+      out.properties = {}
+      for (const [key, value] of Object.entries(props)) {
+        out.properties[key] = toGeminiSchema(value, level + 1)
+      }
+    }
+    if (Array.isArray(schema.required)) {
+      out.required = schema.required.filter((item) => typeof item === 'string')
+    }
+  }
+  if (type === 'array') {
+    const items = schema.items
+    out.items = toGeminiSchema(Array.isArray(items) ? items[0] : (items || { type: 'string' }), level + 1)
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length) {
+    out.enum = schema.enum.map((item) => String(item))
+  }
+  return out
+}
+
+export function geminiFunctionDeclarations(tools) {
+  if (!Array.isArray(tools) || !tools.length) return undefined
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description || '',
+    parameters: toGeminiSchema(tool.parameters || { type: 'object' }),
+  }))
+}

package/lib/google-validation.js

@@ -0,0 +1,117 @@
+const CLOUDCODE_DOMAINS = [
+  'cloudcode-pa.googleapis.com',
+  'staging-cloudcode-pa.googleapis.com',
+  'autopush-cloudcode-pa.googleapis.com',
+]
+
+export function isCloudCodeDomain(domain) {
+  const sanitized = String(domain || '').replace(/[^a-zA-Z0-9.-]/g, '')
+  return CLOUDCODE_DOMAINS.includes(sanitized)
+}
+
+export function parseGoogleApiError(bodyText) {
+  try {
+    const json = JSON.parse(String(bodyText || ''))
+    const err = json.error || json
+    if (!err || typeof err !== 'object') return null
+    return {
+      code: err.code,
+      message: String(err.message || ''),
+      status: String(err.status || ''),
+      details: Array.isArray(err.details) ? err.details : [],
+    }
+  } catch {
+    return null
+  }
+}
+
+function metadataUrl(metadata) {
+  if (!metadata || typeof metadata !== 'object') return ''
+  return String(
+    metadata.validation_url
+    || metadata.validation_link
+    || metadata.validationUrl
+    || '',
+  )
+}
+
+export function validationFromLoadCodeAssist(load) {
+  if (!load) return null
+  const tiers = load.ineligibleTiers
+  if (Array.isArray(tiers) && tiers.length) {
+    const tier = tiers.find((row) => row && (
+      row.reasonCode === 'VALIDATION_REQUIRED'
+      || row.reason === 'VALIDATION_REQUIRED'
+    ) && (row.validationUrl || row.validation_url))
+    if (tier) {
+      return {
+        message: String(tier.reasonMessage || 'Verify your account to continue.'),
+        validationUrl: String(tier.validationUrl || tier.validation_url),
+        learnMoreUrl: String(tier.learnMoreUrl || tier.learn_more_url || ''),
+      }
+    }
+  }
+  return null
+}
+
+export function noticeFromLoadCodeAssist(load) {
+  if (!load || load.currentTier) return null
+  const tiers = load.ineligibleTiers
+  if (!Array.isArray(tiers) || !tiers.length) return null
+  const tier = tiers[0]
+  if (!tier) return null
+  const code = String(tier.reasonCode || tier.reason || '')
+  const message = String(tier.reasonMessage || '')
+  if (!message) return null
+  if (code === 'VALIDATION_REQUIRED') return null
+  return { code, message }
+}
+
+export function validationFromHttpError(status, bodyText) {
+  if (status !== 403) return null
+  const api = parseGoogleApiError(bodyText)
+  if (!api) return null
+  const info = api.details.find((d) => d['@type'] === 'type.googleapis.com/google.rpc.ErrorInfo')
+  if (!info || info.reason !== 'VALIDATION_REQUIRED' || !isCloudCodeDomain(info.domain)) return null
+
+  const help = api.details.find((d) => d['@type'] === 'type.googleapis.com/google.rpc.Help')
+  let validationUrl = metadataUrl(info.metadata)
+  let message = String(info.metadata?.validation_error_message || api.message || 'Verify your account to continue.')
+  if (help?.links?.length) {
+    const verify = help.links.find((link) => {
+      const desc = String(link.description || '').toLowerCase()
+      return desc.includes('verify') || !desc.includes('learn more')
+    }) || help.links[0]
+    validationUrl = validationUrl || String(verify?.url || '')
+    message = String(verify?.description || message)
+  }
+  if (!validationUrl) return null
+  let learnMoreUrl = String(info.metadata?.validation_learn_more_url || '')
+  if (!learnMoreUrl && help?.links?.length) {
+    const more = help.links.find((link) => {
+      if (String(link.description || '').toLowerCase().trim() === 'learn more') return true
+      try { return new URL(link.url).hostname === 'support.google.com' } catch { return false }
+    })
+    if (more) learnMoreUrl = String(more.url || '')
+  }
+  return { message, validationUrl, learnMoreUrl }
+}
+
+export function validationRequiredError(details) {
+  const err = new Error(`${details.message} Verify at ${details.validationUrl}`)
+  err.code = 'VALIDATION_REQUIRED'
+  err.validationUrl = details.validationUrl
+  if (details.learnMoreUrl) err.learnMoreUrl = details.learnMoreUrl
+  return err
+}
+
+
+export function googleRateLimitMessage(status, bodyText) {
+  if (status !== 429) return ''
+  const api = parseGoogleApiError(bodyText)
+  const msg = String(api?.message || bodyText || '')
+  if (/resource has been exhausted|RESOURCE_EXHAUSTED|quota/i.test(msg)) {
+    return 'Google Antigravity quota or rate limit reached. Wait a few minutes, check usage in antigravity.google, or upgrade Google AI Pro.'
+  }
+  return ''
+}