@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/lib/plugin-folder.test.mjs

@@ -0,0 +1,145 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { isBinaryPath, loadPluginFolder } from './plugin-folder.ts'
+
+const MANIFEST = JSON.stringify({
+  id: 'demo-plugin',
+  name: 'Demo plugin',
+  version: '1.0.0',
+  apiVersion: 1,
+  entry: 'main.js',
+  stylesheet: 'main.css',
+  capabilities: ['ui.commands'],
+})
+
+test('a picked folder drops its own name and keeps the file layout', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/main.js', content: 'maxcode.log("hi")' },
+    { path: 'demo/styles/main.css', content: '.a{}' },
+    { path: 'demo/assets/icon.bin', content: new Uint8Array([1, 2, 3]) },
+  ])
+  assert.deepEqual(Object.keys(folder.files).sort(), ['assets/icon.bin', 'main.js', 'styles/main.css'])
+  assert.equal(folder.entry, 'main.js')
+  assert.equal(folder.stylesheet, 'styles/main.css')
+})
+
+test('a loose file pick keeps its flat names and needs no stylesheet', () => {
+  const folder = loadPluginFolder([{ path: 'main.js', content: '' }])
+  assert.equal(folder.entry, 'main.js')
+  assert.equal(folder.stylesheet, 'main.css')
+  assert.equal(folder.manifest, undefined)
+})
+
+test('the folder manifest.json seeds the form and never becomes a package file', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/manifest.json', content: MANIFEST },
+    { path: 'demo/main.js', content: '' },
+  ])
+  assert.equal(folder.manifest?.id, 'demo-plugin')
+  assert.deepEqual(folder.manifest?.domains, [])
+  assert.equal('manifest.json' in folder.files, false)
+})
+
+test('a folder without an entry file is rejected with a readable reason', () => {
+  assert.throws(() => loadPluginFolder([{ path: 'demo/main.css', content: '.a{}' }]), /\.js entry/)
+  assert.throws(() => loadPluginFolder([{ path: 'demo/manifest.json', content: 'not json' }]), /entry/i)
+})
+
+test('a broken manifest.json is reported without costing the load', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/main.js', content: 'maxcode.log("hi")' },
+    { path: 'demo/manifest.json', content: '{oops' },
+  ])
+  assert.equal(folder.entry, 'main.js')
+  assert.equal(folder.manifest, undefined)
+  assert.match(folder.manifestError, /valid JSON/)
+  const incomplete = loadPluginFolder([
+    { path: 'demo/main.js', content: '' },
+    { path: 'demo/manifest.json', content: '{"id":"x"}' },
+  ])
+  assert.equal(incomplete.manifest, undefined)
+  assert.match(incomplete.manifestError, /plugin id/)
+})
+
+test('the folder manifest decides the entry, so a folder of many files picks the declared one', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/manifest.json', content: JSON.stringify({ ...JSON.parse(MANIFEST), entry: 'index.js', stylesheet: 'theme.css' }) },
+    { path: 'demo/index.js', content: 'maxcode.log(1)' },
+    { path: 'demo/theme.css', content: '.a{}' },
+  ])
+  assert.equal(folder.entry, 'index.js')
+  assert.equal(folder.stylesheet, 'theme.css')
+})
+
+test('a folder with a second script is refused with the reason, not a validator error', () => {
+  assert.throws(
+    () =>
+      loadPluginFolder([
+        { path: 'demo/main.js', content: '' },
+        { path: 'demo/helper.js', content: '' },
+      ]),
+    /one script and one stylesheet.*helper\.js/s,
+  )
+})
+
+test('a nested src/main.js is the entry, and a sibling helper is named as the extra', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/src/main.js', content: '' },
+    { path: 'demo/src/main.css', content: '' },
+  ])
+  assert.equal(folder.entry, 'src/main.js')
+  assert.equal(folder.stylesheet, 'src/main.css')
+
+  // The extra named must be the helper — naming main.js would mean the entry was misdetected.
+  assert.throws(
+    () =>
+      loadPluginFolder([
+        { path: 'demo/src/helper.js', content: '' },
+        { path: 'demo/src/main.js', content: '' },
+      ]),
+    /one script and one stylesheet.*src\/helper\.js/s,
+  )
+})
+
+test('the entry pick is stable when a folder has more than one .js', () => {
+  const many = (order) => loadPluginFolder(order.map((path) => ({ path, content: '' })))
+  const error = (order) => {
+    try {
+      many(order)
+      return ''
+    } catch (caught) {
+      return caught.message
+    }
+  }
+  assert.equal(error(['demo/zed.js', 'demo/alpha.js']), error(['demo/alpha.js', 'demo/zed.js']))
+})
+
+test('a declared entry that is not in the folder falls back to detection', () => {
+  const folder = loadPluginFolder([
+    { path: 'demo/manifest.json', content: JSON.stringify({ ...JSON.parse(MANIFEST), entry: 'missing.js' }) },
+    { path: 'demo/main.js', content: '' },
+  ])
+  assert.equal(folder.entry, 'main.js')
+})
+
+test('binary assets are recognised by extension', () => {
+  assert.equal(isBinaryPath('assets/icon.png'), true)
+  assert.equal(isBinaryPath('fonts/inter.woff2'), true)
+  assert.equal(isBinaryPath('main.js'), false)
+  assert.equal(isBinaryPath('styles/main.css'), false)
+})
+
+test('a package built from a picked folder with no domains round-trips', async () => {
+  const { buildPluginArchive, readPluginArchive } = await import('../../shared/plugin-package.mjs')
+  const folder = loadPluginFolder([
+    { path: 'demo/manifest.json', content: MANIFEST },
+    { path: 'demo/main.js', content: 'maxcode.log("hi")' },
+  ])
+  assert.ok(folder.manifest)
+  const archive = buildPluginArchive({
+    manifest: folder.manifest,
+    files: { ...folder.files, [folder.stylesheet]: '' },
+  })
+  assert.deepEqual(readPluginArchive(archive).files['main.js'], 'maxcode.log("hi")')
+  assert.deepEqual(readPluginArchive(archive).manifest.domains, [])
+})

