tissues 0.5.2 → 0.6.1

package/src/commands/status.js

@@ -4,7 +4,9 @@ import { loadConfig, findRepoRoot } from '../lib/defaults.js'
 import { getSafetyStatus, forceReset } from '../lib/safety.js'
 import { getDb } from '../lib/db.js'
 import { getCircuitState, countRecentEvents, probeCircuit } from '../lib/db.js'
-import chalk from 'chalk'
+import { countPending } from '../lib/drafts.js'
+import { getAuthStatus } from '../lib/gh.js'
+import { bold, dim, red, green, yellow, cyan } from '../lib/color.js'
 
 /**
  * Query fingerprint count and last creation time for a repo from the DB.
@@ -66,13 +68,24 @@ function timeAgo(isoString) {
  * @returns {string}
  */
 function colorCircuitState(state) {
-  if (state === 'closed') return chalk.green('closed') + ' ' + chalk.green('✓')
-  if (state === 'open') return chalk.red('open') + ' ' + chalk.red('✗')
-  return chalk.yellow('half-open') + ' ' + chalk.yellow('~')
+  if (state === 'closed') return green('closed') + ' ' + green('✓')
+  if (state === 'open') return red('open') + ' ' + red('✗')
+  return yellow('half-open') + ' ' + yellow('~')
+}
+
+function maskKey(value) {
+  if (!value || typeof value !== 'string') return null
+  if (value.length <= 4) return '****'
+  return '****' + value.slice(-4)
+}
+
+function formatBudget(val) {
+  if (val === 0 || !val) return 'unlimited'
+  return val.toLocaleString()
 }
 
 export const statusCommand = new Command('status')
-  .description('Show safety status (circuit breaker + rate limits) for the active repo')
+  .description('Show auth, safety, and config status')
   .option('--repo <repo>', 'Repository override (owner/name)')
   .option('--agent <name>', "Check a specific agent's status (default: 'human')", 'human')
   .option('--reset', 'Force-reset the circuit breaker to closed')
@@ -83,19 +96,59 @@ export const statusCommand = new Command('status')
     }
 
     if (!repo) {
-      console.error(chalk.red('No active repo. Set one with: tissues use <owner/repo>'))
+      console.error(red('No active repo. Set one with: tissues config'))
       process.exit(1)
     }
 
+    const repoRoot = findRepoRoot()
+    const config = loadConfig(repoRoot)
     const agent = opts.agent
 
+    // --- Auth ---
+    console.log(bold('Auth'))
+    try {
+      const status = getAuthStatus()
+      const active = status.accounts?.find((a) => a.active)
+      if (active) {
+        console.log(`  GitHub: ${green('✔')} ${active.login}`)
+      } else {
+        console.log(`  GitHub: ${red('✗')} not logged in`)
+      }
+    } catch {
+      console.log(`  GitHub: ${red('✗')} gh CLI not available`)
+    }
+    console.log(`  Active repo: ${cyan(repo)}`)
+
+    // --- AI config ---
+    console.log()
+    console.log(bold('AI'))
+    const aiEnabled = config.ai?.enabled !== false
+    console.log(`  Enabled:  ${aiEnabled ? green('yes') : dim('no')}`)
+    if (aiEnabled) {
+      console.log(`  Provider: ${config.ai?.provider || dim('not set')}`)
+      const providers = ['anthropic', 'openai', 'gemini']
+      const keys = providers.filter((p) => config.ai?.keys?.[p]).map((p) => `${p} (${maskKey(config.ai.keys[p])})`)
+      console.log(`  Keys:     ${keys.length > 0 ? keys.join(', ') : dim('none')}`)
+      const budgets = config.ai?.budgets || {}
+      console.log(`  Budgets:  ${formatBudget(budgets.maxTokensPerRequest)}/req, ${formatBudget(budgets.maxTokensPerHour)}/hr, ${formatBudget(budgets.maxTokensPerDay)}/day`)
+      const routes = config.ai?.routes || []
+      console.log(`  Routes:   ${routes.length > 0 ? `${routes.length} rule${routes.length === 1 ? '' : 's'}` : dim('none')}`)
+    }
+
+    // --- Template ---
+    console.log()
+    console.log(bold('Templates'))
+    console.log(`  Default: ${config.templates?.default || 'default'}`)
+
     // Handle --reset before displaying status
     if (opts.reset) {
       forceReset(repo, agent)
-      console.log(chalk.green(`Circuit breaker reset to closed for ${repo} / ${agent}`))
+      console.log(green(`\nCircuit breaker reset to closed for ${repo} / ${agent}`))
     }
 
