AI Orchestration

import { genkit } from 'genkit';
import { googleAI } from '@genkit-ai/google-genai';

export const ai = genkit({
  plugins: [googleAI()],
  model: 'googleai/gemini-2.5-flash',
});

const mainAnalysisPrompt = ai.definePrompt({
  name: 'mainAnalysisPrompt',
  input: { 
    schema: z.object({ 
      input: z.string(), 
      searchQuery: z.string(), 
      context: z.string() 
    }) 
  },
  output: {
    schema: z.object({
      blueprint: z.array(ArgumentNodeSchema),
      summary: z.string(),
      analysis: z.string(),
      credibilityScore: z.number(),
      brutalHonestTake: z.string(),
      keyPoints: z.array(z.string()),
      fallacies: z.array(DetectedFallacySchema),
    })
  },
  system: `You are an expert AI assistant specializing in rigorous, 
  balanced argument deconstruction and LOGICAL FALLACY DETECTION.
  
  Core Principles:
  1. Objectivity is Paramount - Act as neutral synthesizer
  2. Depth and Detail - Identify distinct lines of reasoning
  3. Ground Everything in Sources - Tie every node to provided context
  4. Detect Logical Fallacies - Actively scan for errors in reasoning
  
  Execution Process:
  1. Analyze Context - Read provided sources
  2. Identify Thesis - Determine central question
  3. Deconstruct Both Sides - Claims, counterclaims, evidence
  4. Excavate Evidence - Extract verbatim snippets
  5. Detect Fallacies - Identify specific logical errors
  6. Build Blueprint - Construct JSON object
  
  You must respond with valid JSON in a \`\`\`json code block.`,
  
  prompt: `Initial Query: {{{input}}}
  Search Query Used: {{{searchQuery}}}
  
  *** RESEARCH CONTEXT (Analysis Sources) ***
  {{{context}}}`
});

import { ai } from '@/ai/genkit';

export const webSearch = ai.defineTool(
  {
    name: 'webSearch',
    description: 'Searches the web for information using Firecrawl',
    inputSchema: z.object({
      query: z.string().describe('Search query'),
    }),
    outputSchema: z.array(z.object({
      title: z.string(),
      link: z.string(),
      snippet: z.string(),
    })),
  },
  async (input) => {
    // Implementation
    const results = await searchWeb(input.query);
    return results;
  }
);

let context = "";

if (scrapedDocs.length > 0) {
  context = scrapedDocs.map((doc, index) => `
--- SOURCE ${index + 1} ---
URL: ${doc.url}
Extracted Text:
${doc.content.substring(0, 12000)} 
  `).join("\n\n");
}

const rawText = mainAnalysisResponse.text;
let jsonString = "";

// Try to extract from code block
const jsonBlockMatch = rawText.match(/```json\n([\s\S]*?)\n```/);

if (jsonBlockMatch && jsonBlockMatch[1]) {
  jsonString = jsonBlockMatch[1];
} else {
  // Fallback: Find braces
  const firstBrace = rawText.indexOf('{');
  const lastBrace = rawText.lastIndexOf('}');
  
  if (firstBrace !== -1 && lastBrace !== -1) {
    jsonString = rawText.substring(firstBrace, lastBrace + 1);
  }
}

// Use JSON5 for lenient parsing (allows trailing commas)
const parsed = JSON5.parse(jsonString);

try {
  const validatedOutput = GenerateArgumentBlueprintOutputSchema.parse(parsed);
  return validatedOutput;
} catch (error) {
  if (error instanceof ZodError) {
    console.error("Schema validation failed:", error.errors);
    // Log specific field errors for debugging
    error.errors.forEach(err => {
      console.error(`- ${err.path.join('.')}: ${err.message}`);
    });
  }
  throw new Error("AI output does not match expected schema");
}

async function callAIWithRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (i === maxRetries - 1) throw error;
      
      const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
      console.log(`Retry ${i + 1}/${maxRetries} after ${delay}ms`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
  throw new Error("Max retries exceeded");
}

const [searchResults, twitterResults] = await Promise.all([
  searchWeb(searchQuery),
  twitterSearch({ query: searchQuery }),
]);

const stream = await ai.generateStream({
  prompt: analysisPrompt,
  model: 'gemini-2.5-flash',
});

for await (const chunk of stream) {
  // Send partial results to client
  sendSSE({ type: 'chunk', data: chunk });
}

console.log('[Flow] Generated Query:', searchQuery);
console.log('[Flow] Found ${results.length} sources');
console.log('[Flow] Context length:', context.length, 'chars');
console.log('[Flow] Analysis complete. Credibility:', score);