@goodandready/dsh-subscriptions 0.1.0

package/lib/messages.js

@@ -0,0 +1,258 @@
+import { geminiFunctionDeclarations } from './gemini-schema.js'
+
+function flattenText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((block) => block && (block.type === 'text' || block.type === 'reasoning'))
+    .map((block) => block.text || '')
+    .join('')
+}
+
+function toolResults(content) {
+  return Array.isArray(content) ? content.filter((b) => b && b.type === 'tool-result') : []
+}
+
+function toolCalls(content) {
+  return Array.isArray(content) ? content.filter((b) => b && b.type === 'tool-call') : []
+}
+
+export function openaiMessages(options) {
+  const out = []
+  if (options.system) out.push({ role: 'system', content: options.system })
+  for (const message of options.messages || []) {
+    if (message.role === 'system') {
+      out.push({ role: 'system', content: flattenText(message.content) })
+      continue
+    }
+    if (message.role === 'assistant') {
+      const calls = toolCalls(message.content).map((block) => ({
+        id: block.id,
+        type: 'function',
+        function: { name: block.name, arguments: block.arguments || '{}' },
+      }))
+      out.push({
+        role: 'assistant',
+        content: flattenText(message.content) || (calls.length ? null : ''),
+        ...(calls.length ? { tool_calls: calls } : {}),
+      })
+      continue
+    }
+    const results = toolResults(message.content)
+    const text = flattenText(message.content)
+    if (text || !results.length) out.push({ role: 'user', content: text })
+    for (const result of results) {
+      out.push({
+        role: 'tool',
+        tool_call_id: result.toolCallId,
+        content: flattenText(result.content) || '(no output)',
+      })
+    }
+  }
+  return out
+}
+
+export function openaiTools(options) {
+  const tools = options.tools
+  if (!Array.isArray(tools) || !tools.length) return undefined
+  return tools.map((tool) => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description || '',
+      parameters: tool.parameters || { type: 'object' },
+    },
+  }))
+}
+
+export function codexResponsesBody(options, fallbackInstructions) {
+  const systemParts = []
+  if (options.system) systemParts.push(options.system)
+  const input = []
+  let pendingRole = null
+  let pendingContent = []
+  function flush() {
+    if (!pendingRole) return
+    const type = pendingRole === 'assistant' ? 'output_text' : 'input_text'
+    input.push({
+      role: pendingRole,
+      content: pendingContent.length ? pendingContent : [{ type, text: '' }],
+    })
+    pendingRole = null
+    pendingContent = []
+  }
+  function addText(role, text) {
+    const type = role === 'assistant' ? 'output_text' : 'input_text'
+    if (pendingRole && pendingRole !== role) flush()
+    pendingRole = role
+    if (text) pendingContent.push({ type, text })
+  }
+  for (const message of options.messages || []) {
+    if (message.role === 'system') {
+      systemParts.push(flattenText(message.content))
+      continue
+    }
+    if (message.role === 'assistant') {
+      const text = flattenText(message.content)
+      if (text) addText('assistant', text)
+      for (const call of toolCalls(message.content)) {
+        flush()
+        input.push({
+          type: 'function_call',
+          call_id: String(call.id || ''),
+          name: call.name,
+          arguments: typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments || {}),
+        })
+      }
+      continue
+    }
+    const text = flattenText(message.content)
+    if (text) addText('user', text)
+    for (const result of toolResults(message.content)) {
+      flush()
+      input.push({
+        type: 'function_call_output',
+        call_id: String(result.toolCallId || ''),
+        output: flattenText(result.content) || '',
+      })
+    }
+  }
+  flush()
+  if (!input.length) input.push({ role: 'user', content: [{ type: 'input_text', text: '' }] })
+  const tools = openaiTools(options)
+  const responsesTools = tools && tools.map((tool) => ({
+    type: 'function',
+    name: tool.function.name,
+    description: tool.function.description,
+    parameters: tool.function.parameters,
+  }))
+  const instructions = systemParts.filter(Boolean).join('\n\n') || fallbackInstructions
+  return {
+    model: options.model,
+    stream: true,
+    store: false,
+    instructions,
+    input,
+    ...(responsesTools && responsesTools.length ? { tools: responsesTools } : {}),
+    ...(options.maxTokens != null ? { max_output_tokens: options.maxTokens } : {}),
+    ...(options.temperature != null ? { temperature: options.temperature } : {}),
+  }
+}
+
+export function anthropicPayload(options, extraSystem) {
+  const systemParts = []
+  if (extraSystem) systemParts.push(extraSystem)
+  if (options.system) systemParts.push(options.system)
+  const messages = []
+  for (const message of options.messages || []) {
+    if (message.role === 'system') {
+      systemParts.push(flattenText(message.content))
+      continue
+    }
+    if (message.role === 'assistant') {
+      const blocks = []
+      const text = flattenText(message.content)
+      if (text) blocks.push({ type: 'text', text })
+      for (const call of toolCalls(message.content)) {
+        blocks.push({
+          type: 'tool_use',
+          id: call.id,
+          name: call.name,
+          input: safeJson(call.arguments),
+        })
+      }
+      messages.push({ role: 'assistant', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+      continue
+    }
+    const blocks = []
+    const text = flattenText(message.content)
+    if (text) blocks.push({ type: 'text', text })
+    for (const result of toolResults(message.content)) {
+      blocks.push({
+        type: 'tool_result',
+        tool_use_id: result.toolCallId,
+        content: flattenText(result.content) || '',
+      })
+    }
+    messages.push({ role: 'user', content: blocks.length ? blocks : [{ type: 'text', text: '' }] })
+  }
+  const tools = Array.isArray(options.tools)
+    ? options.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description || '',
+      input_schema: tool.parameters || { type: 'object' },
+    }))
+    : undefined
+  return {
+    model: options.model,
+    max_tokens: options.maxTokens || 8192,
+    stream: true,
+    ...(systemParts.length ? { system: systemParts.join('\n\n') } : {}),
+    messages,
+    ...(tools && tools.length ? { tools } : {}),
+    ...(options.temperature != null ? { temperature: options.temperature } : {}),
+  }
+}
+
+export function googleContents(options) {
+  const contents = []
+  const systemParts = []
+  if (options.system) systemParts.push({ text: options.system })
+  for (const message of options.messages || []) {
+    if (message.role === 'system') {
+      systemParts.push({ text: flattenText(message.content) })
+      continue
+    }
+    const role = message.role === 'assistant' ? 'model' : 'user'
+    const parts = []
+    const text = flattenText(message.content)
+    if (text) parts.push({ text })
+    for (const call of toolCalls(message.content)) {
+      parts.push({ functionCall: { name: call.name, args: safeJson(call.arguments) } })
+    }
+    for (const result of toolResults(message.content)) {
+      parts.push({
+        functionResponse: {
+          name: result.toolName || result.name || 'tool',
+          response: { output: flattenText(result.content) },
+        },
+      })
+    }
+    if (!parts.length) parts.push({ text: '' })
+    contents.push({ role, parts })
+  }
+  const declarations = geminiFunctionDeclarations(options.tools)
+  const tools = declarations ? [{ functionDeclarations: declarations }] : undefined
+  return {
+    contents,
+    ...(systemParts.length ? { systemInstruction: { parts: systemParts } } : {}),
+    ...(tools ? { tools } : {}),
+    generationConfig: {
+      ...(options.temperature != null ? { temperature: options.temperature } : {}),
+      ...(options.maxTokens != null ? { maxOutputTokens: options.maxTokens } : {}),
+    },
+  }
+}
+
+function safeJson(text) {
+  if (text && typeof text === 'object') return text
+  try { return JSON.parse(text || '{}') } catch { return {} }
+}
+
+export function modelCatalog(provider, entries) {
+  return (entries || []).map((entry) => {
+    if (!entry) return null
+    if (typeof entry === 'string') return { provider, id: entry, name: entry }
+    const id = entry.id || entry.slug || entry.name
+    if (!id) return null
+    return {
+      provider,
+      id,
+      name: entry.name || entry.display_name || id,
+      ...(entry.description ? { description: entry.description } : {}),
+      ...(entry.contextWindow ? { contextWindow: entry.contextWindow } : {}),
+      ...(entry.inputModalities ? { inputModalities: entry.inputModalities } : {}),
+      ...(entry.reasoning ? { reasoning: entry.reasoning } : {}),
+    }
+  }).filter(Boolean)
+}