-    const config = loadConfig(findRepoRoot())
+    // --- Safety ---
+    console.log()
+    console.log(bold('Safety'))
     const safetyCfg = config.safety ?? {}
 
     const cfg = {
@@ -130,7 +183,7 @@ export const statusCommand = new Command('status')
     const agentHourRemaining = Math.max(0, cfg.maxPerHour - agentHourCount)
     const globalHourRemaining = Math.max(0, cfg.globalMaxPerHour - globalHourCount)
 
-    console.log(`Circuit Breaker: ${colorCircuitState(circuitState)}`)
+    console.log(`  Circuit:    ${colorCircuitState(circuitState)}`)
     if (circuitState === 'open' && circuit.cooldownUntil) {
       const until = new Date(
         circuit.cooldownUntil.endsWith('Z') ? circuit.cooldownUntil : circuit.cooldownUntil + 'Z'
@@ -138,29 +191,38 @@ export const statusCommand = new Command('status')
       const diffMs = until - Date.now()
       if (diffMs > 0) {
         const mins = Math.ceil(diffMs / 60_000)
-        console.log(chalk.dim(`  Cooldown: ${mins} minute${mins === 1 ? '' : 's'} remaining`))
+        console.log(dim(`              Cooldown: ${mins} minute${mins === 1 ? '' : 's'} remaining`))
       }
     }
 
     console.log(
-      `Rate Limit: ${agentHourCount}/${cfg.maxPerHour} per hour` +
-        chalk.dim(` (${agentHourRemaining} remaining)`)
+      `  Rate:       ${agentHourCount}/${cfg.maxPerHour} per hour` +
+        dim(` (${agentHourRemaining} remaining)`)
     )
     console.log(
-      `Burst: ${agentBurstCount}/${cfg.burstLimit} in last ${cfg.burstWindowMinutes} min`
+      `  Burst:      ${agentBurstCount}/${cfg.burstLimit} in last ${cfg.burstWindowMinutes} min`
     )
     console.log(
-      `Global: ${globalHourCount}/${cfg.globalMaxPerHour} per hour` +
-        chalk.dim(` (${globalHourRemaining} remaining)`)
+      `  Global:     ${globalHourCount}/${cfg.globalMaxPerHour} per hour` +
+        dim(` (${globalHourRemaining} remaining)`)
     )
 
     console.log()
-
     if (lastCreatedAt) {
-      console.log(`Last issue created: ${timeAgo(lastCreatedAt)}`)
+      console.log(`Last issue: ${timeAgo(lastCreatedAt)}`)
     } else {
-      console.log(chalk.dim('Last issue created: never'))
+      console.log(dim('Last issue: never'))
     }
 
-    console.log(`Fingerprints stored: ${fingerprintCount}`)
+    console.log(`Fingerprints: ${fingerprintCount}`)
+
+    const pendingCount = countPending(repoRoot)
+    if (pendingCount > 0) {
+      console.log(
+        cyan(`Drafts: ${pendingCount} pending`) +
+          dim(' (run ') + cyan('tissues drafts') + dim(' to manage)'),
+      )
+    } else {
+      console.log(dim('Drafts: empty'))
+    }
   })

package/src/commands/templates.js

