@corgelabs/corge 0.0.1 → 1.0.1

package/src/auth/utils.ts

@@ -0,0 +1,106 @@
+import { createHash, timingSafeEqual } from 'node:crypto'
+import type { UserRecord } from 'firebase-admin/auth'
+import { CORE_CONFIG, type DbRole } from '../config'
+import type { EntryId } from '../db'
+import type { AuthUser, LinkedProvider, OAuthProvider, UserAuthMetaRecord } from './schema'
+
+export const resolveUserRole = (userId?: EntryId, explicitRole?: DbRole): DbRole => {
+  if (explicitRole === 'admin' || explicitRole === 'user' || explicitRole === 'anon') return explicitRole
+  if (userId === CORE_CONFIG.auth.adminUserId) return 'admin'
+  return userId ? 'user' : 'anon'
+}
+
+export const resolveTokenRole = (decoded: Record<string, unknown>, uid: EntryId): DbRole =>
+  uid === CORE_CONFIG.auth.adminUserId || decoded.role === 'admin' || decoded.admin === true ? 'admin' : 'user'
+
+export const normalizeDate = (val: unknown, fallback = new Date()): Date => {
+  if (val instanceof Date) return val
+  if (
+    val &&
+    typeof val === 'object' &&
+    'toDate' in val &&
+    typeof (val as { toDate: () => Date }).toDate === 'function'
+  ) {
+    return (val as { toDate: () => Date }).toDate()
+  }
+  if (typeof val === 'string' || typeof val === 'number') {
+    const d = new Date(val)
+    if (!Number.isNaN(d.getTime())) return d
+  }
+  return fallback
+}
+
+export const safeEqualHex = (aHex: string, bHex: string): boolean => {
+  if (!aHex || !bHex || aHex.length !== bHex.length) return false
+  try {
+    const a = Buffer.from(aHex, 'hex')
+    const b = Buffer.from(bHex, 'hex')
+    return a.length > 0 && a.length === b.length && timingSafeEqual(a, b)
+  } catch {
+    return false
+  }
+}
+
+export const hashToken = (raw: string): string => createHash('sha256').update(raw.trim()).digest('hex')
+
+export const parseLinkedProviders = (rawProviders: unknown, fallbackDate = new Date()): LinkedProvider[] => {
+  if (!Array.isArray(rawProviders)) return []
+  return rawProviders
+    .filter((p): p is Record<string, unknown> => Boolean(p && typeof p === 'object'))
+    .map((p) => ({
+      provider: (p.provider === 'apple' ? 'apple' : 'google') as OAuthProvider,
+      providerUserId: String(p.providerUserId ?? ''),
+      ...(p.email !== undefined ? { email: (p.email as string | null) ?? null } : {}),
+      linkedAt: normalizeDate(p.linkedAt, fallbackDate)
+    }))
+    .filter((p) => Boolean(p.providerUserId))
+}
+
+export const mapUserRecord = (u: UserRecord, meta?: UserAuthMetaRecord): AuthUser => {
+  const createdAt = new Date(u.metadata.creationTime || Date.now())
+  const updatedAt = new Date(u.metadata.lastRefreshTime || u.metadata.creationTime || Date.now())
+  const fbProviders: LinkedProvider[] = (u.providerData ?? [])
+    .filter((p) => p.providerId === 'google.com' || p.providerId === 'apple.com')
+    .map((p) => ({
+      provider: (p.providerId === 'apple.com' ? 'apple' : 'google') as OAuthProvider,
+      providerUserId: p.uid,
+      ...(p.email ? { email: p.email } : {}),
+      linkedAt: createdAt
+    }))
+  const mergedProvidersMap = new Map<string, LinkedProvider>()
+  for (const p of fbProviders) mergedProvidersMap.set(`${p.provider}:${p.providerUserId}`, p)
+  for (const p of meta?.linkedProviders ?? []) mergedProvidersMap.set(`${p.provider}:${p.providerUserId}`, p)
+  const linkedProviders = [...mergedProvidersMap.values()]
+  const avatarUrl = u.photoURL ?? meta?.avatarUrl ?? undefined
+
+  return {
+    id: u.uid,
+    email: u.email ?? meta?.email ?? null,
+    emailVerified: Boolean(u.emailVerified || meta?.emailVerified),
+    name: u.displayName ?? meta?.name ?? null,
+    ...(avatarUrl !== undefined ? { avatarUrl } : {}),
+    ...(meta?.recoveryEmail !== undefined ? { recoveryEmail: meta.recoveryEmail } : {}),
+    ...(meta?.recoveryEmailVerified !== undefined ? { recoveryEmailVerified: meta.recoveryEmailVerified } : {}),
+    ...(linkedProviders.length > 0 ? { linkedProviders } : {}),
+    ...(u.customClaims ? { customClaims: u.customClaims } : {}),
+    deleted: u.disabled,
+    createdAt,
+    updatedAt
+  }
+}
+
+export const fetchIdentityToolkit = async <T = Record<string, unknown>>(
+  endpoint: string,
+  apiKey: string,
+  body: Record<string, unknown>,
+  timeoutMs = 10_000
+): Promise<{ ok: boolean; status: number; data: T }> => {
+  const res = await fetch(`https://identitytoolkit.googleapis.com/v1/${endpoint}?key=${apiKey}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  })
+  const data = (await res.json().catch(() => ({}))) as T
+  return { ok: res.ok, status: res.status, data }
+}

package/src/chat/context.ts

@@ -0,0 +1,310 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ModelMessage } from 'ai'
+import { FieldValue, type Query } from 'firebase-admin/firestore'
+import type { JevQuestion } from '../ai'
+import { CORE_CONFIG, type DbRole } from '../config'
+import type { EntryId } from '../db'
+import { Core } from '../index'
+import type {
+  AgentConfig,
+  ChatMessagePublic,
+  ChatMessageRole,
+  ContextEntry,
+  ContextItemSpec,
+  GetContextOptions,
+  HybridRetrievalOptions,
+  HybridRetrievalResult,
+  RecalledMemorySnippet,
+  UserContext,
+  VectorValue
+} from './schema'
+import {
+  isContextItemVisible,
+  isUserContextShape,
+  mapFirestoreMessageDoc,
+  PUBLIC_MESSAGE_FIELDS,
+  RECALL_MESSAGE_FIELDS,
+  toModelMessageFromDoc
+} from './utils'
+
+let contextCatalog: readonly ContextItemSpec[] = []
+const markdownCache = new Map<string, string>()
+
+export class ChatContextEngine {
+  readonly #core: Core
+
+  constructor(coreClient: Core) {
+    this.#core = coreClient
+  }
+
+  registerContextCatalog = (items: readonly ContextItemSpec[] = [], reset = false): void => {
+    if (reset) {
+      contextCatalog = []
+      markdownCache.clear()
+    }
+    contextCatalog = [...items]
+  }
+
+  #readContextMarkdown = async (relPath: string): Promise<string | undefined> => {
+    const cached = markdownCache.get(relPath)
+    if (cached !== undefined) return cached
+
+    const contextRoot = path.resolve(process.cwd(), CORE_CONFIG.context.dir)
+    const resolved = path.resolve(contextRoot, relPath)
+    if (!resolved.startsWith(contextRoot + path.sep) || !relPath.endsWith('.md')) {
+      return undefined
+    }
+
+    try {
+      const content = await readFile(resolved, 'utf8')
+      markdownCache.set(relPath, content)
+      return content
+    } catch {
+      return undefined
+    }
+  }
+
+  getContext = async (
+    prompt: string,
+    catalog: readonly ContextItemSpec[] = contextCatalog,
+    options?: GetContextOptions
+  ): Promise<ContextEntry[]> => {
+    const trimmed = prompt.trim()
+    if (!trimmed || catalog.length === 0) return []
+
+    const validItems = catalog.filter(
+      (item) =>
+        item.path?.endsWith('.md') &&
+        !item.path.includes('..') &&
+        !path.isAbsolute(item.path) &&
+        isContextItemVisible(item, options?.audiences)
+    )
+    if (validItems.length === 0) return []
+
+    const maxSources = options?.maxSources ?? CORE_CONFIG.context.maxSources
+    const userState = options?.userState
+    const stateHint = userState ? ' Use the provided userState when judging relevance.' : ''
+    const questions: Record<string, JevQuestion> = {}
+    validItems.forEach((item, idx) => {
+      questions[`doc_${idx}`] = {
+        type: 'noul',
+        instructions: `Is documentation file "${item.path}" (${item.description}) directly relevant to answering the user prompt?${stateHint}`,
+        criteria: {
+          true: `The user prompt requires or benefits from documentation in ${item.path} (${item.description})`,
+          false: 'The user prompt is unrelated to this documentation file'
+        }
+      }
+    })
+
+    try {
+      const decision = await this.#core.ai.decide(
+        { prompt: trimmed, ...(userState ? { userState } : {}) },
+        questions
+      )
+      const scored = validItems
+        .map((item, idx) => {
+          const ans = decision.answers[`doc_${idx}`]
+          return { item, score: ans?.type === 'noul' ? ans.noul : 0 }
+        })
+        .filter((x) => x.score >= 0.5)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxSources)
+
+      if (scored.length === 0) return []
+
+      const loaded = await Promise.all(
+        scored.map(async ({ item }): Promise<ContextEntry | undefined> => {
+          const markdown = await this.#readContextMarkdown(item.path)
+          return markdown ? { path: item.path, description: item.description, markdown } : undefined
+        })
+      )
+      return loaded.filter((entry): entry is ContextEntry => Boolean(entry))
+    } catch {
+      return []
+    }
+  }
+
+  #resolveTurnUserContext = async (opts: {
+    userId: EntryId
+    role?: DbRole
+    agent?: Pick<AgentConfig, 'resolveUserContext'>
+    abortSignal?: AbortSignal
+  }): Promise<UserContext | undefined> => {
+    const resolver = opts.agent?.resolveUserContext
+    const role = opts.role ?? this.#core.internals.auth.resolveUserRole(opts.userId)
+    if (!resolver || !opts.userId || role === 'anon') return undefined
+    const timeout = AbortSignal.timeout(CORE_CONFIG.context.userContextTimeoutMs)
+    const signal = opts.abortSignal ? AbortSignal.any([opts.abortSignal, timeout]) : timeout
+    let onAbort: (() => void) | undefined
+    try {
+      const state = { env: this.#core.env, userId: opts.userId, role }
+      const turnCore = new Core(state)
+      const aborted = new Promise<undefined>((resolve) => {
+        onAbort = () => resolve(undefined)
+        if (signal.aborted) return resolve(undefined)
+        signal.addEventListener('abort', onAbort, { once: true })
+      })
+      const result = await Promise.race([
+        this.#core.internals.context.run(state, () =>
+          Promise.resolve(resolver({ userId: opts.userId, core: turnCore, signal }))
+        ),
+        aborted
+      ])
+      return isUserContextShape(result) ? result : undefined
+    } catch {
+      return undefined
+    } finally {
+      if (onAbort) signal.removeEventListener('abort', onAbort)
+    }
+  }
+
+  #queryNearestMessages = async (
+    baseQuery: Query,
+    vectorValue: VectorValue,
+    limit: number,
+    scope: 'in_chat' | 'cross_chat',
+    fallbackChatId = ''
+  ): Promise<RecalledMemorySnippet[]> => {
+    try {
+      await this.#core.internals.resilience.acquireLimit('firestore')
+      const snap = await baseQuery
+        .select(...RECALL_MESSAGE_FIELDS)
+        .findNearest({
+          vectorField: 'embedding',
+          queryVector: vectorValue,
+          limit,
+          distanceMeasure: 'COSINE',
+          distanceThreshold: 0.35
+        })
+        .get()
+      return snap.docs
+        .map((d) => {
+          const data = d.data()
+          const content = typeof data.content === 'string' ? data.content.trim() : ''
+          if (!content) return undefined
+          return {
+            id: d.id,
+            chatId: typeof data.chatId === 'string' ? data.chatId : fallbackChatId,
+            role: (data.role === 'assistant' ? 'assistant' : 'user') as ChatMessageRole,
+            content,
+            scope
+          }
+        })
+        .filter((x): x is RecalledMemorySnippet => Boolean(x))
+    } catch {
+      return []
+    }
+  }
+
+  #vectorRecall = async (
+    prompt: string,
+    userId: EntryId,
+    chatId: string | undefined,
+    messageCount: number,
+    slidingWindowSize: number
+  ): Promise<RecalledMemorySnippet[]> => {
+    const queryVector = await this.#core.ai.embed(prompt)
+    if (!queryVector) return []
+    const vectorValue = FieldValue.vector(queryVector)
+    const db = this.#core.db.firestore()
+
+    const inChatPromise =
+      chatId && messageCount > slidingWindowSize
+        ? this.#queryNearestMessages(
+            db.collection('chat').doc(chatId).collection('messages'),
+            vectorValue,
+            5,
+            'in_chat',
+            chatId
+          )
+        : Promise.resolve([] as RecalledMemorySnippet[])
+
+    const crossChatPromise = userId
+      ? this.#queryNearestMessages(
+          db.collectionGroup('messages').where('userId', '==', userId),
+          vectorValue,
+          3,
+          'cross_chat'
+        )
+      : Promise.resolve([] as RecalledMemorySnippet[])
+
+    const [inChat, crossChat] = await Promise.all([inChatPromise, crossChatPromise])
+    return [...inChat, ...crossChat]
+  }
+
+  retrieveContext = async (opts: HybridRetrievalOptions): Promise<HybridRetrievalResult> => {
+    const {
+      userId = this.#core.userId,
+      chatId,
+      messageCount = 0,
+      prompt,
+      useContext = true,
+      slidingWindowSize = CORE_CONFIG.limits.chatMessagesLimit,
+      agent,
+      role,
+      abortSignal
+    } = opts
+    const db = this.#core.db.firestore()
+
+    const userContextPromise = this.#resolveTurnUserContext({ userId, role, agent, abortSignal })
+
+    const slidingWindowPromise = (async (): Promise<ChatMessagePublic[]> => {
+      if (!chatId) return []
+      try {
+        await this.#core.internals.resilience.acquireLimit('firestore')
+        const snap = await db
+          .collection('chat')
+          .doc(chatId)
+          .collection('messages')
+          .select(...PUBLIC_MESSAGE_FIELDS)
+          .orderBy('createdAt', 'desc')
+          .limit(slidingWindowSize)
+          .get()
+        return snap.docs.map((d) => mapFirestoreMessageDoc(d.id, d.data() ?? {})).reverse()
+      } catch {
+        return []
+      }
+    })()
+
+    const vectorRecallPromise = this.#vectorRecall(prompt, userId, chatId, messageCount, slidingWindowSize)
+
+    const infobasePromise =
+      useContext !== false && prompt.trim()
+        ? userContextPromise.then((userContext) =>
+            this.getContext(prompt, undefined, {
+              ...(agent?.contextAudiences ? { audiences: agent.contextAudiences } : {}),
+              ...(userContext ? { userState: userContext.state } : {})
+            })
+          )
+        : Promise.resolve([] as ContextEntry[])
+
+    const [slidingWindowDocs, rawRecalled, infobaseContextEntries, userContext] = await Promise.all([
+      slidingWindowPromise,
+      vectorRecallPromise,
+      infobasePromise,
+      userContextPromise
+    ])
+
+    const windowIds = new Set(slidingWindowDocs.map((m) => m.id))
+    const seenRecallIds = new Set<string>()
+    const recalledMemories: RecalledMemorySnippet[] = []
+    for (const mem of rawRecalled) {
+      if (windowIds.has(mem.id) || seenRecallIds.has(mem.id)) continue
+      seenRecallIds.add(mem.id)
+      recalledMemories.push(mem)
+    }
+
+    const slidingWindowMessages = slidingWindowDocs
+      .map(toModelMessageFromDoc)
+      .filter((m): m is ModelMessage => Boolean(m))
+
+    return {
+      slidingWindowDocs,
+      slidingWindowMessages,
+      recalledMemories,
+      infobaseContextEntries,
+      ...(userContext ? { userContext } : {})
+    }
+  }
+}

package/src/chat/index.ts

@@ -0,0 +1,3 @@
+export * from './schema'
+export { ChatService } from './service'
+export { coreChatRoutes, mcpRoute } from './routes'

package/src/chat/routes.ts

@@ -0,0 +1,264 @@
+import { createMcpHandler, McpServer } from '@modelcontextprotocol/server'
+import type { ModelMessage, streamText } from 'ai'
+import type { Context } from 'hono'
+import type { z } from 'zod'
+import { CORE_CONFIG, type AppEnv } from '../config'
+import type { EntryId } from '../db'
+import { core } from '../index'
+import {
+  listChatMessagesQuery,
+  openaiCompletionsBody,
+  saveChatBody,
+  streamChatBody,
+  type RawAttachmentPart,
+  type WorkflowToolSpec
+} from './schema'
+import { extractLatestUserPrompt, formatUsage, sanitizeToolInputSchema } from './utils'
+
+const listOpenaiModelsService = async () => {
+  const agents = core.internals.registry.getRegisteredAgents()
+  return {
+    object: 'list',
+    data: Object.keys(agents).map((id) => ({
+      id,
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: CORE_CONFIG.appName
+    }))
+  }
+}
+
+const parseOpenaiMessages = (
+  messages: z.infer<typeof openaiCompletionsBody>['messages']
+): { parts: RawAttachmentPart[]; modelMessages: ModelMessage[] } => {
+  const parts: RawAttachmentPart[] = []
+  const modelMessages: ModelMessage[] = []
+  for (const message of messages) {
+    if (message.role !== 'user' && message.role !== 'assistant') continue
+    const text =
+      typeof message.content === 'string'
+        ? message.content
+        : (message.content ?? [])
+            .filter((p) => p.type === 'text')
+            .map((p) => p.text ?? '')
+            .join('\n\n')
+    if (message.role === 'assistant' && text.trim()) {
+      modelMessages.push({ role: 'assistant', content: [{ type: 'text', text }] })
+    }
+    if (message.role !== 'user') continue
+    for (const p of Array.isArray(message.content) ? message.content : []) {
+      const dataUrl = p.image_url?.url ?? p.file?.file_data
+      if (dataUrl?.startsWith('data:')) parts.push({ dataUrl, filename: p.file?.filename ?? 'file' })
+    }
+    if (text.trim()) modelMessages.push({ role: 'user', content: [{ type: 'text', text }] })
+  }
+  return { parts, modelMessages }
+}
+
+const createOpenaiSseResponse = (
+  turn: ReturnType<typeof streamText>,
+  id: string,
+  created: number,
+  model: string,
+  includeUsage: boolean
+): Response => {
+  const encoder = new TextEncoder()
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (payload: unknown) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(payload)}\n\n`))
+      const sendChunk = (choices: unknown[], extra?: Record<string, unknown>) =>
+        send({ id, object: 'chat.completion.chunk', created, model, choices, ...extra })
+
+      sendChunk([{ index: 0, delta: { role: 'assistant' }, finish_reason: null }])
+      try {
+        for await (const delta of turn.textStream) {
+          if (delta) sendChunk([{ index: 0, delta: { content: delta }, finish_reason: null }])
+        }
+        sendChunk([{ index: 0, delta: {}, finish_reason: 'stop' }])
+        if (includeUsage) sendChunk([], { usage: formatUsage(await turn.usage) })
+      } catch (error) {
+        console.error('[openai] stream failed:', error)
+        send({ error: { message: 'The agent failed to produce a reply. Please retry.' } })
+      }
+      controller.enqueue(encoder.encode('data: [DONE]\n\n'))
+      controller.close()
+    }
+  })
+  return new Response(stream, {
+    headers: { 'content-type': 'text/event-stream; charset=utf-8', 'cache-control': 'no-cache' }
+  })
+}
+
+const openaiCompletionsService = async ({
+  c,
+  userId,
+  input
+}: {
+  c: Context<AppEnv>
+  userId: EntryId
+  input?: z.infer<typeof openaiCompletionsBody>
+}) => {
+  const body = input ?? openaiCompletionsBody.parse(await c.req.json().catch(() => ({})))
+  const agents = core.internals.registry.getRegisteredAgents()
+  const entries = Object.entries(agents)
+  if (entries.length === 0) return core.errors.httpError(404, 'No registered agents', 'NOT_FOUND')
+  const [defaultModel, defaultAgent] = entries[0]!
+  const modelKey = body.model && body.model in agents ? body.model : defaultModel
+  const agent = agents[modelKey] ?? defaultAgent
+  const model = agent.name ?? modelKey
+
+  await core.internals.context.enforceAgentAccess(c, agent, 'openai.completions')
+
+  const { parts, modelMessages } = parseOpenaiMessages(body.messages)
+  if (modelMessages.length === 0 && parts.length === 0) {
+    return core.errors.httpError(400, 'No supported messages', 'VALIDATION_ERROR')
+  }
+
+  const latestPrompt = extractLatestUserPrompt(modelMessages)
+  const role = core.internals.auth.resolveUserRole(userId, c.get('userRole'))
+  const { turn, userCreatedAtMs } = await core.internals.context.startChatStreamTurn({
+    userId,
+    role,
+    agent,
+    attachmentParts: parts,
+    rawUserText: latestPrompt,
+    signal: c.req.raw.signal,
+    priorMessages: modelMessages
+  })
+  const id = `chatcmpl-${crypto.randomUUID().replace(/-/g, '').slice(0, 24)}`
+  const created = Math.floor(userCreatedAtMs / 1000)
+
+  if (!body.stream) {
+    const [text, usage] = await Promise.all([turn.text, turn.usage])
+    return {
+      id,
+      object: 'chat.completion',
+      created,
+      model,
+      choices: [{ index: 0, message: { role: 'assistant', content: text }, finish_reason: 'stop' }],
+      usage: formatUsage(usage)
+    }
+  }
+
+  return createOpenaiSseResponse(turn, id, created, model, Boolean(body.stream_options?.include_usage))
+}
+
+export const mcpRoute = async (
+  request: Request,
+  userId: EntryId,
+  mcpTools: Map<string, WorkflowToolSpec>
+): Promise<Response> => {
+  const role = core.internals.auth.resolveUserRole(userId)
+  const server = new McpServer({ name: CORE_CONFIG.appName, version: '1.0.0' })
+  for (const [name, toolSpec] of mcpTools) {
+    if (toolSpec.mcp !== true) continue
+    server.registerTool(
+      name,
+      {
+        description: (toolSpec.description || name).slice(0, 1024),
+        inputSchema: sanitizeToolInputSchema(toolSpec.input)
+      },
+      async (input) => {
+        try {
+          const step = core.internals.workflows.createStepRunner('workflow')
+          const result = await core.internals.context.run({ env: core.env, userId, role, step }, () =>
+            toolSpec.execute(input, userId)
+          )
+          return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err)
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: JSON.stringify(core.errors.buildErrorBody(msg, 502, 'WORKFLOW_ERROR'))
+              }
+            ],
+            isError: true
+          }
+        }
+      }
+    )
+  }
+  return createMcpHandler(() => server).fetch(request)
+}
+
+export const coreChatRoutes = {
+  'chat.list': {
+    handler: async ({ c, userId }: { c: Context<AppEnv>; userId: EntryId }) =>
+      core.db.list(
+        'chat',
+        {
+          userId,
+          ...(c?.req.query('full') === 'true'
+            ? {}
+            : {
+                select: [
+                  'id',
+                  'userId',
+                  'agentId',
+                  'title',
+                  'model',
+                  'messageCount',
+                  'summary',
+                  'activeGenerationId',
+                  'deleted',
+                  'createdAt',
+                  'updatedAt'
+                ]
+              })
+        },
+        { bypassRbac: true }
+      )
+  },
+  'chat.get': {
+    handler: async ({ c }: { c: Context<AppEnv> }) => {
+      const chat = await core.db.read('chat', c.req.param('chatId') ?? '', false)
+      return chat ?? core.errors.httpError(404, 'Chat not found', 'NOT_FOUND')
+    }
+  },
+  'chat.messages': {
+    handler: async ({ c }: { c: Context<AppEnv> }) => {
+      const chatId = c.req.param('chatId') ?? ''
+      const parsedQuery = listChatMessagesQuery.parse(c.req.query())
+      return core.chat.messages(chatId, { limit: parsedQuery.limit, before: parsedQuery.before })
+    }
+  },
+  'chat.save': {
+    input: saveChatBody,
+    handler: ({ userId, input }: { userId: EntryId; input: z.infer<typeof saveChatBody> }) =>
+      core.internals.context.saveChat({ userId, input })
+  },
+  'chat.delete': {
+    handler: async ({ c }: { c: Context<AppEnv> }) => {
+      const chatId = c.req.param('chatId') ?? ''
+      await core.db.delete('chat', chatId)
+      return { id: chatId, deleted: true }
+    }
+  },
+  'chat.stream': {
+    input: streamChatBody,
+    handler: ({
+      c,
+      userId,
+      input
+    }: {
+      c: Context<AppEnv>
+      userId: EntryId
+      input?: z.infer<typeof streamChatBody>
+    }) => core.internals.context.streamChatSse({ c, userId, input })
+  },
+  'chat.cancel': {
+    handler: ({ c }: { c: Context<AppEnv> }) => {
+      const chatId = c.req.param('chatId') ?? ''
+      return core.chat.cancel(chatId)
+    }
+  },
+  'openai.models': {
+    handler: listOpenaiModelsService
+  },
+  'openai.completions': {
+    input: openaiCompletionsBody,
+    handler: openaiCompletionsService
+  }
+}