package/lib/oauth.js

@@ -0,0 +1,68 @@
+export function buildAuthorizeUrl({
+  authUrl,
+  clientId,
+  redirectUri,
+  challenge,
+  state,
+  extra,
+  scope,
+}) {
+  const url = new URL(authUrl)
+  url.searchParams.set('response_type', 'code')
+  url.searchParams.set('client_id', clientId)
+  url.searchParams.set('redirect_uri', redirectUri)
+  url.searchParams.set('code_challenge', challenge)
+  url.searchParams.set('code_challenge_method', 'S256')
+  url.searchParams.set('state', state)
+  if (scope) url.searchParams.set('scope', scope)
+  if (extra && typeof extra === 'object') {
+    for (const [key, value] of Object.entries(extra)) {
+      if (value == null || value === '') continue
+      url.searchParams.set(key, String(value))
+    }
+  }
+  return url.toString()
+}
+
+export function parseCallbackInput(text) {
+  const raw = String(text || '').trim()
+  if (!raw) return { code: '', state: '' }
+  if (!raw.includes('://') && !raw.includes('?')) {
+    const parts = raw.split('#')
+    return { code: parts[0], state: parts[1] || '' }
+  }
+  try {
+    const hashed = raw.replace('#', '?')
+    const url = new URL(hashed)
+    const code = url.searchParams.get('code') || ''
+    const state = url.searchParams.get('state') || ''
+    return { code, state }
+  } catch {
+    const match = /(?:^|[?&#])code=([^&#\s]+)/.exec(raw)
+    return { code: match ? decodeURIComponent(match[1]) : raw, state: '' }
+  }
+}
+
+export function requestOrigin(req) {
+  const xfProto = header(req, 'x-forwarded-proto')
+  const xfHost = header(req, 'x-forwarded-host')
+  const host = xfHost || header(req, 'host') || 'localhost'
+  let proto = xfProto || 'http'
+  if (header(req, 'origin')) {
+    try { return new URL(header(req, 'origin')).origin } catch { /* fall through */ }
+  }
+  if (header(req, 'referer')) {
+    try { return new URL(header(req, 'referer')).origin } catch { /* fall through */ }
+  }
+  return `${proto}://${host}`
+}
+
+function header(req, name) {
+  const value = req && req.headers && req.headers[name]
+  if (Array.isArray(value)) return value[0] || ''
+  return value ? String(value) : ''
+}
+
+export function webCallbackUri(origin) {
+  return `${String(origin || '').replace(/\/$/, '')}/dsh-subscriptions/oauth/callback`
+}

package/lib/pkce.js

@@ -0,0 +1,12 @@
+import { createHash, randomBytes } from 'node:crypto'
+
+function b64url(bytes) {
+  return Buffer.from(bytes).toString('base64url')
+}
+
+export async function createPkce() {
+  const verifier = b64url(randomBytes(32))
+  const challenge = b64url(createHash('sha256').update(verifier).digest())
+  const state = b64url(randomBytes(16))
+  return { verifier, challenge, state }
+}

package/lib/refs.js

@@ -0,0 +1,59 @@
+export const PROVIDERS = Object.freeze([
+  'codex',
+  'claude',
+  'grok',
+  'antigravity',
+])
+
+const KNOWN = new Set(PROVIDERS)
+
+const DISPLAY = {
+  codex: 'ChatGPT Codex',
+  claude: 'Claude',
+  grok: 'Grok',
+  antigravity: 'Antigravity',
+}
+
+export function isProvider(value) {
+  return KNOWN.has(value)
+}
+
+export function displayName(provider) {
+  return DISPLAY[provider] || provider
+}
+
+export function oauthRef(provider, index) {
+  if (!KNOWN.has(provider)) throw new Error(`unknown provider: ${provider}`)
+  const n = Number(index)
+  if (!Number.isInteger(n) || n < 1) throw new Error('account index must be an integer >= 1')
+  return `${provider.toUpperCase()}_OAUTH_${n}`
+}
+
+export function parseOauthRef(ref) {
+  if (typeof ref !== 'string') return null
+  const match = /^(CODEX|CLAUDE|GROK|ANTIGRAVITY)_OAUTH_([1-9][0-9]*)$/.exec(ref)
+  if (!match) return null
+  return { provider: match[1].toLowerCase(), index: Number(match[2]) }
+}
+
+export function droppedCredentialRefs(previousSlots, nextSlots) {
+  const keep = new Set()
+  for (const slot of nextSlots || []) {
+    if (!isProvider(slot.provider)) continue
+    const index = Number(slot.index)
+    if (!Number.isInteger(index) || index < 1) continue
+    keep.add(oauthRef(slot.provider, index))
+  }
+  const out = []
+  const seen = new Set()
+  for (const slot of previousSlots || []) {
+    if (!isProvider(slot.provider)) continue
+    const index = Number(slot.index)
+    if (!Number.isInteger(index) || index < 1) continue
+    const ref = oauthRef(slot.provider, index)
+    if (seen.has(ref) || keep.has(ref)) continue
+    seen.add(ref)
+    out.push(ref)
+  }
+  return out
+}

package/lib/responses-stream.js

@@ -0,0 +1,175 @@
+import { iterateSse, jsonSse } from './sse.js'
+import { httpError } from './wire.js'
+
+function responsesFailure(code, message) {
+  const text = String(message || code || 'responses failed')
+  throw httpError(400, text, /quota|usage.?limit/i.test(text) ? 'QUOTA' : 'VENDOR')
+}
+
+export class ResponsesStreamTranslator {
+  constructor() {
+    this.blocks = new Map()
+    this.order = []
+    this.nextIndex = 0
+    this.sawToolCall = false
+    this.terminated = false
+  }
+
+  open(key, kind, callId = '', name) {
+    const block = {
+      index: this.nextIndex++,
+      kind,
+      text: '',
+      callId,
+      name,
+    }
+    this.blocks.set(key, block)
+    this.order.push(block)
+    return [{ type: 'block-start', index: block.index, blockType: kind }]
+  }
+
+  closeItem(itemId) {
+    for (const key of [...this.blocks.keys()]) {
+      if (key.startsWith(`${itemId}:`)) this.blocks.delete(key)
+    }
+  }
+
+  push(event) {
+    if (this.terminated) return []
+    const chunks = []
+    switch (event.type) {
+      case 'response.output_item.added': {
+        const item = event.item
+        if (item?.type === 'function_call' && item.id !== undefined) {
+          this.sawToolCall = true
+          const callId = item.call_id ?? ''
+          const start = this.open(`${item.id}:call`, 'tool-call', callId, item.name)
+          chunks.push(...start)
+          const block = this.blocks.get(`${item.id}:call`)
+          chunks.push({
+            type: 'tool-call-delta',
+            index: block.index,
+            id: callId,
+            ...(item.name === undefined ? {} : { name: item.name }),
+            argumentsDelta: '',
+          })
+        }
+        return chunks
+      }
+      case 'response.output_text.delta': {
+        const key = `${event.item_id ?? ''}:text:${String(event.content_index ?? 0)}`
+        if (!this.blocks.has(key)) chunks.push(...this.open(key, 'text'))
+        const block = this.blocks.get(key)
+        const delta = event.delta ?? ''
+        block.text += delta
+        chunks.push({ type: 'text-delta', index: block.index, text: delta })
+        return chunks
+      }
+      case 'response.reasoning_summary_text.delta':
+      case 'response.reasoning_text.delta': {
+        const sub = event.summary_index ?? event.content_index ?? 0
+        const key = `${event.item_id ?? ''}:reason:${String(sub)}`
+        if (!this.blocks.has(key)) chunks.push(...this.open(key, 'reasoning'))
+        const block = this.blocks.get(key)
+        const delta = event.delta ?? ''
+        block.text += delta
+        chunks.push({ type: 'reasoning-delta', index: block.index, text: delta })
+        return chunks
+      }
+      case 'response.function_call_arguments.delta': {
+        const key = `${event.item_id ?? ''}:call`
+        if (!this.blocks.has(key)) {
+          this.sawToolCall = true
+          chunks.push(...this.open(key, 'tool-call'))
+        }
+        const block = this.blocks.get(key)
+        const delta = event.delta ?? ''
+        block.text += delta
+        chunks.push({
+          type: 'tool-call-delta',
+          index: block.index,
+          id: block.callId,
+          ...(block.name === undefined ? {} : { name: block.name }),
+          argumentsDelta: delta,
+        })
+        return chunks
+      }
+      case 'response.output_item.done': {
+        const item = event.item
+        if (item === undefined || item.id === undefined) return chunks
+        if (item.type === 'function_call') {
+          const key = `${item.id}:call`
+          const block = this.blocks.get(key)
+          if (block !== undefined && block.text.length === 0 && item.arguments !== undefined) {
+            block.text = item.arguments
+            chunks.push({
+              type: 'tool-call-delta',
+              index: block.index,
+              id: block.callId,
+              ...(block.name === undefined ? {} : { name: block.name }),
+              argumentsDelta: item.arguments,
+            })
+          }
+          this.blocks.delete(key)
+        } else if (item.type === 'message') {
+          const hasText = [...this.blocks.keys()].some((key) => key.startsWith(`${item.id}:text:`))
+          if (!hasText) {
+            for (const [partIndex, part] of (item.content ?? []).entries()) {
+              if (part?.type !== 'output_text' || typeof part.text !== 'string' || part.text.length === 0) continue
+              const key = `${item.id}:text:${partIndex}`
+              chunks.push(...this.open(key, 'text'))
+              const block = this.blocks.get(key)
+              block.text = part.text
+              chunks.push({ type: 'text-delta', index: block.index, text: part.text })
+              this.blocks.delete(key)
+            }
+          }
+          this.closeItem(item.id)
+        } else {
+          this.closeItem(item.id)
+        }
+        return chunks
+      }
+      case 'response.completed': {
+        this.terminated = true
+        const usage = event.response?.usage
+        if (usage !== undefined) chunks.push({ type: 'usage', usage })
+        chunks.push({ type: 'finish', reason: { kind: this.sawToolCall ? 'tool-calls' : 'stop' } })
+        return chunks
+      }
+      case 'response.failed':
+        responsesFailure(event.response?.error?.code, event.response?.error?.message)
+        break
+      case 'response.incomplete':
+        responsesFailure(event.response?.incomplete_details?.reason, event.response?.error?.message
+          || `incomplete response (${event.response?.incomplete_details?.reason ?? 'unknown'})`)
+        break
+      case 'error':
+        responsesFailure(event.code, event.message)
+        break
+      default:
+        return chunks
+    }
+    return chunks
+  }
+}
+
+export async function* streamResponses(body) {
+  const translator = new ResponsesStreamTranslator()
+  for await (const data of iterateSse(body)) {
+    const json = jsonSse(data)
+    if (!json) continue
+    const type = json.type || ''
+    if (type === 'response.failed' || type === 'error') {
+      const msg = (json.response && json.response.error && json.response.error.message)
+        || json.message || json.error || 'responses failed'
+      const text = typeof msg === 'string' ? msg : JSON.stringify(msg)
+      throw httpError(json.status || 400, text, /quota|usage.?limit/i.test(text) ? 'QUOTA' : 'VENDOR')
+    }
+    for (const chunk of translator.push(json)) yield chunk
+    if (translator.terminated) return
+  }
+  if (!translator.terminated) {
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  }
+}

package/lib/rotate.js

@@ -0,0 +1,31 @@
+const SWITCH_CODES = new Set([
+  'RATE_LIMIT',
+  'QUOTA',
+  'QUOTA_EXCEEDED',
+])
+
+export function isSwitchableError(err) {
+  if (!err || typeof err !== 'object') return false
+  const code = err.code || (err.failure && err.failure.code)
+  if (SWITCH_CODES.has(code)) return true
+  const status = err.status || err.statusCode
+  return status === 429
+}
+
+export function pickAccount(accounts, nowMs) {
+  const list = Array.isArray(accounts) ? accounts : []
+  const now = Number(nowMs) || 0
+  for (const account of list) {
+    if (!account || !account.hasToken) continue
+    if (account.usagePercent != null && Number(account.usagePercent) >= 100) continue
+    if (account.cooldownUntil && Number(account.cooldownUntil) > now) continue
+    return account
+  }
+  return null
+}
+
+export function markCooldown(account, nowMs, cooldownMs) {
+  const wait = Number(cooldownMs)
+  const ms = Number.isFinite(wait) && wait > 0 ? wait : 30 * 60 * 1000
+  return { ...account, cooldownUntil: (Number(nowMs) || 0) + ms }
+}

package/lib/sse.js

@@ -0,0 +1,44 @@
+export async function* iterateSse(body) {
+  const reader = body && typeof body.getReader === 'function' ? body.getReader() : null
+  const decoder = new TextDecoder()
+  let buffer = ''
+  async function* fromText(chunk) {
+    buffer += chunk
+    let sep
+    while ((sep = buffer.search(/\r?\n\r?\n/)) >= 0) {
+      const raw = buffer.slice(0, sep)
+      buffer = buffer.slice(sep).replace(/^\r?\n\r?\n/, '')
+      const dataLines = []
+      for (const line of raw.split(/\r?\n/)) {
+        if (line.startsWith('data:')) dataLines.push(line.slice(5).trimStart())
+      }
+      if (!dataLines.length) continue
+      const data = dataLines.join('\n')
+      if (data === '[DONE]') return
+      yield data
+    }
+  }
+  if (reader) {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      yield* fromText(decoder.decode(value, { stream: true }))
+    }
+    yield* fromText(decoder.decode())
+    return
+  }
+  if (body && typeof body[Symbol.asyncIterator] === 'function') {
+    for await (const chunk of body) {
+      const text = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true })
+      yield* fromText(text)
+    }
+    yield* fromText(decoder.decode())
+    return
+  }
+  const text = typeof body === 'string' ? body : await new Response(body).text()
+  yield* fromText(text)
+}
+
+export function jsonSse(data) {
+  try { return JSON.parse(data) } catch { return null }
+}