@@ -0,0 +1,157 @@
+import { Command } from 'commander'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { dim, red, green } from '../lib/color.js'
+import { select, input, editor } from '@inquirer/prompts'
+import { listTemplates, loadTemplate, builtInTemplateKeys } from '../lib/templates.js'
+import { findRepoRoot, loadConfig } from '../lib/defaults.js'
+import { theme } from '../lib/theme.js'
+
+function isCancelled(err) {
+  return err?.name === 'ExitPromptError' || err?.message?.includes('User force closed')
+}
+
+async function promptOrBack(fn) {
+  try { return await fn() } catch (err) { if (isCancelled(err)) return Symbol.for('back'); throw err }
+}
+
+function userTemplateDir() {
+  return path.join(os.homedir(), '.config', 'tissues', 'templates')
+}
+
+export const templatesCommand = new Command('templates')
+  .description('Manage issue templates (view, edit, create)')
+  .action(async () => {
+    while (true) {
+      const repoRoot = findRepoRoot()
+      const templates = listTemplates(repoRoot)
+      const builtInKeys = builtInTemplateKeys()
+
+      // Deduplicate by key
+      const seen = new Set()
+      const choices = []
+      for (const tpl of templates) {
+        if (!seen.has(tpl.key)) {
+          seen.add(tpl.key)
+          choices.push({
+            name: `${tpl.key.padEnd(14)} ${dim(tpl.name)} ${dim(`(${tpl.source})`)}`,
+            value: tpl.key,
+          })
+        }
+      }
+      choices.push({ name: green('Create New Template'), value: '_create' })
+      choices.push({ name: dim('Done'), value: 'done' })
+
+      const chosen = await promptOrBack(() => select({ message: 'Templates', choices, theme }))
+      if (chosen === Symbol.for('back') || chosen === 'done') break
+
+      if (chosen === '_create') {
+        await createNewTemplate(builtInKeys, seen)
+        continue
+      }
+
+      // View / edit existing template
+      await editTemplate(chosen, repoRoot, builtInKeys)
+      console.log()
+    }
+  })
+
+async function createNewTemplate(builtInKeys, existingKeys) {
+  const name = await promptOrBack(() => input({ message: 'Template name (lowercase, no spaces)', theme }))
+  if (name === Symbol.for('back') || !name) return
+
+  const key = name.trim().toLowerCase().replace(/\s+/g, '-')
+  if (!key) return
+
+  // Block reusing exact built-in names
+  if (builtInKeys.includes(key)) {
+    console.log(red(`  "${key}" is a built-in template. Use edit to customize it instead.`))
+    return
+  }
+
+  // Block duplicates
+  if (existingKeys.has(key)) {
+    console.log(red(`  Template "${key}" already exists.`))
+    return
+  }
+
+  const body = await promptOrBack(() =>
+    editor({
+      message: 'Template body (opens editor)',
+      default: `## ${key.charAt(0).toUpperCase() + key.slice(1)}\n\n{{description}}\n\n## Details\n\n`,
+      theme,
+    }),
+  )
+  if (body === Symbol.for('back') || !body) return
+
+  const dir = userTemplateDir()
+  fs.mkdirSync(dir, { recursive: true })
+  const filePath = path.join(dir, `${key}.md`)
+  fs.writeFileSync(filePath, body, 'utf8')
+  console.log(green(`  ✔ Template "${key}" created: ${filePath}`))
+}
+
+async function editTemplate(key, repoRoot, builtInKeys) {
+  let tpl
+  try {
+    tpl = loadTemplate(key, repoRoot)
+  } catch (err) {
+    console.log(red(`  ${err.message}`))
+    return
+  }
+
+  console.log(`\n  ${tpl.name} ${dim(`(${tpl.source})`)}`)
+  console.log(dim('  ─'.repeat(20)))
+  // Show preview (truncated)
+  const preview = tpl.body.split('\n').slice(0, 8).join('\n')
+  console.log(dim(preview))
+  if (tpl.body.split('\n').length > 8) console.log(dim('  ...'))
+  console.log()
+
+  const actionChoices = [
+    { name: 'Edit', value: 'edit' },
+  ]
+  if (builtInKeys.includes(key) && tpl.source === 'built-in') {
+    actionChoices[0] = { name: 'Customize (creates user copy)', value: 'edit' }
+  }
+  // Only allow deleting user templates
+  const userFile = path.join(userTemplateDir(), `${key}.md`)
+  if (fs.existsSync(userFile)) {
+    actionChoices.push({ name: red('Delete user copy'), value: 'delete' })
+  }
+  actionChoices.push({ name: dim('Back'), value: 'back' })
+
+  const action = await promptOrBack(() => select({ message: tpl.name, choices: actionChoices, theme }))
+  if (action === Symbol.for('back') || action === 'back') return
+
+  if (action === 'delete') {
+    fs.unlinkSync(userFile)
+    console.log(green(`  ✔ User copy of "${key}" deleted`))
+    if (builtInKeys.includes(key)) {
+      console.log(dim(`  Built-in "${key}" will be used again.`))
+    }
+    return
+  }
+
+  // Edit — open in editor with current body
+  const newBody = await promptOrBack(() =>
+    editor({
+      message: `Edit ${key}`,
+      default: tpl.body,
+      theme,
+    }),
+  )
+  if (newBody === Symbol.for('back') || !newBody) return
+
+  // Save as user template (even if editing a built-in — creates a user override)
+  const dir = userTemplateDir()
+  fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(path.join(dir, `${key}.md`), newBody, 'utf8')
+
+  if (tpl.source === 'built-in') {
+    console.log(green(`  ✔ User copy of "${key}" created (overrides built-in)`))
+  } else {
+    console.log(green(`  ✔ Template "${key}" updated`))
+  }
+}