package/src/lib/plugin-folder.ts

@@ -0,0 +1,96 @@
+import type { PluginManifest } from '../../shared/plugin-package.mjs'
+import { validatePluginManifest } from '../../shared/plugin-package.mjs'
+
+export interface PickedFile {
+  path: string
+  content: string | Uint8Array
+}
+
+export interface PluginFolder {
+  entry: string
+  stylesheet: string
+  files: Record<string, string | Uint8Array>
+  manifest?: PluginManifest
+  /** A `manifest.json` we would not use, so the load still succeeds and the form keeps its values. */
+  manifestError?: string
+}
+
+const BINARY = /\.(?:png|jpe?g|gif|webp|ico|woff2?|ttf|otf|eot|wasm|zip|pdf|mp3|mp4)$/i
+
+/** Anything not read as UTF-8 text, so a picked image or font survives the round trip. */
+export function isBinaryPath(path: string): boolean {
+  return BINARY.test(path)
+}
+
+/** A directory pick prefixes every path with the folder the user chose; loose picks do not. */
+function stripRoot(paths: string[]): string[] {
+  const slash = paths[0]?.indexOf('/') ?? -1
+  if (slash < 0) return paths
+  const root = paths[0].slice(0, slash + 1)
+  return paths.every((path) => path.startsWith(root)) ? paths.map((path) => path.slice(root.length)) : paths
+}
+
+function parseManifest(raw: string | Uint8Array): PluginManifest {
+  if (typeof raw !== 'string') throw new Error('manifest.json must be text.')
+  let value: unknown
+  try {
+    value = JSON.parse(raw)
+  } catch {
+    throw new Error('manifest.json is not valid JSON.')
+  }
+  return validatePluginManifest(value)
+}
+
+/**
+ * Turns a picked folder or file set into the sources a plugin package needs. The
+ * folder's own `manifest.json` only seeds the form; the package manifest is
+ * always rebuilt from the fields, so what you see is what gets packed.
+ */
+export function loadPluginFolder(picked: PickedFile[]): PluginFolder {
+  const paths = stripRoot(picked.map((file) => file.path))
+  const files: Record<string, string | Uint8Array> = {}
+  let raw: string | Uint8Array | undefined
+  picked.forEach((file, index) => {
+    const path = paths[index]
+    if (path === 'manifest.json') raw = file.content
+    else files[path] = file.content
+  })
+
+  const names = Object.keys(files)
+  const usable = (path: string | undefined, extension: string) =>
+    path !== undefined && path.endsWith(extension) && names.includes(path) ? path : undefined
+  const pick = (preferred: string, extension: string) => {
+    if (names.includes(preferred)) return preferred
+    const candidates = names.filter((name) => name.endsWith(extension)).sort()
+    // `src/main.js` is the entry just as much as `main.js` is; compare leaf names.
+    return candidates.find((name) => name.slice(name.lastIndexOf('/') + 1) === preferred) ?? candidates[0]
+  }
+
+  // A folder manifest is a convenience. A broken one must not cost you the load.
+  let manifest: PluginManifest | undefined
+  let manifestError: string | undefined
+  if (raw !== undefined) {
+    try {
+      manifest = parseManifest(raw)
+    } catch (error) {
+      manifestError = error instanceof Error ? error.message : 'manifest.json could not be read.'
+    }
+  }
+
+  // What the folder declared beats guessing by extension, and makes the pick stable.
+  const entry = usable(manifest?.entry, '.js') ?? pick('main.js', '.js')
+  if (!entry) throw new Error('A plugin needs one .js entry file. Pick a folder that has one.')
+  const stylesheet = usable(manifest?.stylesheet, '.css') ?? pick('main.css', '.css') ?? 'main.css'
+
+  // The package holds exactly one script and one stylesheet: no imports, no second module.
+  const extra = names.filter(
+    (name) => name !== entry && name !== stylesheet && /\.(?:m?js|cjs|jsx|tsx?|css)$/i.test(name),
+  )
+  if (extra.length > 0) {
+    throw new Error(
+      `A plugin package holds one script and one stylesheet. Remove or merge: ${extra.join(', ')}.`,
+    )
+  }
+
+  return { entry, stylesheet, files, manifest, manifestError }
+}

