Add AI-assisted world and character drafting flows

apps/web/server/api/v1/campaigns/[id]/characters.post.ts

@@ -1,6 +1,6 @@
 import { AbilityScoresSchema } from '@dng/shared'
 import { z } from 'zod'
-import { requireCampaignAccess, requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoDatabase, stageTwoUuid } from '~/server/utils/stage-two-supabase'
+import { requireCampaignAccess, requireStageTwoSafeText, requireStageTwoUser, stageTwoApiError, stageTwoDatabase, stageTwoRpc, stageTwoUuid } from '~/server/utils/stage-two-supabase'
 
 const BodySchema = z.object({
   name: z.string().trim().min(1).max(80),
@@ -26,25 +26,24 @@ export default defineEventHandler(async (event) => {
       throw createError({ statusCode: 403, statusMessage: 'Only the campaign owner can add AI heroes.' })
     }
     requireStageTwoSafeText([body.name, body.concept, ...body.inventory, ...body.statuses, JSON.stringify(body.persona)].join('\n'))
-    const rows = await stageTwoDatabase<Array<Record<string, unknown>>>('characters', {
-      method: 'POST',
-      prefer: 'return=representation',
-      body: JSON.stringify({
-        campaign_id: campaignId,
-        user_id: body.controller === 'human' ? user.id : null,
-        name: body.name,
-        concept: body.concept,
-        controller: body.controller,
-        abilities: body.abilities,
-        hp: body.hp,
-        max_hp: body.maxHp,
-        defense: body.defense,
-        proficiency: body.proficiency,
-        inventory: body.inventory,
-        statuses: body.statuses,
-        persona: body.persona,
-      }),
+    const characterId = await stageTwoRpc<string>('stage_four_create_character', {
+      p_campaign_id: campaignId,
+      p_actor_id: user.id,
+      p_controller: body.controller,
+      p_name: body.name,
+      p_concept: body.concept,
+      p_abilities: body.abilities,
+      p_hp: body.hp,
+      p_max_hp: body.maxHp,
+      p_defense: body.defense,
+      p_proficiency: body.proficiency,
+      p_inventory: body.inventory,
+      p_statuses: body.statuses,
+      p_persona: body.persona,
     })
+    const rows = await stageTwoDatabase<Array<Record<string, unknown>>>(
+      `characters?select=*&id=eq.${characterId}&campaign_id=eq.${campaignId}&limit=1`,
+    )
     setResponseStatus(event, 201)
     return { character: rows[0] }
   } catch (error) {

apps/web/server/api/v1/campaigns/[id]/characters/suggest.post.ts

@@ -0,0 +1,77 @@
+import { CharacterDraftSchema } from '@dng/shared'
+import { z } from 'zod'
+import { buildJsonCompletion, parseJsonCompletion } from '~/server/utils/ai-provider'
+import {
+  requireCampaignAccess,
+  requireStageTwoSafeText,
+  requireStageTwoUser,
+  stageTwoApiError,
+  stageTwoDatabase,
+  stageTwoUuid,
+} from '~/server/utils/stage-two-supabase'
+
+const BodySchema = z.object({
+  concept: z.string().trim().max(600).default(''),
+  controller: z.enum(['human', 'ai']).default('human'),
+}).strict()
+
+export default defineEventHandler(async (event) => {
+  try {
+    const user = await requireStageTwoUser(event)
+    const campaignId = stageTwoUuid(getRouterParam(event, 'id'), 'campaign id')
+    const access = await requireCampaignAccess(campaignId, user.id)
+    const body = BodySchema.parse((await readBody(event)) ?? {})
+    if (body.controller === 'ai' && !access.owner) {
+      throw createError({ statusCode: 403, statusMessage: 'Only the campaign owner can add AI heroes.' })
+    }
+    if (body.concept) requireStageTwoSafeText(body.concept)
+
+    const worlds = await stageTwoDatabase<Array<Record<string, unknown>>>(
+      `worlds?select=title,genre,tone,premise,content_boundaries&` +
+      `id=eq.${String(access.campaign.world_id)}&limit=1`,
+    )
+    const world = worlds[0]
+    if (!world) throw createError({ statusCode: 404, statusMessage: 'Campaign world not found.' })
+
+    const completion = buildJsonCompletion(useRuntimeConfig(), {
+      system: `You create an original, editable Dungeons & Ground character draft for a private 13+ TTRPG campaign. Adapt archetype, equipment and voice to the supplied genre, but always use STR, DEX, CON, INT, WIS and CHA. Keep an alpha hero grounded: ability scores 7–16, max HP 8–20, Defense 10–16, proficiency 2. Give 2–5 useful starting items and a distinctive persona. Never use protected franchise characters. Return only the requested JSON.`,
+      messages: [{
+        role: 'user',
+        content: JSON.stringify({
+          world,
+          currentScene: access.campaign.current_scene,
+          heroKind: body.controller === 'ai' ? 'persistent AI companion' : 'human player character',
+          requestedConcept: body.concept || 'Surprise me with a character who creates interesting choices for this party.',
+        }),
+      }],
+      schemaName: 'character_draft',
+      jsonSchema: CharacterDraftSchema.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 character coauthor is temporarily unavailable.' })
+
+    let character
+    try {
+      character = CharacterDraftSchema.parse(parseJsonCompletion(await response.json()))
+    } catch {
+      throw createError({ statusCode: 502, statusMessage: 'The coauthor returned an invalid character draft.' })
+    }
+    requireStageTwoSafeText(JSON.stringify(character))
+    return { character }
+  } catch (error) {
+    stageTwoApiError(error)
+  }
+})

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

@@ -5,7 +5,7 @@ export default defineEventHandler(async (event) => {
     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`,
+      `coauthor_sessions?select=id,status,messages,current_question,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 } }

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

@@ -7,13 +7,18 @@ const QuestionSchema = z.object({
   question: z.string().trim().min(5).max(300),
   options: z.array(z.string().trim().min(1).max(100)).length(3),
 })
+const StoredQuestionSchema = z.object({
+  id: z.string().trim().min(1).max(80),
+  label: 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 sessions = await stageTwoDatabase<Array<{ status: string; messages: unknown; current_question: unknown }>>(
+      `coauthor_sessions?select=status,messages,current_question&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.' })
@@ -21,6 +26,9 @@ export default defineEventHandler(async (event) => {
     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 }
+    if (session.current_question) {
+      return { readyToGenerate: false, question: StoredQuestionSchema.parse(session.current_question) }
+    }
 
     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+.`,
@@ -41,12 +49,17 @@ export default defineEventHandler(async (event) => {
     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,
+    const storedQuestion = StoredQuestionSchema.parse({
+      id: `question-${answerCount + 1}`,
+      label: question.question,
+      options: question.options,
+    })
+    await stageTwoRpc('stage_four_set_coauthor_question', {
+      p_session_id: sessionId, p_owner_id: user.id, p_question: storedQuestion,
     })
     return {
       readyToGenerate: false,
-      question: { id: `question-${messages.length}`, label: question.question, options: question.options },
+      question: storedQuestion,
     }
   } catch (error) {
     stageTwoApiError(error)

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

@@ -4,7 +4,7 @@ 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`,
+      `coauthor_sessions?select=id,status,messages,current_question,generated_world,confirmed_world_id,created_at,updated_at&owner_id=eq.${user.id}&status=in.(collecting,generating,ready,failed)&order=updated_at.desc`,
     )
     return { sessions }
   } catch (error) {

apps/web/server/api/worlds/generate.post.ts

@@ -1,7 +1,9 @@
 import { CreateWorldRequestSchema, WorldStarterSchema, moderate13Plus } from '@dng/shared'
 import { buildJsonCompletion, parseJsonCompletion } from '../../utils/ai-provider'
+import { requireStageTwoUser } from '../../utils/stage-two-supabase'
 
 export default defineEventHandler(async event => {
+  await requireStageTwoUser(event)
   const raw = await readBody(event)
   const prompt = typeof raw?.prompt === 'string' ? raw.prompt : ''
   const answers = raw?.answers && typeof raw.answers === 'object' ? raw.answers : {}
@@ -28,9 +30,14 @@ export default defineEventHandler(async event => {
     body: JSON.stringify(completion.body),
   })
   if (!response.ok) throw createError({ statusCode: 502, statusMessage: 'The coauthor is temporarily unavailable.' })
+  let world
   try {
-    return WorldStarterSchema.parse(parseJsonCompletion(await response.json()))
+    world = WorldStarterSchema.parse(parseJsonCompletion(await response.json()))
   } catch {
     throw createError({ statusCode: 502, statusMessage: 'The coauthor returned an invalid world structure.' })
   }
+  if (!moderate13Plus(JSON.stringify(world)).allowed) {
+    throw createError({ statusCode: 422, statusMessage: 'The generated world falls outside the alpha’s 13+ content boundary.' })
+  }
+  return world
 })