package/src/lib/ai/adapters/anthropic.js

@@ -0,0 +1,52 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'claude-haiku-4-5-20251001'
+const DEFAULT_MAX_TOKENS = 4096
+const API_URL = 'https://api.anthropic.com/v1/messages'
+
+export class AnthropicAdapter extends BaseAdapter {
+  get name() {
+    return 'anthropic'
+  }
+
+  async complete(messages, opts = {}) {
+    const apiKey = this.config.apiKey
+    if (!apiKey) throw new Error('Anthropic API key not configured (ai.keys.anthropic)')
+
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    // Anthropic Messages API uses a separate `system` param
+    const systemMsg = messages.find((m) => m.role === 'system')
+    const userMessages = messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({ role: m.role, content: m.content }))
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: userMessages,
+    }
+    if (systemMsg) body.system = systemMsg.content
+
+    const res = await fetch(API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Anthropic API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const textBlock = data.content?.find((b) => b.type === 'text')
+    if (!textBlock) throw new Error('Anthropic returned no text content')
+    return textBlock.text
+  }
+}

package/src/lib/ai/adapters/base.js

@@ -0,0 +1,45 @@
+/**
+ * Base adapter interface for AI providers.
+ * Each adapter owns its own HTTP calls — callers never touch fetch.
+ */
+export class BaseAdapter {
+  constructor(config) {
+    this.config = config
+  }
+
+  /** @returns {string} provider name (e.g. 'anthropic', 'openai', 'gemini') */
+  get name() {
+    throw new Error('not implemented')
+  }
+
+  /**
+   * Check if this adapter has enough configuration to make requests.
+   * Override in adapters that don't need an API key.
+   * @returns {boolean}
+   */
+  isConfigured() {
+    return !!this.config.apiKey
+  }
+
+  /**
+   * Sanitize API error response body — strip anything that looks like an API key
+   * to prevent accidental leakage in error messages or logs.
+   */
+  sanitizeErrorBody(text, maxLen = 200) {
+    if (!text) return ''
+    // Strip anything that looks like an API key (sk-*, gm-*, key-*, etc.)
+    const cleaned = text.replace(/\b(sk-|gm-|key-|Bearer\s+)[A-Za-z0-9_-]{8,}\b/gi, '[REDACTED]')
+    return cleaned.length > maxLen ? cleaned.slice(0, maxLen) + '...' : cleaned
+  }
+
+  /**
+   * Send a completion request.
+   *
+   * @param {Array<{ role: 'user'|'system', content: string }>} messages
+   * @param {{ model?: string, maxTokens?: number }} opts
+   * @returns {Promise<string>} extracted text response
+   */
+  async complete(messages, opts = {}) {
+    throw new Error('not implemented')
+  }
+}

package/src/lib/ai/adapters/command.js

@@ -0,0 +1,68 @@
+import { execFile } from 'node:child_process'
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 60_000
+
+export class CommandAdapter extends BaseAdapter {
+  get name() {
+    return 'command'
+  }
+
+  isConfigured() {
+    return !!this.config.command
+  }
+
+  async complete(messages, opts = {}) {
+    const command = this.config.command
+    if (!command) throw new Error('Command not configured (ai.command)')
+
+    const timeoutMs = this.config.timeout
+      || (opts.maxTokens
+        ? Math.max(DEFAULT_TIMEOUT_MS, opts.maxTokens * 15) // rough heuristic
+        : DEFAULT_TIMEOUT_MS)
+
+    // Extract the last user message as the prompt text
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    // Check if command uses {prompt} placeholder (arg mode) or JSON stdin
+    const usesPlaceholder = command.includes('{prompt}')
+
+    const resolvedCommand = usesPlaceholder
+      ? command.replace(/\{prompt\}/g, promptText)
+      : command
+
+    const payload = usesPlaceholder ? null : JSON.stringify({
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      model: opts.model || null,
+      maxTokens: opts.maxTokens || 4096,
+    })
+
+    return new Promise((resolve, reject) => {
+      // Always use shell to support quoted args, pipes, builtins, etc.
+      const shell = process.platform === 'win32' ? true : '/bin/sh'
+      const child = execFile('sh', ['-c', resolvedCommand], {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024, // 10 MB
+        shell: false, // we're already wrapping in sh -c
+      }, (err, stdout, stderr) => {
+        if (err) {
+          const msg = stderr?.trim() || err.message
+          reject(new Error(`Command adapter error: ${msg}`))
+          return
+        }
+        const text = stdout.trim()
+        if (!text) {
+          reject(new Error('Command adapter returned no output'))
+          return
+        }
+        resolve(text)
+      })
+
+      if (payload) {
+        child.stdin.write(payload)
+      }
+      child.stdin.end()
+    })
+  }
+}