package/src/lib/reasoning.ts

@@ -0,0 +1,87 @@
+import type { Effort, ModelInfo, ReasoningOption } from '../types'
+import { EFFORT_ORDER } from '../data/providers'
+
+export function effortValues(model?: ModelInfo | null): Effort[] {
+  const option = model?.reasoningOptions.find(
+    (entry): entry is Extract<ReasoningOption, { type: 'effort' }> => entry.type === 'effort',
+  )
+  return option?.values ?? []
+}
+
+export function budgetOption(
+  model?: ModelInfo | null,
+): Extract<ReasoningOption, { type: 'budget_tokens' }> | undefined {
+  return model?.reasoningOptions.find(
+    (entry): entry is Extract<ReasoningOption, { type: 'budget_tokens' }> =>
+      entry.type === 'budget_tokens',
+  )
+}
+
+export function hasBudget(model?: ModelInfo | null) {
+  return Boolean(budgetOption(model))
+}
+
+export function hasToggle(model?: ModelInfo | null) {
+  return Boolean(model?.reasoningOptions.some((entry) => entry.type === 'toggle'))
+}
+
+/** Whether the effort control applies: the live model advertises effort or a budget. */
+export function supportsReasoningControl(model?: ModelInfo | null) {
+  return effortValues(model).length > 0 || hasBudget(model)
+}
+
+/** Whether the model can think at all, even when the provider controls the switch. */
+export function supportsReasoning(model?: ModelInfo | null) {
+  return supportsReasoningControl(model) || hasToggle(model)
+}
+
+export function defaultEffort(model?: ModelInfo | null): Effort {
+  const values = effortValues(model)
+  if (values.length === 0) return 'medium'
+  for (const candidate of ['medium', 'high', 'low'] as Effort[]) {
+    if (values.includes(candidate)) return candidate
+  }
+  return values[0]
+}
+
+export function normalizeEffort(effort: Effort, model?: ModelInfo | null): Effort {
+  const values = effortValues(model)
+  if (values.length === 0) return effort
+  if (values.includes(effort)) return effort
+  return defaultEffort(model)
+}
+
+export function clampBudget(value: number, model?: ModelInfo | null) {
+  const option = budgetOption(model)
+  const min = Math.max(0, option?.min ?? 1024)
+  const max = Math.max(min, option?.max ?? 32_768)
+  return Math.max(min, Math.min(max, value))
+}
+
+const BUDGET_BY_EFFORT: Record<Effort, number> = {
+  none: 1024,
+  minimal: 1024,
+  low: 2048,
+  medium: 8192,
+  high: 16_384,
+  xhigh: 24_576,
+  max: 32_768,
+}
+
+export function budgetForEffort(effort: Effort, model?: ModelInfo | null) {
+  return clampBudget(BUDGET_BY_EFFORT[effort] ?? 8192, model)
+}
+
+export function effortOptions(model?: ModelInfo | null): Effort[] {
+  const values = effortValues(model)
+  return [...values].sort((a, b) => EFFORT_ORDER.indexOf(a) - EFFORT_ORDER.indexOf(b))
+}
+
+export function reasoningSummary(model?: ModelInfo | null): string {
+  if (!model) return 'Choose a model to see live reasoning controls.'
+  const values = effortValues(model)
+  if (values.length > 0) return `Effort levels from this model: ${values.join(', ')}.`
+  if (hasBudget(model)) return 'This model accepts a thinking token budget, derived from the effort level.'
+  if (hasToggle(model)) return 'This model controls reasoning itself; no effort value is sent.'
+  return 'This model advertises no reasoning controls, so effort does not apply.'
+}

