fix: Add response transformer to handle AI schema mismatch in Generate feature

Author: Programcode

src/lib/ai/client.ts

@@ -91,9 +91,86 @@ async function callSupabaseAI(
   return data.output;
 }
 
+/**
+ * Transforms AI generate response from various formats to the expected GenerateOutput schema.
+ * This handles cases where the AI returns a different structure than requested.
+ */
+function transformGenerateResponse(response: Record<string, unknown>): GenerateOutput {
+  // If already in correct format, return as-is
+  if (response.caseStructure && response.contentions && response.predictedOpponentCase && response.counters && response.metadata) {
+    return response as unknown as GenerateOutput;
+  }
+
+  // Transform from wrong format to correct format
+  const wrongFormatContentions = response.contentions as Array<{
+    title?: string;
+    claim?: string;
+    points?: string[];
+    evidence?: string[] | string;
+    analysis?: string;
+    reasoning?: string;
+    impact?: string;
+  }> || [];
+
+  const transformedContentions = wrongFormatContentions.map((c, i) => ({
+    id: String(i + 1),
+    claim: c.claim || c.title || 'Argument',
+    reasoning: c.reasoning || c.analysis || (Array.isArray(c.points) ? c.points.join(' ') : ''),
+    evidence: Array.isArray(c.evidence) ? c.evidence.join(' ') : (c.evidence || ''),
+    needsSource: false,
+    sourceQuery: '',
+    impact: c.impact || c.analysis || '',
+  }));
+
+  // Transform rebuttals to counters
+  const rebuttals = (response.rebuttals as Array<{ attack?: string; response?: string }>) || [];
+  const counters = rebuttals.map(r => ({
+    targetArgument: r.attack || '',
+    counterpoint: r.response || '',
+    rebuttal: r.response || '',
+  }));
+
+  // Transform potentialWeaknesses to predictedOpponentCase
+  const weaknesses = (response.potentialWeaknesses as string[]) || [];
+
+  return {
+    caseStructure: {
+      thesis: (response.thesis as string) || (response.title as string) || '',
+      framework: 'General framework',
+      keyDefinitions: [],
+      burdenOfProof: 'We must prove that ' + ((response.thesis as string) || '').slice(0, 50),
+    },
+    contentions: transformedContentions.length > 0 ? transformedContentions : [{
+      id: '1',
+      claim: 'Main argument',
+      reasoning: 'Reasoning here',
+      evidence: 'Evidence here',
+      needsSource: false,
+      sourceQuery: '',
+      impact: 'Impact here',
+    }],
+    predictedOpponentCase: {
+      likelyArguments: weaknesses.slice(0, 3),
+      strategicWeaknesses: weaknesses,
+      keyClashes: ['Main clash point'],
+    },
+    counters: counters.length > 0 ? counters : [{
+      targetArgument: 'Opponent argument',
+      counterpoint: 'Our counter',
+      rebuttal: 'Rebuttal text',
+    }],
+    metadata: {
+      side: (response.side as 'pro' | 'con') || 'pro',
+      format: 'custom',
+      generatedAt: new Date().toISOString(),
+    },
+  };
+}
+
 export async function generateCase(input: GenerateInput, config: ProviderConfig): Promise<GenerateOutput> {
   if (config.provider === 'mock') return mockGenerateCase(input.motion, input.side);
-  return callSupabaseAI('generate', input as Record<string, unknown>, config);
+  const rawResponse = await callSupabaseAI('generate', input as Record<string, unknown>, config);
+  return transformGenerateResponse(rawResponse as Record<string, unknown>);
 }
 
 export async function attackCase(input: AttackInput, config: ProviderConfig): Promise<AttackOutput> {

src/pages/GeneratePage.tsx

@@ -23,6 +23,11 @@ export default function GeneratePage() {
     setGenerateLoading(true);
     try {
       const result = await generateCase(data, config);
+      console.log('[DEBUG] Generate result:', JSON.stringify(result, null, 2));
+      console.log('[DEBUG] Has caseStructure:', !!result?.caseStructure);
+      console.log('[DEBUG] Has contentions:', !!result?.contentions);
+      console.log('[DEBUG] Has predictedOpponentCase:', !!result?.predictedOpponentCase);
+      console.log('[DEBUG] Has counters:', !!result?.counters);
       setGenerateResult(result);
     } catch (error) {
       console.error('Failed to generate case:', error);
@@ -41,7 +46,7 @@ export default function GeneratePage() {
     // TODO: Implement section-specific regeneration
     console.log('Regenerate section:', section);
   };
-  
+
   const handleSave = () => {
     if (!generateResult) return;
     const title = window.prompt("Enter a title for this case:", generateResult.caseStructure.thesis.slice(0, 50));
@@ -53,33 +58,33 @@ export default function GeneratePage() {
 
   const handleDiscuss = async () => {
     if (!generateResult) return;
-    
+
     const summary = `I'd like to discuss the case we just generated.
     
     **Thesis:** ${generateResult.caseStructure.thesis}
     
     **Contentions:**
-    ${generateResult.contentions.map((c, i) => `${i+1}. ${c.claim}`).join('\n')}
+    ${generateResult.contentions.map((c, i) => `${i + 1}. ${c.claim}`).join('\n')}
     
     Can we refine this?`;
 
     addAskMessage({ role: 'user', content: summary });
     navigate('/ask');
-    
+
     setAskLoading(true);
     try {
-      const history = [...askMessages, { role: 'user', content: summary }].map(m => ({ 
-        role: m.role as 'user' | 'assistant', 
-        content: m.content 
+      const history = [...askMessages, { role: 'user', content: summary }].map(m => ({
+        role: m.role as 'user' | 'assistant',
+        content: m.content
       }));
-      
+
       const result = await askChat(summary, history, 'general', askConfig);
-      
-      addAskMessage({ 
-        role: 'assistant', 
+
+      addAskMessage({
+        role: 'assistant',
         content: result.response,
         // @ts-expect-error: form schema and UI fields diverge
-        output: result 
+        output: result
       });
     } catch (error) {
       console.error('Failed to discuss result:', error);
@@ -115,8 +120,8 @@ export default function GeneratePage() {
                     Save Case
                   </Button>
                 </div>
-                <GenerateResults 
-                  result={generateResult} 
+                <GenerateResults
+                  result={generateResult}
                   onRegenerateSection={handleRegenerateSection}
                   onDiscuss={handleDiscuss}
                 />

supabase/functions/ai/index.ts

@@ -466,14 +466,48 @@ CRITICAL: The debate format is strictly:
 - R2 (6 min): Builds further on R1's arguments but primarily focuses on refuting the opponent.
 - Conclusor (3 min): Summarizes the debate and explains why this team wins.
 
-Return a valid JSON object matching this structure:
+CRITICAL - STRICT JSON SCHEMA REQUIREMENT:
+You MUST return a valid JSON object with EXACTLY these fields. Do NOT use different field names.
+Do NOT add extra fields. Do NOT omit any fields. Follow this structure EXACTLY:
+
 {
-  "caseStructure": { "thesis": "string", "framework": "string", "keyDefinitions": ["string"], "burdenOfProof": "string" },
-  "contentions": [{ "id": "1", "claim": "string", "reasoning": "string", "evidence": "string", "needsSource": boolean, "sourceQuery": "string", "impact": "string" }],
-  "predictedOpponentCase": { "likelyArguments": ["string"], "strategicWeaknesses": ["string"], "keyClashes": ["string"] },
-  "counters": [{ "targetArgument": "string", "counterpoint": "string", "rebuttal": "string" }],
-  "metadata": { "side": "pro/con", "format": "string", "generatedAt": "ISO string" }
-}`;
+  "caseStructure": {
+    "thesis": "The main thesis statement for the debate",
+    "framework": "The framework or lens through which to view the debate",
+    "keyDefinitions": ["definition1", "definition2"],
+    "burdenOfProof": "What we must prove to win"
+  },
+  "contentions": [
+    {
+      "id": "1",
+      "claim": "The main claim of this contention",
+      "reasoning": "Why this claim is true",
+      "evidence": "Supporting evidence",
+      "needsSource": false,
+      "sourceQuery": "",
+      "impact": "Why this matters"
+    }
+  ],
+  "predictedOpponentCase": {
+    "likelyArguments": ["Argument opponent will make"],
+    "strategicWeaknesses": ["Weakness in our case"],
+    "keyClashes": ["Main clash points"]
+  },
+  "counters": [
+    {
+      "targetArgument": "What opponent argument this counters",
+      "counterpoint": "Our counter to that argument",
+      "rebuttal": "How to phrase the rebuttal"
+    }
+  ],
+  "metadata": {
+    "side": "pro",
+    "format": "custom",
+    "generatedAt": "CURRENT_ISO_TIMESTAMP"
+  }
+}
+
+IMPORTANT: The "side" in metadata must be exactly "pro" or "con". Always include the generatedAt timestamp.`;
 
 const ATTACK_PROMPT = `You are an expert debate judge and coach. Analyze the given debate case and provide a critical breakdown in JSON format.