package/src/lib/ai/adapters/gemini.js

@@ -0,0 +1,56 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'gemini-2.0-flash'
+const DEFAULT_MAX_TOKENS = 4096
+const API_BASE = 'https://generativelanguage.googleapis.com/v1beta/models'
+
+export class GeminiAdapter extends BaseAdapter {
+  get name() {
+    return 'gemini'
+  }
+
+  async complete(messages, opts = {}) {
+    const apiKey = this.config.apiKey
+    if (!apiKey) throw new Error('Gemini API key not configured (ai.keys.gemini)')
+
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    // Gemini uses systemInstruction + contents
+    const systemMsg = messages.find((m) => m.role === 'system')
+    const userMessages = messages.filter((m) => m.role !== 'system')
+
+    const body = {
+      contents: userMessages.map((m) => ({
+        role: m.role === 'user' ? 'user' : 'model',
+        parts: [{ text: m.content }],
+      })),
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+      },
+    }
+    if (systemMsg) {
+      body.systemInstruction = { parts: [{ text: systemMsg.content }] }
+    }
+
+    const url = `${API_BASE}/${model}:generateContent`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': apiKey,
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Gemini API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const text = data.candidates?.[0]?.content?.parts?.[0]?.text
+    if (!text) throw new Error('Gemini returned no text content')
+    return text
+  }
+}

package/src/lib/ai/adapters/ollama.js

@@ -0,0 +1,60 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MODEL = 'llama3.2'
+const DEFAULT_MAX_TOKENS = 4096
+const DEFAULT_BASE_URL = 'http://localhost:11434'
+
+export class OllamaAdapter extends BaseAdapter {
+  get name() {
+    return 'ollama'
+  }
+
+  isConfigured() {
+    return true // no API key needed — server just needs to be running
+  }
+
+  async complete(messages, opts = {}) {
+    const baseUrl = (this.config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')
+    const model = opts.model || DEFAULT_MODEL
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    }
+
+    const url = `${baseUrl}/v1/chat/completions`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`Ollama API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const content = data.choices?.[0]?.message?.content
+    if (!content) throw new Error('Ollama returned no content')
+    return content
+  }
+}
+
+/**
+ * List models installed on an Ollama server.
+ *
+ * @param {string} [baseUrl] - Ollama server URL (default: http://localhost:11434)
+ * @returns {Promise<string[]>} array of model names
+ */
+export async function listModels(baseUrl) {
+  const url = `${(baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '')}/api/tags`
+  const res = await fetch(url)
+  if (!res.ok) {
+    throw new Error(`Ollama /api/tags error ${res.status}`)
+  }
+  const data = await res.json()
+  return (data.models || []).map((m) => m.name)
+}

package/src/lib/ai/adapters/openai-compat.js

@@ -0,0 +1,51 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_MAX_TOKENS = 4096
+
+export class OpenAICompatAdapter extends BaseAdapter {
+  get name() {
+    return 'openai-compat'
+  }
+
+  isConfigured() {
+    return !!this.config.baseUrl
+  }
+
+  async complete(messages, opts = {}) {
+    const baseUrl = this.config.baseUrl
+    if (!baseUrl) throw new Error('OpenAI-compatible base URL not configured (ai.custom.url)')
+
+    const model = opts.model
+    if (!model) throw new Error('Model must be configured for openai-compat provider (ai.models.openai-compat)')
+
+    const maxTokens = opts.maxTokens || DEFAULT_MAX_TOKENS
+
+    const body = {
+      model,
+      max_tokens: maxTokens,
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+    }
+
+    const url = `${baseUrl.replace(/\/+$/, '')}/v1/chat/completions`
+    const headers = { 'Content-Type': 'application/json' }
+    if (this.config.apiKey) {
+      headers.Authorization = `Bearer ${this.config.apiKey}`
+    }
+
+    const res = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    })
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '')
+      throw new Error(`OpenAI-compatible API error ${res.status}: ${this.sanitizeErrorBody(text)}`)
+    }
+
+    const data = await res.json()
+    const content = data.choices?.[0]?.message?.content
+    if (!content) throw new Error('OpenAI-compatible endpoint returned no content')
+    return content
+  }
+}