package/lib/stream-rotate.js

@@ -0,0 +1,41 @@
+import { pickAccount, markCooldown, isSwitchableError } from './rotate.js'
+
+export async function* streamWithRotation({
+  accounts,
+  nowMs,
+  cooldownMs,
+  streamOnce,
+  options,
+  onCooldown,
+}) {
+  const pool = (accounts || []).map((account) => ({ ...account }))
+  let lastError = null
+  const tried = new Set()
+  while (true) {
+    const account = pickAccount(pool, nowMs())
+    if (!account) {
+      if (lastError) throw lastError
+      const err = new Error('no usable subscription account for this provider')
+      err.code = 'AUTH'
+      throw err
+    }
+    if (tried.has(account.ref)) {
+      if (lastError) throw lastError
+      const err = new Error('all subscription accounts failed')
+      err.code = 'RATE_LIMIT'
+      throw err
+    }
+    tried.add(account.ref)
+    try {
+      yield* streamOnce(account, options)
+      return
+    } catch (err) {
+      lastError = err
+      if (!isSwitchableError(err)) throw err
+      const cooled = markCooldown(account, nowMs(), cooldownMs)
+      account.cooldownUntil = cooled.cooldownUntil
+      if (onCooldown) onCooldown(account)
+    }
+  }
+}
+