Important Fixes, New mechanics, and many more

apps/web/server/api/v1/coauthor/sessions/[id].get.ts

@@ -0,0 +1,15 @@
+import { requireStageTwoUser, stageTwoApiError, stageTwoDatabase, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const id = stageTwoUuid(getRouterParam(event, 'id'))
+    const sessions = await stageTwoDatabase<Array<Record<string, unknown>>>(
+      `coauthor_sessions?select=id,status,messages,generated_world,confirmed_world_id,created_at,updated_at&id=eq.${id}&owner_id=eq.${user.id}&limit=1`,
+    )
+    if (!sessions[0]) throw createError({ statusCode: 404, statusMessage: 'Coauthor session not found.' })
+    return { session: { ...sessions[0], generatedWorld: sessions[0].generated_world ?? null } }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/[id]/confirm.post.ts

@@ -0,0 +1,30 @@
+import { WorldStarterSchema } from '@dng/shared'
+import { z } from 'zod'
+import { requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoDatabase, stageTwoRpc, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+
+const BodySchema = z.object({ world: WorldStarterSchema.optional() }).strict()
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const sessionId = stageTwoUuid(getRouterParam(event, 'id'), 'session id')
+    const body = BodySchema.parse((await readBody(event)) ?? {})
+    const sessions = await stageTwoDatabase<Array<{ generated_world: unknown }>>(
+      `coauthor_sessions?select=generated_world&id=eq.${sessionId}&owner_id=eq.${user.id}&limit=1`,
+    )
+    if (!sessions[0]) throw createError({ statusCode: 404, statusMessage: 'Coauthor session not found.' })
+    const world = WorldStarterSchema.parse(body.world ?? sessions[0].generated_world)
+    requireStageTwoSafeText(JSON.stringify(world))
+    if (body.world) {
+      await stageTwoDatabase(`coauthor_sessions?id=eq.${sessionId}&owner_id=eq.${user.id}`, {
+        method: 'PATCH', prefer: 'return=minimal', body: JSON.stringify({ generated_world: world, updated_at: new Date().toISOString() }),
+      })
+    }
+    const worldId = await stageTwoRpc<string>('stage_two_confirm_world', {
+      p_session_id: sessionId, p_owner_id: user.id,
+    })
+    return { worldId }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/[id]/generate.post.ts

@@ -0,0 +1,15 @@
+import { requireStageTwoUser, stageTwoApiError, stageTwoRpc, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const sessionId = stageTwoUuid(getRouterParam(event, 'id'), 'session id')
+    const jobId = await stageTwoRpc<string>('stage_two_enqueue_world_generation', {
+      p_session_id: sessionId, p_owner_id: user.id,
+    })
+    setResponseStatus(event, 202)
+    return { jobId, status: 'queued' }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/[id]/messages.post.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod'
+import { requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoRpc, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+
+const BodySchema = z.object({ content: z.string().trim().min(1).max(5000) }).strict()
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const sessionId = stageTwoUuid(getRouterParam(event, 'id'), 'session id')
+    const body = BodySchema.parse(await readBody(event))
+    requireStageTwoSafeText(body.content)
+    const session = await stageTwoRpc<Record<string, unknown>>('stage_two_append_coauthor_message', {
+      p_session_id: sessionId, p_owner_id: user.id, p_content: body.content,
+    })
+    return { session }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/[id]/respond.post.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod'
+import { buildJsonCompletion, parseJsonCompletion } from '~/server/utils/ai-provider'
+import { requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoDatabase, stageTwoRpc, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+
+const MessageSchema = z.object({ role: z.enum(['user', 'assistant']), content: z.string().min(1).max(5000) })
+const QuestionSchema = z.object({
+  question: z.string().trim().min(5).max(300),
+  options: z.array(z.string().trim().min(1).max(100)).length(3),
+})
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const sessionId = stageTwoUuid(getRouterParam(event, 'id'), 'session id')
+    const sessions = await stageTwoDatabase<Array<{ status: string; messages: unknown }>>(
+      `coauthor_sessions?select=status,messages&id=eq.${sessionId}&owner_id=eq.${user.id}&limit=1`,
+    )
+    const session = sessions[0]
+    if (!session) throw createError({ statusCode: 404, statusMessage: 'Coauthor session not found.' })
+    if (session.status !== 'collecting') throw createError({ statusCode: 409, statusMessage: 'This coauthor session is not accepting answers.' })
+    const messages = z.array(MessageSchema).min(1).max(12).parse(session.messages)
+    const answerCount = Math.max(0, messages.filter(message => message.role === 'user').length - 1)
+    if (answerCount >= 4) return { readyToGenerate: true }
+
+    const completion = buildJsonCompletion(useRuntimeConfig(), {
+      system: `You are the Dungeons & Ground coauthor. Based only on this conversation, ask one focused question that makes the original TTRPG world more playable. This is clarification ${answerCount + 1} of 4. Do not repeat a topic already answered. Adapt to the requested genre. Provide exactly three concise, mutually distinct answer options. Keep everything suitable for ages 13+.`,
+      messages,
+      schemaName: 'coauthor_question',
+      jsonSchema: QuestionSchema.toJSONSchema(),
+    })
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 30_000)
+    let response: Response
+    try {
+      response = await fetch(completion.endpoint, {
+        method: 'POST', headers: completion.headers, body: JSON.stringify(completion.body), signal: controller.signal,
+      })
+    } finally {
+      clearTimeout(timeout)
+    }
+    if (!response.ok) throw createError({ statusCode: 502, statusMessage: 'The coauthor is temporarily unavailable.' })
+    const question = QuestionSchema.parse(parseJsonCompletion(await response.json()))
+    requireStageTwoSafeText([question.question, ...question.options].join('\n'))
+    await stageTwoRpc('stage_two_append_coauthor_assistant_message', {
+      p_session_id: sessionId, p_owner_id: user.id, p_content: question.question,
+    })
+    return {
+      readyToGenerate: false,
+      question: { id: `question-${messages.length}`, label: question.question, options: question.options },
+    }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/index.get.ts

@@ -0,0 +1,13 @@
+import { requireStageTwoUser, stageTwoApiError, stageTwoDatabase } from '~/server/utils/stage-two-supabase'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const sessions = await stageTwoDatabase<Array<Record<string, unknown>>>(
+      `coauthor_sessions?select=id,status,messages,generated_world,confirmed_world_id,created_at,updated_at&owner_id=eq.${user.id}&order=updated_at.desc`,
+    )
+    return { sessions }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

apps/web/server/api/v1/coauthor/sessions/index.post.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod'
+import { requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoDatabase } from '~/server/utils/stage-two-supabase'
+
+const BodySchema = z.object({ message: z.string().trim().min(1).max(5000).optional() }).strict()
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const body = BodySchema.parse((await readBody(event)) ?? {})
+    if (body.message) requireStageTwoSafeText(body.message)
+    const sessions = await stageTwoDatabase<Array<Record<string, unknown>>>('coauthor_sessions', {
+      method: 'POST',
+      prefer: 'return=representation',
+      body: JSON.stringify({
+        owner_id: user.id,
+        messages: body.message ? [{ role: 'user', content: body.message }] : [],
+      }),
+    })
+    setResponseStatus(event, 201)
+    return { session: sessions[0] }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})