Genkit Integration

const myFlow = ai.defineFlow(
  {
    name: 'flowName',
    inputSchema: InputSchema,
    outputSchema: OutputSchema,
  },
  async (input) => {
    // Flow logic here
    return output;
  }
);

const summarizeSourceTextFlow = ai.defineFlow(
  {
    name: 'summarizeSourceTextFlow',
    inputSchema: SummarizeSourceTextInputSchema,
    outputSchema: SummarizeSourceTextOutputSchema,
  },
  async input => {
    const {output} = await summarizeSourceTextPrompt(input);
    return output!;
  }
);

const generateArgumentBlueprintFlow = ai.defineFlow(
  {
    name: 'generateArgumentBlueprintFlow',
    inputSchema: GenerateArgumentBlueprintInputSchema,
    outputSchema: GenerateArgumentBlueprintOutputSchema,
  },
  async (input) => {
    // Multi-stage pipeline
    const searchQueryResponse = await searchQueryPrompt(input);
    const mainAnalysisResponse = await mainAnalysisPrompt({ 
      ...input, 
      searchQuery: searchQueryResponse.output?.searchQuery 
    });
    
    // Manual JSON extraction
    const jsonBlockMatch = rawText.match(/```json\n([\s\S]*?)\n```/);
    const coreAnalysis = JSON.parse(jsonBlockMatch[1]);
    
    // Graceful error handling
    let tweets = [];
    try {
      const twitterResult = await twitterSearch({ query: searchQuery });
      tweets = twitterResult.sort(
        (a, b) => b.public_metrics.like_count - a.public_metrics.like_count
      );
    } catch (error) {
      console.error("Twitter search failed, continuing...");
    }
    
    return { ...coreAnalysis, tweets: tweets.slice(0, 5) };
  }
);

const myPrompt = ai.definePrompt({
  name: 'promptName',
  input: { schema: InputSchema },
  output: { schema: OutputSchema },
  tools: [tool1, tool2],  // Optional
  system: 'System instructions...',  // Optional
  prompt: 'User prompt with {{{variables}}}',
});

const prompt = ai.definePrompt({
  name: 'explainLogicalFallacyPrompt',
  input: {schema: ExplainLogicalFallacyInputSchema},
  output: {schema: ExplainLogicalFallacyOutputSchema},
  prompt: `You are an expert in logic and rhetoric. Provide a clear, 
           concise explanation for the following logical fallacy: 
           {{{fallacyName}}}. 
           
           Explain what the fallacy is and provide a simple example.
           {{json}}`,
});

const mainAnalysisPrompt = ai.definePrompt({
  name: 'mainAnalysisPrompt',
  input: {schema: z.object({ 
    input: z.string(), 
    searchQuery: z.string() 
  })},
  output: {schema: z.object({
    blueprint: z.array(ArgumentNodeSchema),
    summary: z.string(),
    analysis: z.string(),
  })},
  tools: [webSearch],  // AI can call this tool during execution
  system: `You are an expert AI assistant specializing in rigorous, 
  balanced, and detailed argument deconstruction. Your task is to 
  provide a comprehensive, neutral, and multi-faceted analysis.
  
  **Core Principles:**
  1. **Objectivity is Paramount**: Act as a neutral synthesizer
  2. **Depth and Detail**: Go beyond the surface
  3. **Ground Everything in Sources**: Every node must cite sources
  4. **Find the Opposition**: Search for credible counter-arguments
  
  **Execution Process:**
  1. Analyze Input
  2. Comprehensive Web Search using webSearch tool with searchQuery
  3. Identify Core Thesis
  4. Deconstruct Both Sides (claims and counterclaims)
  5. Excavate Evidence
  6. Build the JSON Blueprint
  7. Generate Summary & Analysis
  
  You must respond with a valid JSON object enclosed in a \`\`\`json code block.`,
  prompt: `Initial Input: {{{input}}}`,
});

export const myTool = ai.defineTool(
  {
    name: 'toolName',
    description: 'What the tool does - AI uses this to decide when to call it',
    inputSchema: InputSchema,
    outputSchema: OutputSchema,
  },
  async (input) => {
    // Tool implementation
    return output;
  }
);