package/src/lib/sse.ts

@@ -0,0 +1,75 @@
+export async function* readSSE(response: Response): AsyncGenerator<string> {
+  if (!response.body) throw new Error('The provider returned an empty response body.')
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      buffer = buffer.replace(/\r\n/g, '\n')
+      let boundary = buffer.indexOf('\n\n')
+      while (boundary !== -1) {
+        const chunk = buffer.slice(0, boundary)
+        buffer = buffer.slice(boundary + 2)
+        for (const line of chunk.split('\n')) {
+          if (!line.startsWith('data:')) continue
+          const data = line.slice(5).trim()
+          if (data) yield data
+        }
+        boundary = buffer.indexOf('\n\n')
+      }
+    }
+    for (const line of buffer.split('\n')) {
+      if (line.startsWith('data:')) {
+        const data = line.slice(5).trim()
+        if (data) yield data
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+}
+
+export function parseErrorMessage(raw: string, status: number): string {
+  try {
+    const parsed = JSON.parse(raw) as {
+      error?: { message?: string; type?: string } | string
+      message?: string
+    }
+    if (typeof parsed.error === 'string') return `${parsed.error} (${status})`
+    if (parsed.error?.message) return `${parsed.error.message} (${status})`
+    if (parsed.message) return `${parsed.message} (${status})`
+  } catch {
+    // Fall through to the raw text, which is still useful.
+  }
+  const trimmed = raw.trim()
+  if (trimmed.startsWith('<')) {
+    return `The provider returned an HTML error page (${status}). Check the base URL and key.`
+  }
+  return trimmed ? `${trimmed.slice(0, 500)} (${status})` : `Request failed with status ${status}.`
+}
+
+export async function assertOk(response: Response): Promise<void> {
+  if (response.ok) return
+  const text = await response.text().catch(() => '')
+  throw new Error(parseErrorMessage(text, response.status))
+}
+
+export function describeRequestError(error: unknown, providerName: string): string {
+  if (error instanceof DOMException && error.name === 'AbortError') return 'Stopped.'
+  if (error instanceof Error) {
+    if (/daemon is not reachable|lost the connection/i.test(error.message)) {
+      return 'The local OpenSol daemon is not reachable. Start it with “npm start”, then try again.'
+    }
+    if (/failed to fetch|networkerror|load failed/i.test(error.message)) {
+      return `The local daemon could not reach ${providerName}. Check the network and the provider base URL, then try again.`
+    }
+    if (/401|403/.test(error.message) && /key|auth|permission|refus|reject/i.test(error.message)) {
+      return `${error.message} Check the API key in Settings → Models, or choose a model this key can access.`
+    }
+    return error.message
+  }
+  return 'The request failed for an unknown reason.'
+}

package/src/lib/themes.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { THEMES, normalizeTheme, resolveTheme, themeIsDark } from './themes.ts'
+
+const css = readFileSync(fileURLToPath(new URL('../index.css', import.meta.url)), 'utf8')
+
+const TOKENS = [
+  'canvas',
+  'panel',
+  'raised',
+  'line',
+  'ink',
+  'muted',
+  'faint',
+  'accent',
+  'accent-soft',
+  'on-accent',
+  'success',
+  'warning',
+  'danger',
+  'syn-keyword',
+  'syn-string',
+  'syn-number',
+  'syn-title',
+  'syn-attr',
+]
+
+function block(needle) {
+  const start = css.indexOf(needle)
+  assert.notEqual(start, -1, `missing CSS block for ${needle}`)
+  return css.slice(start, css.indexOf('}', start))
+}
+
+test('every named palette defines the full semantic token set', () => {
+  for (const theme of THEMES) {
+    const body = block(`[data-theme='${theme.id}']`)
+    for (const token of TOKENS) {
+      assert.match(body, new RegExp(`--${token}:`), `${theme.id} is missing --${token}`)
+    }
+  }
+  const light = block(':root,')
+  for (const token of TOKENS) {
+    assert.match(light, new RegExp(`--${token}:`), `light is missing --${token}`)
+  }
+})
+
+test('legacy, named, system and invalid themes resolve', () => {
+  assert.equal(normalizeTheme('light'), 'light')
+  assert.equal(normalizeTheme('dark'), 'dark')
+  assert.equal(normalizeTheme('system'), 'system')
+  assert.equal(normalizeTheme('night-owl'), 'night-owl')
+  assert.equal(normalizeTheme('claude-code'), 'claude-code')
+  assert.equal(normalizeTheme('flame'), 'flame')
+  assert.equal(normalizeTheme(undefined), 'system')
+  assert.equal(normalizeTheme(7), 'system')
+  assert.equal(normalizeTheme('Not A Theme'), 'system')
+  // Plugin themes are `plugin-<id>:<theme>` slugs the app has not seen at build time.
+  assert.equal(normalizeTheme('plugin-demo:sunrise'), 'plugin-demo:sunrise')
+})
+
+test('system follows the OS preference while named themes do not', () => {
+  assert.equal(resolveTheme('system', true), 'dark')
+  assert.equal(resolveTheme('system', false), 'light')
+  assert.equal(resolveTheme('light', true), 'light')
+  assert.equal(resolveTheme('flame', false), 'flame')
+  assert.equal(themeIsDark('light', true), false)
+  assert.equal(themeIsDark('dark', false), true)
+  assert.equal(themeIsDark('night-owl', false), true)
+  assert.equal(themeIsDark('system', true), true)
+})

package/src/lib/themes.ts

@@ -0,0 +1,52 @@
+export type BuiltinThemeId = 'light' | 'dark' | 'system' | 'night-owl' | 'claude-code' | 'flame'
+
+/** A built-in theme id, or a Safe plugin's `plugin-<plugin>:<theme>` id. */
+export type ThemeId = BuiltinThemeId | (string & {})
+
+export type ResolvedThemeId = Exclude<BuiltinThemeId, 'system'> | (string & {})
+
+export interface ThemeMeta {
+  id: string
+  label: string
+  /** Whether the `dark` class (and `dark:` Tailwind variants) applies. */
+  dark: boolean
+}
+
+export const THEMES: ThemeMeta[] = [
+  { id: 'light', label: 'Light', dark: false },
+  { id: 'dark', label: 'Dark', dark: true },
+  { id: 'night-owl', label: 'Night Owl', dark: true },
+  { id: 'claude-code', label: 'Claude Code', dark: true },
+  { id: 'flame', label: 'Flame', dark: true },
+]
+
+const SLUG = /^[a-z0-9][a-z0-9:_-]{0,79}$/
+const registry = new Map<string, ThemeMeta>(THEMES.map((theme) => [theme.id, theme]))
+
+/** Plugin-contributed themes register here so the app knows how to apply them. */
+export function registerTheme(meta: ThemeMeta): void {
+  registry.set(meta.id, meta)
+}
+
+export function unregisterTheme(id: string): void {
+  if (THEMES.some((theme) => theme.id === id)) return
+  registry.delete(id)
+}
+
+export function isThemeId(value: unknown): value is string {
+  return typeof value === 'string' && SLUG.test(value)
+}
+
+export function resolveTheme(theme: ThemeId, prefersDark: boolean): string {
+  if (theme === 'system') return prefersDark ? 'dark' : 'light'
+  return isThemeId(theme) ? theme : 'light'
+}
+
+export function themeIsDark(theme: ThemeId, prefersDark: boolean): boolean {
+  return registry.get(resolveTheme(theme, prefersDark))?.dark ?? false
+}
+
+export function normalizeTheme(value: unknown): ThemeId {
+  if (value === 'system') return 'system'
+  return isThemeId(value) ? value : 'system'
+}

package/src/lib/usage.test.mjs

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { computeUsage, dayKey, formatTokens, shortModelName } from './usage.ts'
+
+const now = new Date(2026, 0, 15, 15, 0, 0, 0).getTime()
+const hour = 3_600_000
+const day = 86_400_000
+
+function assistant(id, createdAt, model, content = '', usage) {
+  return {
+    id,
+    role: 'assistant',
+    content,
+    reasoning: '',
+    toolCalls: [],
+    model,
+    usage,
+    createdAt,
+    round: 0,
+  }
+}
+
+function session(id, updatedAt, messages) {
+  return { id, title: id, createdAt: updatedAt, updatedAt, messages }
+}
+
+const sessions = [
+  session('recent', now, [
+    { id: 'u1', role: 'user', content: 'hello', createdAt: now - hour },
+    assistant('a1', now - 2 * hour, 'anthropic/claude-sonnet', 'ok', { input: 100, output: 50 }),
+    assistant('a2', now - hour, 'anthropic/claude-sonnet', 'x'.repeat(40)),
+  ]),
+  session('older', now - 10 * day, [
+    assistant('a3', now - 10 * day, 'openai/gpt-5', 'ok', { input: 10, output: 10 }),
+  ]),
+]
+
+test('counts all sessions and messages', () => {
+  const stats = computeUsage(sessions, 'all', now)
+  assert.equal(stats.sessions, 2)
+  assert.equal(stats.messages, 4)
+  assert.equal(stats.tokens, 180)
+  assert.equal(stats.activeDays, 2)
+  assert.equal(stats.favoriteModel, 'anthropic/claude-sonnet')
+  assert.equal(stats.favoriteShare, 67)
+  assert.equal(stats.models.length, 2)
+})
+
+test('applies the 7 day window', () => {
+  const stats = computeUsage(sessions, '7d', now)
+  assert.equal(stats.sessions, 1)
+  assert.equal(stats.messages, 3)
+  assert.equal(stats.tokens, 160)
+  assert.equal(stats.favoriteModel, 'anthropic/claude-sonnet')
+  assert.equal(stats.peakHour, '2 PM')
+})
+
+test('builds a 26 week heatmap that includes the current day', () => {
+  const stats = computeUsage(sessions, 'all', now)
+  assert.equal(stats.heatmap.length, 26 * 7)
+  assert.equal(stats.busiestDay, 3)
+  const today = stats.heatmap.find((entry) => entry.key === dayKey(now))
+  assert.equal(today?.count, 3)
+})
+
+test('formats token counts and model names', () => {
+  assert.equal(formatTokens(999), '999')
+  assert.equal(formatTokens(1_500), '1.5k')
+  assert.equal(formatTokens(5_400_000), '5.4M')
+  assert.equal(shortModelName('anthropic/claude-sonnet'), 'claude-sonnet')
+  assert.equal(shortModelName('gpt-5'), 'gpt-5')
+})