@swarmclawai/swarmclaw 0.2.0

package/src/lib/providers/index.ts

@@ -0,0 +1,351 @@
+import { streamClaudeCliChat } from './claude-cli'
+import { streamCodexCliChat } from './codex-cli'
+import { streamOpenCodeCliChat } from './opencode-cli'
+import { streamOpenAiChat } from './openai'
+import { streamOllamaChat } from './ollama'
+import { streamAnthropicChat } from './anthropic'
+import { streamOpenClawChat } from './openclaw'
+import type { ProviderInfo, ProviderConfig as CustomProviderConfig } from '../../types'
+
+const RETRYABLE_STATUS_CODES = [401, 429, 500, 502, 503]
+
+export interface ProviderHandler {
+  streamChat: (opts: StreamChatOptions) => Promise<string>
+}
+
+export interface StreamChatOptions {
+  session: any
+  message: string
+  imagePath?: string
+  apiKey?: string | null
+  systemPrompt?: string
+  write: (data: string) => void
+  active: Map<string, any>
+  loadHistory: (sessionId: string) => any[]
+}
+
+interface BuiltinProviderConfig extends ProviderInfo {
+  handler: ProviderHandler
+}
+
+const PROVIDERS: Record<string, BuiltinProviderConfig> = {
+  'claude-cli': {
+    id: 'claude-cli',
+    name: 'Claude Code CLI',
+    models: ['claude-sonnet-4-6', 'claude-opus-4-6', 'claude-haiku-4-5-20251001', 'claude-sonnet-4-5-20250514'],
+    requiresApiKey: false,
+    requiresEndpoint: false,
+    handler: { streamChat: streamClaudeCliChat },
+  },
+  'codex-cli': {
+    id: 'codex-cli',
+    name: 'OpenAI Codex CLI',
+    models: ['gpt-5.3-codex', 'gpt-5.2-codex', 'gpt-5.1-codex', 'gpt-5-codex', 'gpt-5-codex-mini'],
+    requiresApiKey: false,
+    requiresEndpoint: false,
+    handler: { streamChat: streamCodexCliChat },
+  },
+  openai: {
+    id: 'openai',
+    name: 'OpenAI',
+    models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'gpt-4.1-mini', 'gpt-4.1-nano', 'o3', 'o3-mini', 'o4-mini'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    handler: { streamChat: streamOpenAiChat },
+  },
+  anthropic: {
+    id: 'anthropic',
+    name: 'Anthropic',
+    models: ['claude-sonnet-4-6', 'claude-opus-4-6', 'claude-haiku-4-5-20251001'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    handler: { streamChat: streamAnthropicChat },
+  },
+  openclaw: {
+    id: 'openclaw',
+    name: 'OpenClaw',
+    models: ['default'],
+    requiresApiKey: true,
+    requiresEndpoint: true,
+    defaultEndpoint: 'http://localhost:18789',
+    handler: { streamChat: streamOpenClawChat },
+  },
+  'opencode-cli': {
+    id: 'opencode-cli',
+    name: 'OpenCode CLI',
+    models: ['claude-sonnet-4-6', 'gpt-4.1', 'gemini-2.5-pro', 'gemini-2.5-flash'],
+    requiresApiKey: false,
+    requiresEndpoint: false,
+    handler: { streamChat: streamOpenCodeCliChat },
+  },
+  google: {
+    id: 'google',
+    name: 'Google Gemini',
+    models: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://generativelanguage.googleapis.com/v1beta/openai',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  deepseek: {
+    id: 'deepseek',
+    name: 'DeepSeek',
+    models: ['deepseek-chat', 'deepseek-reasoner'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.deepseek.com/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.deepseek.com/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  groq: {
+    id: 'groq',
+    name: 'Groq',
+    models: ['llama-3.3-70b-versatile', 'deepseek-r1-distill-llama-70b', 'qwen-qwq-32b', 'gemma2-9b-it'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.groq.com/openai/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.groq.com/openai/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  together: {
+    id: 'together',
+    name: 'Together AI',
+    models: ['meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8', 'deepseek-ai/DeepSeek-R1', 'Qwen/Qwen2.5-72B-Instruct'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.together.xyz/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.together.xyz/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  mistral: {
+    id: 'mistral',
+    name: 'Mistral AI',
+    models: ['mistral-large-latest', 'mistral-small-latest', 'magistral-medium-2506', 'devstral-small-latest'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.mistral.ai/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.mistral.ai/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  xai: {
+    id: 'xai',
+    name: 'xAI (Grok)',
+    models: ['grok-3', 'grok-3-fast', 'grok-3-mini', 'grok-3-mini-fast'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.x.ai/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.x.ai/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  fireworks: {
+    id: 'fireworks',
+    name: 'Fireworks AI',
+    models: ['accounts/fireworks/models/deepseek-r1-0528', 'accounts/fireworks/models/llama-v3p3-70b-instruct', 'accounts/fireworks/models/qwen3-235b-a22b'],
+    requiresApiKey: true,
+    requiresEndpoint: false,
+    defaultEndpoint: 'https://api.fireworks.ai/inference/v1',
+    handler: {
+      streamChat: (opts) => {
+        const patchedSession = {
+          ...opts.session,
+          apiEndpoint: opts.session.apiEndpoint || 'https://api.fireworks.ai/inference/v1',
+        }
+        return streamOpenAiChat({ ...opts, session: patchedSession })
+      },
+    },
+  },
+  ollama: {
+    id: 'ollama',
+    name: 'Ollama',
+    models: [
+      'qwen3.5', 'qwen3-coder-next', 'qwen3-coder', 'qwen3-next', 'qwen3-vl',
+      'glm-5', 'glm-4.7', 'glm-4.6',
+      'kimi-k2.5', 'kimi-k2', 'kimi-k2-thinking',
+      'minimax-m2.5', 'minimax-m2.1', 'minimax-m2',
+      'deepseek-v3.2', 'deepseek-r1',
+      'gemini-3-flash-preview', 'gemma3',
+      'devstral-2', 'devstral-small-2', 'ministral-3', 'mistral-large-3',
+      'gpt-oss', 'cogito-2.1', 'rnj-1', 'nemotron-3-nano',
+      'llama3.3', 'llama3.2', 'llama3.1',
+    ],
+    requiresApiKey: false,
+    optionalApiKey: true,
+    requiresEndpoint: true,
+    defaultEndpoint: 'http://localhost:11434',
+    handler: { streamChat: streamOllamaChat },
+  },
+}
+
+/** Merge built-in providers with custom providers from storage */
+function getCustomProviders(): Record<string, CustomProviderConfig> {
+  try {
+    const { loadProviderConfigs } = require('../server/storage')
+    return loadProviderConfigs() as Record<string, CustomProviderConfig>
+  } catch {
+    return {}
+  }
+}
+
+function getModelOverrides(): Record<string, string[]> {
+  try {
+    const { loadModelOverrides } = require('../server/storage')
+    return loadModelOverrides()
+  } catch {
+    return {}
+  }
+}
+
+export function getProviderList(): ProviderInfo[] {
+  const overrides = getModelOverrides()
+  const builtins = Object.values(PROVIDERS)
+    .filter(({ id }) => id !== 'openclaw')
+    .map(({ handler, ...info }) => ({
+      ...info,
+      models: overrides[info.id] || info.models,
+    }))
+  const customs = Object.values(getCustomProviders())
+    .filter((c) => c.isEnabled)
+    .map((c) => ({
+      id: c.id as any,
+      name: c.name,
+      models: c.models,
+      requiresApiKey: c.requiresApiKey,
+      requiresEndpoint: false,
+      defaultEndpoint: c.baseUrl,
+    }))
+  return [...builtins, ...customs]
+}
+
+export function getProvider(id: string): BuiltinProviderConfig | null {
+  if (PROVIDERS[id]) return PROVIDERS[id]
+  // Check custom providers — they use OpenAI-compatible handler with custom baseUrl
+  const customs = getCustomProviders()
+  const custom = customs[id]
+  if (custom?.isEnabled) {
+    return {
+      id: custom.id as any,
+      name: custom.name,
+      models: custom.models,
+      requiresApiKey: custom.requiresApiKey,
+      requiresEndpoint: false,
+      handler: {
+        streamChat: (opts) => {
+          // Custom providers use OpenAI handler with custom baseUrl
+          const patchedSession = { ...opts.session, apiEndpoint: custom.baseUrl }
+          return streamOpenAiChat({ ...opts, session: patchedSession })
+        },
+      },
+    }
+  }
+  return null
+}
+
+/**
+ * Stream chat with automatic failover to fallback credentials on retryable errors.
+ * Falls back through fallbackCredentialIds on 401/429/500/502/503 errors.
+ */
+export async function streamChatWithFailover(
+  opts: StreamChatOptions & { fallbackCredentialIds?: string[] },
+): Promise<string> {
+  const provider = getProvider(opts.session.provider)
+  if (!provider) throw new Error(`Unknown provider: ${opts.session.provider}`)
+
+  const credentialIds = [
+    opts.session.credentialId,
+    ...(opts.fallbackCredentialIds || []),
+  ].filter(Boolean) as string[]
+
+  // If no fallbacks, just call directly
+  if (credentialIds.length <= 1) {
+    return provider.handler.streamChat(opts)
+  }
+
+  let lastError: any = null
+
+  for (let i = 0; i < credentialIds.length; i++) {
+    const credId = credentialIds[i]
+    try {
+      // Resolve API key for this credential
+      let apiKey: string | null = opts.apiKey || null
+      if (credId && i > 0) {
+        // Need to decrypt fallback credential
+        const { loadCredentials, decryptKey } = require('../server/storage')
+        const creds = loadCredentials()
+        const cred = creds[credId]
+        if (cred?.encryptedKey) {
+          try { apiKey = decryptKey(cred.encryptedKey) } catch { /* skip */ }
+        }
+      }
+
+      const result = await provider.handler.streamChat({
+        ...opts,
+        apiKey,
+      })
+      return result // success
+    } catch (err: any) {
+      lastError = err
+      const statusCode = err.status || err.statusCode || 0
+      const isRetryable = RETRYABLE_STATUS_CODES.includes(statusCode)
+        || err.message?.includes('rate limit')
+        || err.message?.includes('Rate limit')
+        || err.message?.includes('429')
+        || err.message?.includes('401')
+
+      if (isRetryable && i < credentialIds.length - 1) {
+        console.log(`[failover] Credential ${credId} failed (${statusCode || err.message}), trying fallback...`)
+        // Send a metadata event to inform the client
+        opts.write(`data: ${JSON.stringify({
+          t: 'md',
+          text: JSON.stringify({ failover: { from: credId, reason: err.message?.slice(0, 100) } }),
+        })}\n\n`)
+        continue
+      }
+      throw err
+    }
+  }
+
+  throw lastError || new Error('All credentials exhausted')
+}

package/src/lib/providers/ollama.ts

@@ -0,0 +1,131 @@
+import fs from 'fs'
+import http from 'http'
+import https from 'https'
+import type { StreamChatOptions } from './index'
+
+const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
+const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
+
+export function streamOllamaChat({ session, message, imagePath, apiKey, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+  return new Promise((resolve) => {
+    const messages = buildMessages(session, message, imagePath, loadHistory)
+    const model = session.model || 'llama3'
+    // Cloud: no endpoint but API key present → use Ollama cloud
+    const endpoint = session.apiEndpoint || (apiKey ? 'https://ollama.com' : 'http://localhost:11434')
+
+    const parsed = new URL(endpoint)
+    const isHttps = parsed.protocol === 'https:'
+    const transport = isHttps ? https : http
+    const defaultPort = isHttps ? 443 : 11434
+
+    const payload = JSON.stringify({
+      model,
+      messages,
+      stream: true,
+    })
+
+    const abortController = { aborted: false }
+    let fullResponse = ''
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+    if (apiKey) {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+
+    const apiReq = transport.request({
+      hostname: parsed.hostname,
+      port: parsed.port || defaultPort,
+      path: '/api/chat',
+      method: 'POST',
+      headers,
+    }, (apiRes) => {
+      if (apiRes.statusCode !== 200) {
+        let errBody = ''
+        apiRes.on('data', (c: Buffer) => errBody += c)
+        apiRes.on('end', () => {
+          console.error(`[${session.id}] ollama error ${apiRes.statusCode}:`, errBody.slice(0, 200))
+          write(`data: ${JSON.stringify({ t: 'err', text: `Ollama error (${apiRes.statusCode}): ${errBody.slice(0, 100)}` })}\n\n`)
+          active.delete(session.id)
+          resolve(fullResponse)
+        })
+        return
+      }
+
+      let buf = ''
+      apiRes.on('data', (chunk: Buffer) => {
+        if (abortController.aborted) return
+        buf += chunk.toString()
+        const lines = buf.split('\n')
+        buf = lines.pop()!
+
+        for (const line of lines) {
+          if (!line.trim()) continue
+          try {
+            const parsed = JSON.parse(line)
+            const content = parsed.message?.content
+            if (content) {
+              fullResponse += content
+              write(`data: ${JSON.stringify({ t: 'd', text: content })}\n\n`)
+            }
+          } catch {}
+        }
+      })
+
+      apiRes.on('end', () => {
+        active.delete(session.id)
+        resolve(fullResponse)
+      })
+    })
+
+    active.set(session.id, { kill: () => { abortController.aborted = true; apiReq.destroy() } })
+
+    apiReq.on('error', (e: NodeJS.ErrnoException) => {
+      console.error(`[${session.id}] ollama request error:`, e.message)
+      let errMsg = e.message
+      if (e.code === 'ECONNREFUSED') {
+        errMsg = `Cannot connect to Ollama at ${endpoint}. Is Ollama running?`
+      }
+      write(`data: ${JSON.stringify({ t: 'err', text: errMsg })}\n\n`)
+      active.delete(session.id)
+      resolve(fullResponse)
+    })
+
+    apiReq.end(payload)
+  })
+}
+
+function fileToOllamaMsg(text: string, filePath?: string): { content: string; images?: string[] } {
+  if (!filePath || !fs.existsSync(filePath)) return { content: text }
+  if (IMAGE_EXTS.test(filePath)) {
+    const data = fs.readFileSync(filePath).toString('base64')
+    return { content: text, images: [data] }
+  }
+  if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
+    try {
+      const fileContent = fs.readFileSync(filePath, 'utf-8')
+      const name = filePath.split('/').pop() || 'file'
+      return { content: `[Attached file: ${name}]\n\n${fileContent}\n\n${text}` }
+    } catch { return { content: text } }
+  }
+  return { content: `[Attached file: ${filePath.split('/').pop()}]\n\n${text}` }
+}
+
+function buildMessages(session: any, message: string, imagePath: string | undefined, loadHistory: (id: string) => any[]) {
+  const msgs: Array<{ role: string; content: string; images?: string[] }> = []
+
+  if (loadHistory) {
+    const history = loadHistory(session.id)
+    for (const m of history) {
+      if (m.role === 'user' && m.imagePath) {
+        msgs.push({ role: 'user', ...fileToOllamaMsg(m.text, m.imagePath) })
+      } else {
+        msgs.push({ role: m.role, content: m.text })
+      }
+    }
+  }
+
+  msgs.push({ role: 'user', ...fileToOllamaMsg(message, imagePath) })
+  return msgs
+}

package/src/lib/providers/openai.ts

@@ -0,0 +1,164 @@
+import fs from 'fs'
+import type { StreamChatOptions } from './index'
+
+const IMAGE_EXTS = /\.(png|jpg|jpeg|gif|webp|bmp)$/i
+const TEXT_EXTS = /\.(txt|md|csv|json|xml|html|js|ts|tsx|jsx|py|go|rs|java|c|cpp|h|yml|yaml|toml|env|log|sh|sql|css|scss)$/i
+
+function fileToContentParts(filePath: string): any[] {
+  if (!filePath || !fs.existsSync(filePath)) return []
+  if (IMAGE_EXTS.test(filePath)) {
+    const data = fs.readFileSync(filePath).toString('base64')
+    const ext = filePath.split('.').pop()?.toLowerCase() || 'png'
+    const mimeType = ext === 'jpg' ? 'image/jpeg' : `image/${ext}`
+    return [{ type: 'image_url', image_url: { url: `data:${mimeType};base64,${data}` } }]
+  }
+  if (TEXT_EXTS.test(filePath) || filePath.endsWith('.pdf')) {
+    try {
+      const text = fs.readFileSync(filePath, 'utf-8')
+      const name = filePath.split('/').pop() || 'file'
+      return [{ type: 'text', text: `[Attached file: ${name}]\n\n${text}` }]
+    } catch { return [] }
+  }
+  return [{ type: 'text', text: `[Attached file: ${filePath.split('/').pop()}]` }]
+}
+
+export function streamOpenAiChat({ session, message, imagePath, apiKey, systemPrompt, write, active, loadHistory }: StreamChatOptions): Promise<string> {
+  return new Promise(async (resolve) => {
+    const messages = buildMessages(session, message, imagePath, systemPrompt, loadHistory)
+    const model = session.model || 'gpt-4o'
+
+    const payload = JSON.stringify({
+      model,
+      messages,
+      stream: true,
+    })
+
+    let fullResponse = ''
+
+    // Support custom base URLs for custom providers
+    const baseUrl = session.apiEndpoint || 'https://api.openai.com/v1'
+    const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`
+
+    // OpenClaw endpoints behind Hostinger's proxy use express.json() middleware
+    // which consumes the request body before http-proxy-middleware can forward it.
+    // Sending as text/plain bypasses the body parser while the gateway still parses JSON.
+    const contentType = session.contentType || 'application/json'
+
+    const abortController = new AbortController()
+    active.set(session.id, { kill: () => abortController.abort() })
+
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': contentType,
+        },
+        body: payload,
+        signal: abortController.signal,
+      })
+
+      // Detect HTML responses (e.g. landing page returned instead of API)
+      const resContentType = res.headers.get('content-type') || ''
+      if (resContentType.includes('text/html')) {
+        console.error(`[${session.id}] received HTML instead of API response from ${baseUrl} (provider: ${session.provider})`)
+        write(`data: ${JSON.stringify({ t: 'err', text: 'Received HTML instead of API response. The endpoint may be misconfigured or returning a landing page.' })}\n\n`)
+        active.delete(session.id)
+        resolve(fullResponse)
+        return
+      }
+
+      if (!res.ok) {
+        const errBody = await res.text().catch(() => '')
+        console.error(`[${session.id}] openai error ${res.status}:`, errBody.slice(0, 200))
+        let errMsg = `API error (${res.status})`
+        try {
+          const parsed = JSON.parse(errBody)
+          if (parsed.error?.message) errMsg = parsed.error.message
+          else if (parsed.message) errMsg = parsed.message
+          else if (parsed.detail) errMsg = parsed.detail
+        } catch {}
+        write(`data: ${JSON.stringify({ t: 'err', text: errMsg })}\n\n`)
+        active.delete(session.id)
+        resolve(fullResponse)
+        return
+      }
+
+      if (!res.body) {
+        console.error(`[${session.id}] no response body from ${baseUrl}`)
+        active.delete(session.id)
+        resolve(fullResponse)
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buf = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        if (abortController.signal.aborted) break
+
+        buf += decoder.decode(value, { stream: true })
+        const lines = buf.split('\n')
+        buf = lines.pop()!
+
+        for (const line of lines) {
+          if (!line.startsWith('data: ')) continue
+          const data = line.slice(6).trim()
+          if (data === '[DONE]') continue
+          try {
+            const parsed = JSON.parse(data)
+            const delta = parsed.choices?.[0]?.delta?.content
+            if (delta) {
+              fullResponse += delta
+              write(`data: ${JSON.stringify({ t: 'd', text: delta })}\n\n`)
+            }
+          } catch {}
+        }
+      }
+
+      if (!fullResponse) {
+        console.error(`[${session.id}] openai stream ended with no content (provider: ${session.provider}, endpoint: ${baseUrl})`)
+      }
+    } catch (err: any) {
+      if (err.name !== 'AbortError') {
+        console.error(`[${session.id}] openai request error:`, err.message)
+        write(`data: ${JSON.stringify({ t: 'err', text: `Connection failed: ${err.message}` })}\n\n`)
+      }
+    } finally {
+      active.delete(session.id)
+      resolve(fullResponse)
+    }
+  })
+}
+
+function buildMessages(session: any, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => any[]) {
+  const msgs: Array<{ role: string; content: any }> = []
+
+  if (systemPrompt) {
+    msgs.push({ role: 'system', content: systemPrompt })
+  }
+
+  if (loadHistory) {
+    const history = loadHistory(session.id)
+    for (const m of history) {
+      if (m.role === 'user' && m.imagePath) {
+        const parts = fileToContentParts(m.imagePath)
+        msgs.push({ role: 'user', content: [...parts, { type: 'text', text: m.text }] })
+      } else {
+        msgs.push({ role: m.role, content: m.text })
+      }
+    }
+  }
+
+  // Current message with optional attachment
+  if (imagePath) {
+    const parts = fileToContentParts(imagePath)
+    msgs.push({ role: 'user', content: [...parts, { type: 'text', text: message }] })
+  } else {
+    msgs.push({ role: 'user', content: message })
+  }
+  return msgs
+}