export const webSearch = ai.defineTool(
  {
    name: 'webSearch',
    description: 'Searches the web for a given query and returns a list of search results, including organic results, news, and academic papers to get a comprehensive overview.',
    inputSchema: WebSearchInputSchema,
    outputSchema: WebSearchOutputSchema,
  },
  async (input) => {
    if (!process.env.SERPAPI_API_KEY) {
      throw new Error('SERPAPI_API_KEY is not configured.');
    }

    const response = await getJson({
      api_key: process.env.SERPAPI_API_KEY,
      q: input.query,
      engine: 'google',
      location: 'United States',
    });

    const organicResults = (response.organic_results || []).map(result => ({
      title: result.title,
      link: result.link,
      snippet: result.snippet,
    }));
    
    return organicResults.slice(0, 7);
  }
);

import { z } from 'genkit';

const MyInputSchema = z.object({
  field1: z.string().describe('Description for AI understanding'),
  field2: z.number().optional(),
  field3: z.enum(['option1', 'option2']),
});

type MyInput = z.infer<typeof MyInputSchema>;

const ArgumentNodeSchema = z.object({
  id: z.string().describe('Unique identifier for the argument node.'),
  parentId: z.string().nullable().describe(
    'ID of the parent node, or null if it is a root node.'
  ),
  type: z.enum(['thesis', 'claim', 'counterclaim', 'evidence']).describe(
    'Type of the argument node.'
  ),
  side: z.enum(['for', 'against']).describe(
    'Side of the argument node.'
  ),
  content: z.string().describe('The content of the argument node.'),
  sourceText: z.string().describe(
    'The original text snippet from the source that supports the content.'
  ),
  source: z.string().url().describe(
    'The URL of the source document.'
  ),
  fallacies: z.array(z.string()).describe(
    'An array of logical fallacies identified in this specific argument node.'
  ),
  logicalRole: z.string().describe(
    "A concise statement explaining the node's function in the overall argument."
  ),
});

const BlueprintSchema = z.object({
  blueprint: z.array(ArgumentNodeSchema).describe(
    'A structured JSON blueprint of the arguments.'
  ),
  summary: z.string().describe(
    "A concise, neutral summary of the overall state of the debate."
  ),
  analysis: z.string().describe(
    "AI-driven meta-analysis providing novel insights."
  ),
});

const mainAnalysisPrompt = ai.definePrompt({
  name: 'mainAnalysisPrompt',
  input: {schema: z.object({ input: z.string(), searchQuery: z.string() })},
  output: {schema: z.object({
    blueprint: z.array(ArgumentNodeSchema),
    summary: z.string(),
    analysis: z.string(),
  })},
  tools: [webSearch],  // ← AI can call webSearch automatically
  system: `...
  **Execution Process:**
  1. Analyze Input
  2. Comprehensive Web Search using the \`webSearch\` tool with the 
     provided \`searchQuery\` to find credible opposing viewpoints
  3. Synthesize information from MULTIPLE diverse, high-authority sources
  ...
  `,
});

const {output} = await prompt(input);
// output is typed and validated against outputSchema
if (!output) {
  throw new Error('Prompt failed to produce valid output');
}
return output;

const mainAnalysisResponse = await mainAnalysisPrompt({ ...input });
const rawText = mainAnalysisResponse.text;

const jsonBlockMatch = rawText.match(/```json\n([\s\S]*?)\n```/);
if (!jsonBlockMatch || !jsonBlockMatch[1]) {
  console.error("Raw AI response:", rawText);
  throw new Error("Could not find valid JSON block in AI response");
}

let coreAnalysis;
try {
  coreAnalysis = JSON.parse(jsonBlockMatch[1]);
} catch(e) {
  console.error("Failed to parse JSON:", jsonBlockMatch[1]);
  throw new Error("Failed to parse JSON from AI response");
}

if (!process.env.SERPAPI_API_KEY || 
    process.env.SERPAPI_API_KEY === 'YOUR_API_KEY_HERE') {
  throw new Error(
    'SERPAPI_API_KEY is not configured. Please add it to your .env file.'
  );
}

import { generateArgumentBlueprint } from '@/ai/flows/generate-argument-blueprint';
import type { 
  GenerateArgumentBlueprintInput,
  GenerateArgumentBlueprintOutput 
} from '@/ai/flows/generate-argument-blueprint';

const input: GenerateArgumentBlueprintInput = {
  input: 'Should AI be regulated?'
};

const result: GenerateArgumentBlueprintOutput = 
  await generateArgumentBlueprint(input);

// Full autocomplete and type checking
console.log(result.blueprint);   // ArgumentNode[]
console.log(result.summary);     // string
console.log(result.tweets);      // Tweet[]