@gotcos/glasses-server 6.2.1 → 6.5.0

package/server/routes/media.ts

@@ -0,0 +1,285 @@
+// Media attachment API (Release A) — authenticated upload, lifecycle, and
+// content endpoints backed by server/lib/media-store.ts.
+//
+//   POST   /api/media                 — upload images (base64 JSON batch)
+//   POST   /api/media/reserve         — bind staged media to a queue item
+//   POST   /api/media/associate       — bind media to a run/message (replay-safe)
+//   POST   /api/media/release         — drop staged/reserved media (cancel path)
+//   GET    /api/media/:id             — metadata (public ref + availability)
+//   GET    /api/media/:id/content     — bytes (?variant=phone|thumb)
+//   DELETE /api/media/:id             — delete UNASSOCIATED media only
+//
+// Uploads accept uploaded bytes only — no remote URLs, no filesystem paths,
+// no data-URI passthrough. The dedicated body parser (mediaBodyParser) is
+// mounted BEFORE the global express.json() so a maximum valid batch
+// (8 MiB decoded ≈ 10.7 MiB base64) doesn't trip the global 10 MB limit;
+// the allowance stays scoped to /api/media.
+
+import { Router, json, type Request, type Response } from 'express'
+import { readFileSync } from 'node:fs'
+import {
+  MAX_ATTACHMENTS_PER_PROMPT,
+  isValidMediaId,
+  parseMediaIdList,
+  type MediaAttachmentRef,
+} from '../../shared/media-attachment.js'
+import {
+  G2_LENS_VARIANT_CAPABILITY,
+  getMediaStore,
+  MediaStoreError,
+} from '../lib/media-store.js'
+import {
+  ImageSafetyError,
+  MAX_BATCH_BYTES,
+  isMediaProcessingReady,
+  strictBase64Decode,
+} from '../lib/image-safety.js'
+
+// Route-scoped parser: 16 MB covers the max valid batch after base64 + JSON
+// overhead. Mounted only for /api/media in server/index.ts — the global
+// server limit is unchanged.
+export const mediaBodyParser = json({ limit: '16mb' })
+
+export const mediaRouter = Router()
+
+const MEDIA_ERROR_STATUS: Record<string, number> = {
+  media_not_found: 404,
+  media_expired: 410,
+  media_unavailable: 503,
+  media_conflict: 409,
+}
+
+const SAFETY_ERROR_STATUS: Record<string, number> = {
+  invalid_base64: 400,
+  unsupported_format: 400,
+  image_too_large: 400,
+  dimensions_too_large: 400,
+  corrupt_image: 400,
+  media_processing_unavailable: 503,
+  normalization_failed: 500,
+}
+
+function sendMediaError(res: Response, err: unknown): void {
+  if (err instanceof MediaStoreError) {
+    res.status(MEDIA_ERROR_STATUS[err.code] ?? 500).json({ error: err.code })
+    return
+  }
+  if (err instanceof ImageSafetyError) {
+    const status = SAFETY_ERROR_STATUS[err.code] ?? 500
+    res.status(status).json({
+      error: err.code,
+      ...(err.code === 'media_processing_unavailable' ? { mediaProcessingReady: false } : {}),
+    })
+    return
+  }
+  console.error('[media] unexpected error:', err)
+  res.status(500).json({ error: 'media_internal_error' })
+}
+
+function safeString(v: unknown, max: number): string | undefined {
+  return typeof v === 'string' && v.trim().length > 0 ? v.trim().slice(0, max) : undefined
+}
+
+// ── Upload ───────────────────────────────────────────────────────────────────
+
+mediaRouter.post('/media', async (req: Request, res: Response) => {
+  try {
+    const body = req.body ?? {}
+    const rawImages = Array.isArray(body.images) ? body.images : []
+    if (rawImages.length === 0) {
+      res.status(400).json({ error: 'no_images' })
+      return
+    }
+    if (rawImages.length > MAX_ATTACHMENTS_PER_PROMPT) {
+      res.status(400).json({ error: 'too_many_images', max: MAX_ATTACHMENTS_PER_PROMPT })
+      return
+    }
+    // Release A: only phone photos enter through this route. Traffic frames
+    // and generated visuals arrive via the Release C run-scoped publisher.
+    const kind = body.kind === undefined || body.kind === 'user_photo' ? 'user_photo' : null
+    if (!kind) {
+      res.status(400).json({ error: 'unsupported_kind' })
+      return
+    }
+    if (!(await isMediaProcessingReady())) {
+      res.status(503).json({ error: 'media_processing_unavailable', mediaProcessingReady: false })
+      return
+    }
+
+    // Decode + total-batch gate before any normalization work.
+    const decoded: Array<{ bytes: Buffer; label?: string; capturedAt?: string }> = []
+    let totalBytes = 0
+    for (const raw of rawImages) {
+      const item = raw && typeof raw === 'object' ? raw as Record<string, unknown> : {}
+      const bytes = strictBase64Decode(item.data)
+      totalBytes += bytes.length
+      if (totalBytes > MAX_BATCH_BYTES) {
+        res.status(400).json({ error: 'batch_too_large', maxBytes: MAX_BATCH_BYTES })
+        return
+      }
+      decoded.push({
+        bytes,
+        label: safeString(item.label, 120),
+        capturedAt: safeString(item.capturedAt, 40),
+      })
+    }
+
+    const sessionId = safeString(body.sessionId, 64)
+    const store = getMediaStore()
+    const attachments: MediaAttachmentRef[] = []
+    for (const img of decoded) {
+      attachments.push(await store.ingestImage({
+        bytes: img.bytes,
+        kind,
+        label: img.label,
+        capturedAt: img.capturedAt,
+        sessionId,
+      }))
+    }
+    res.json({ attachments })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+mediaRouter.post('/media/reserve', async (req: Request, res: Response) => {
+  try {
+    const ids = parseMediaIdList(req.body?.ids)
+    const clientQueueItemId = safeString(req.body?.clientQueueItemId, 120)
+    if (ids.length === 0 || !clientQueueItemId) {
+      res.status(400).json({ error: 'ids_and_client_queue_item_id_required' })
+      return
+    }
+    const attachments = await getMediaStore().reserve(ids, {
+      clientQueueItemId,
+      sessionId: safeString(req.body?.sessionId, 64),
+    })
+    res.json({ ok: true, attachments })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.post('/media/associate', async (req: Request, res: Response) => {
+  try {
+    const ids = parseMediaIdList(req.body?.ids)
+    if (ids.length === 0) {
+      res.status(400).json({ error: 'ids_required' })
+      return
+    }
+    const globalMsgNum = typeof req.body?.globalMsgNum === 'number' && req.body.globalMsgNum > 0
+      ? Math.floor(req.body.globalMsgNum) : undefined
+    await getMediaStore().associate(ids, {
+      sessionId: safeString(req.body?.sessionId, 64),
+      runId: safeString(req.body?.runId, 120),
+      globalMsgNum,
+    })
+    res.json({ ok: true })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.post('/media/release', async (req: Request, res: Response) => {
+  try {
+    const ids = parseMediaIdList(req.body?.ids)
+    if (ids.length === 0) {
+      res.status(400).json({ error: 'ids_required' })
+      return
+    }
+    await getMediaStore().release(ids, {
+      sessionId: safeString(req.body?.sessionId, 64),
+      clientQueueItemId: safeString(req.body?.clientQueueItemId, 120),
+    })
+    res.json({ ok: true })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+// ── Reads ────────────────────────────────────────────────────────────────────
+
+mediaRouter.get('/media/:id', (req: Request, res: Response) => {
+  const id = req.params.id
+  if (!isValidMediaId(id)) {
+    res.status(400).json({ error: 'invalid_media_id' })
+    return
+  }
+  const store = getMediaStore()
+  const rec = store.getRecord(id)
+  if (!rec || rec.lifecycle === 'deleted') {
+    res.status(404).json({ error: 'media_not_found' })
+    return
+  }
+  const content = store.getContent(id, 'phone')
+  res.json({
+    attachment: rec.ref,
+    contentAvailable: content.status === 'ok',
+    ...(content.status === 'expired' ? { expired: true } : {}),
+  })
+})
+
+mediaRouter.get('/media/:id/content', async (req: Request, res: Response) => {
+  const id = req.params.id
+  if (!isValidMediaId(id)) {
+    res.status(400).json({ error: 'invalid_media_id' })
+    return
+  }
+  // 'g2' (Release B) — exact 288x144 grayscale PNG for the lens, generated
+  // lazily and cached beside the asset.
+  const variant = req.query.variant === 'thumb' ? 'thumb' : req.query.variant === 'g2' ? 'g2' : 'phone'
+  const content = variant === 'g2'
+    ? await getMediaStore().getG2Content(id)
+    : getMediaStore().getContent(id, variant)
+  if (content.status === 'not_found') {
+    res.status(404).json({ error: 'media_not_found' })
+    return
+  }
+  if (content.status === 'expired') {
+    res.status(410).json({ error: 'media_expired' })
+    return
+  }
+  if (content.status === 'unavailable') {
+    res.status(503).json({ error: 'media_unavailable' })
+    return
+  }
+  try {
+    // Read + send the buffer directly: content-length is exact and no
+    // filesystem path semantics leak into the response.
+    const bytes = readFileSync(content.path)
+    res.status(200)
+    res.setHeader('Content-Type', content.mime)
+    res.setHeader('Cache-Control', 'private, no-store')
+    res.setHeader('X-Content-Type-Options', 'nosniff')
+    if (variant === 'g2') {
+      res.setHeader('X-COS-G2-Variant', G2_LENS_VARIANT_CAPABILITY)
+      // Even Hub loads the app from a different origin. Without an expose
+      // header, browser fetch can receive this value but cannot read it.
+      res.setHeader('Access-Control-Expose-Headers', 'X-COS-G2-Variant')
+    }
+    res.setHeader('Content-Length', String(bytes.length))
+    res.end(bytes)
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
+mediaRouter.delete('/media/:id', async (req: Request, res: Response) => {
+  const id = req.params.id
+  if (!isValidMediaId(id)) {
+    res.status(400).json({ error: 'invalid_media_id' })
+    return
+  }
+  try {
+    const deleted = await getMediaStore().deleteUnassociated(id)
+    if (!deleted) {
+      res.status(404).json({ error: 'media_not_found' })
+      return
+    }
+    res.json({ deleted: true })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})

package/server/routes/message-ref.ts

@@ -0,0 +1,202 @@
+// Global message reference resolution (v5.15.0) — the server half of
+// "reference message N" across days. Numbers are stamped at exchange time
+// (client-sent, stored via conversation.addExchange) and persist durably in
+// the day archives; this router resolves a number the client no longer holds
+// in its local list, and publishes the numbering ceiling so a cleared or
+// fresh client continues the sequence instead of reusing numbers.
+//
+//   GET /api/message/:num     → { globalMsgNum, date, query, response }  (404 when unknown)
+//   GET /api/message-counter  → { max }
+//
+// Resolution order (per the prompt-queue/archive plan): live in-memory
+// sessions first (covers the mirror's 15-minute lag), then day archives
+// newest-first. Day files are read as plain data — their write path belongs
+// to the archive workstream and is not touched here.
+import { Router } from 'express'
+import { readdirSync, readFileSync } from 'fs'
+import { resolve } from 'path'
+import { getActiveSessions } from '../lib/conversation.js'
+import { dataPath } from '../lib/data-dir.js'
+import { localDay } from '../lib/local-day.js'
+import { mergeMediaAttachmentRefs, type MediaAttachmentRef } from '../../shared/media-attachment.js'
+
+// v6.3.0 — read archives from the SAME persistent location the archive-mirror
+// writes to (~/.cos-glasses/data/archive via dataPath), not a package-relative
+// dir. The app repo uses server/data/archive; the public package uses dataPath,
+// so this file must match the package's lib/archive.ts, or npx users' cross-day
+// references + archive-chat detail read an empty/nonexistent directory.
+const ARCHIVE_DIR = dataPath('archive')
+
+export interface ResolvedGlobalMessage {
+  globalMsgNum: number
+  date: string
+  query: string
+  response: string
+  attachments?: MediaAttachmentRef[]
+}
+
+interface ExchangeLike {
+  role?: string
+  content?: string
+  timestamp?: number
+  globalMsgNum?: number
+  attachments?: unknown
+}
+
+/** Pair the stamped exchange with its other half: a user turn pairs forward
+ *  to the next assistant turn; an assistant turn pairs backward. */
+function pairExchange(exchanges: ExchangeLike[], i: number): { query: string; response: string; attachments: MediaAttachmentRef[] } {
+  const hit = exchanges[i]
+  const user = hit.role === 'user'
+    ? hit
+    : [...exchanges.slice(0, i)].reverse().find((e) => e?.role === 'user')
+  const assistant = hit.role === 'assistant'
+    ? hit
+    : exchanges.slice(i + 1).find((e) => e?.role === 'assistant')
+  return {
+    query: user?.content ?? '',
+    response: assistant?.content ?? '',
+    attachments: mergeMediaAttachmentRefs(user?.attachments, assistant?.attachments),
+  }
+}
+
+function scanExchanges(exchanges: ExchangeLike[], num: number, date: string): ResolvedGlobalMessage | null {
+  for (let i = 0; i < exchanges.length; i++) {
+    if (exchanges[i]?.globalMsgNum !== num) continue
+    const { query, response, attachments } = pairExchange(exchanges, i)
+    return {
+      globalMsgNum: num, date, query, response,
+      ...(attachments.length > 0 ? { attachments } : {}),
+    }
+  }
+  return null
+}
+
+/** Resolve a global message number from the day archives, newest-first.
+ *  Exported with an explicit dir for tests. */
+export function resolveFromArchiveDir(dir: string, num: number): ResolvedGlobalMessage | null {
+  let files: string[] = []
+  try {
+    files = readdirSync(dir).filter((f) => /^\d{4}-\d{2}-\d{2}\.json$/.test(f)).sort().reverse()
+  } catch {
+    return null
+  }
+  for (const f of files) {
+    try {
+      const day = JSON.parse(readFileSync(resolve(dir, f), 'utf8'))
+      const chats = Array.isArray(day?.chats) ? day.chats : []
+      for (const chat of chats) {
+        const exchanges = Array.isArray(chat?.exchanges) ? chat.exchanges : []
+        const hit = scanExchanges(exchanges, num, typeof day?.date === 'string' ? day.date : f.slice(0, 10))
+        if (hit) return hit
+      }
+    } catch {
+      // Unreadable/corrupt day file — skip; the archive workstream owns repair.
+    }
+  }
+  return null
+}
+
+/** Read a specific archived chat's paired Q&A messages WITH their durable
+ *  global numbers (the archive-lib read path strips globalMsgNum; the browser
+ *  needs it so "reference message N" is self-evident from the screen). Same
+ *  user->next-assistant pairing as the lib; the pair's number is the user
+ *  turn's stamp (falling back to the assistant's). Dir-param form for tests. */
+export function readArchiveChatNumbered(
+  dir: string,
+  date: string,
+  chatIndex: number,
+): Array<{ query: string; text: string; timestamp: number; no?: number; attachments?: MediaAttachmentRef[] }> {
+  // Defense-in-depth against path traversal — `date` builds a `${date}.json`
+  // path. The archive route also validates, but this is exported/reused.
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return []
+  let day: { chats?: Array<{ id?: number; exchanges?: ExchangeLike[] }> }
+  try {
+    day = JSON.parse(readFileSync(resolve(dir, `${date}.json`), 'utf8'))
+  } catch {
+    return []
+  }
+  const chat = (Array.isArray(day?.chats) ? day.chats : []).find((c) => c?.id === chatIndex)
+  if (!chat) return []
+  const exchanges: ExchangeLike[] = Array.isArray(chat.exchanges) ? chat.exchanges : []
+  const out: Array<{ query: string; text: string; timestamp: number; no?: number; attachments?: MediaAttachmentRef[] }> = []
+  for (let i = 0; i < exchanges.length; i++) {
+    const ex = exchanges[i]
+    if (ex?.role !== 'user') continue
+    const next = exchanges[i + 1]
+    if (next?.role !== 'assistant') continue
+    const attachments = mergeMediaAttachmentRefs(ex.attachments, next.attachments)
+    out.push({
+      query: ex.content ?? '',
+      text: next.content ?? '',
+      timestamp: next.timestamp ?? ex.timestamp ?? 0,
+      no: ex.globalMsgNum ?? next.globalMsgNum,
+      ...(attachments.length > 0 ? { attachments } : {}),
+    })
+    i++
+  }
+  return out
+}
+
+/** ARCHIVE_DIR-bound form for the route. */
+export function getArchiveChatMessagesNumbered(date: string, chatIndex: number) {
+  return readArchiveChatNumbered(ARCHIVE_DIR, date, chatIndex)
+}
+
+/** Highest stamped number across the day archives (0 when none). */
+export function maxGlobalMsgNumInDir(dir: string): number {
+  let max = 0
+  let files: string[] = []
+  try {
+    files = readdirSync(dir).filter((f) => /^\d{4}-\d{2}-\d{2}\.json$/.test(f))
+  } catch {
+    return 0
+  }
+  for (const f of files) {
+    try {
+      const day = JSON.parse(readFileSync(resolve(dir, f), 'utf8'))
+      for (const chat of Array.isArray(day?.chats) ? day.chats : []) {
+        for (const ex of Array.isArray(chat?.exchanges) ? chat.exchanges : []) {
+          if (typeof ex?.globalMsgNum === 'number' && ex.globalMsgNum > max) max = ex.globalMsgNum
+        }
+      }
+    } catch { /* skip */ }
+  }
+  return max
+}
+
+function resolveFromLiveSessions(num: number): ResolvedGlobalMessage | null {
+  const today = localDay() // local calendar day, not UTC — a live ref in the user's evening must not label tomorrow
+  for (const session of getActiveSessions()) {
+    const exchanges = (session as { exchanges?: ExchangeLike[] }).exchanges ?? []
+    const hit = scanExchanges(exchanges, num, today)
+    if (hit) return hit
+  }
+  return null
+}
+
+export const messageRefRouter = Router()
+
+messageRefRouter.get('/message/:num', (req, res) => {
+  const num = Number.parseInt(req.params.num, 10)
+  if (!Number.isFinite(num) || num < 1) {
+    res.status(400).json({ error: 'invalid message number' })
+    return
+  }
+  const hit = resolveFromLiveSessions(num) ?? resolveFromArchiveDir(ARCHIVE_DIR, num)
+  if (!hit) {
+    res.status(404).json({ error: `message ${num} not found` })
+    return
+  }
+  res.json(hit)
+})
+
+messageRefRouter.get('/message-counter', (_req, res) => {
+  let liveMax = 0
+  for (const session of getActiveSessions()) {
+    for (const ex of ((session as { exchanges?: ExchangeLike[] }).exchanges ?? [])) {
+      if (typeof ex?.globalMsgNum === 'number' && ex.globalMsgNum > liveMax) liveMax = ex.globalMsgNum
+    }
+  }
+  res.json({ max: Math.max(liveMax, maxGlobalMsgNumInDir(ARCHIVE_DIR)) })
+})

package/server/routes/openai-compat.ts

@@ -7,6 +7,10 @@ import { Router } from 'express'
 import { preWarmCLI, logLatency } from '../lib/claude-bridge.js'
 import { callModelStreaming } from '../lib/model-router.js'
 import { normalizeModelPreference, DEFAULT_MODEL, type ModelPreference } from '../../shared/model-preference.js'
+import {
+  getCodexModelCatalog,
+  resolveCodexPreferenceForModelId,
+} from '../lib/codex-model-catalog.js'
 import { tryInstantResponse } from '../lib/response-cache.js'
 import crypto from 'node:crypto'
 
@@ -70,23 +74,31 @@ function validateAuth(req: any, res: any): boolean {
   return true
 }
 
-// Resolve model from OpenAI-compatible model ids. Defaults to Haiku for
-// "Hey Even" speed; Opus/Sonnet/Haiku/Codex High can be explicitly selected.
+// Resolve model from OpenAI-compatible ids, stable app slots, or concrete ids
+// currently advertised by the live Codex catalog.
 function resolveModel(model?: string, _query?: string): ModelPreference {
   const normalized = normalizeModelPreference(model)
   if (normalized) return normalized
+  if (model) {
+    const catalogPreference = resolveCodexPreferenceForModelId(model)
+    if (catalogPreference) return catalogPreference
+  }
   if (model === 'cos-opus') return 'opus'
+  if (model === 'cos-fable') return 'fable'
   if (model === 'cos-sonnet') return 'sonnet'
   if (model === 'cos-haiku') return 'haiku'
-  if (model === 'cos-codex-high' || model === 'cos-codex') return 'codex-high'
+  if (model === 'cos-gpt-frontier' || model === 'cos-codex-high' || model === 'cos-codex') return 'codex-frontier'
+  if (model === 'cos-gpt-balanced') return 'codex-balanced'
   return normalizeModelPreference(process.env.COS_G2_DEFAULT_MODEL) ?? DEFAULT_MODEL
 }
 
 const MODEL_NAMES: Record<ModelPreference, string> = {
   opus: 'cos-opus',
+  fable: 'cos-fable',
   sonnet: 'cos-sonnet',
   haiku: 'cos-haiku',
-  'codex-high': 'cos-codex-high',
+  'codex-frontier': 'cos-gpt-frontier',
+  'codex-balanced': 'cos-gpt-balanced',
 }
 
 // Extract the user's latest message from the OpenAI messages array
@@ -247,6 +259,7 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
   let resolveInflight: (text: string) => void
   let rejectInflight: (err: any) => void
   const inflightPromise = new Promise<string>((res, rej) => { resolveInflight = res; rejectInflight = rej })
+  void inflightPromise.catch(() => { /* duplicate waiters observe the original rejection */ })
   inflightQueries.set(dedupKey, { promise: inflightPromise, timestamp: Date.now() })
 
   // ── Streaming response (SSE) ──
@@ -381,12 +394,23 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
     const fullText = await new Promise<string>((resolve, reject) => {
       let result = ''
       let nsFirstChunkMs = -1
+      let settled = false
+      const fail = (error: unknown) => {
+        if (settled) return
+        settled = true
+        const err = error instanceof Error ? error : new Error(String(error))
+        rejectInflight!(err)
+        inflightQueries.delete(dedupKey)
+        reject(err)
+      }
       callModelStreaming(query, currentSessionIdNS, {
         onChunk: (text) => {
           if (nsFirstChunkMs < 0) nsFirstChunkMs = Date.now() - requestReceivedAt
           result += text
         },
         onDone: (fullText) => {
+          if (settled) return
+          settled = true
           const text = fullText || result
           resolveInflight!(text)
           inflightQueries.delete(dedupKey)
@@ -404,13 +428,13 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
           resolve(text)
         },
         onError: (error) => {
-          rejectInflight!(new Error(error))
-          inflightQueries.delete(dedupKey)
-          reject(new Error(error))
+          fail(new Error(error))
         },
         onToolStatus: () => {},
         onStart: () => {},
-      }, resolvedModel, undefined, undefined, undefined, { lightweight: true }).then(sid => { g2SessionId = sid })
+      }, resolvedModel, undefined, undefined, undefined, { lightweight: true })
+        .then(sid => { g2SessionId = sid })
+        .catch(fail)
     })
 
     res.json({
@@ -433,14 +457,23 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
 })
 
 // GET /v1/models — required by some clients for model discovery
-openaiCompatRouter.get('/v1/models', (_req, res) => {
+openaiCompatRouter.get('/v1/models', async (_req, res) => {
+  const catalog = await getCodexModelCatalog()
   res.json({
     object: 'list',
-    data: [
+	    data: [
 	      { id: 'cos-opus', object: 'model', created: 1709251200, owned_by: 'cos' },
+	      { id: 'cos-fable', object: 'model', created: 1709251200, owned_by: 'cos' },
 	      { id: 'cos-sonnet', object: 'model', created: 1709251200, owned_by: 'cos' },
 	      { id: 'cos-haiku', object: 'model', created: 1709251200, owned_by: 'cos' },
-	      { id: 'cos-codex-high', object: 'model', created: 1709251200, owned_by: 'cos' },
+	      { id: 'cos-gpt-frontier', object: 'model', created: 1709251200, owned_by: 'cos' },
+	      { id: 'cos-gpt-balanced', object: 'model', created: 1709251200, owned_by: 'cos' },
+	      ...catalog.options.filter(option => option.id).map(option => ({
+	        id: option.id,
+	        object: 'model',
+	        created: 1709251200,
+	        owned_by: 'openai',
+	      })),
 	    ],
 	  })
 	})