AI Analysis Agentic Pipeline Implementation Plan

export const maxDuration = 60;

git add src/pages/api/ai-analysis.ts
git commit -m "fix: add maxDuration=60 to ai-analysis API route"

const digestSchema = z.object({
  signals: z.array(z.string()).max(3).describe(
    'Up to 3 strongest stat signals. Each entry: player name, stat type, hit rate, sample size, and one sentence on why it is significant. If fewer than 3 exist, return fewer — do not pad.'
  ),
  newsFacts: z.array(z.string()).max(4).describe(
    'Concrete facts from the match preview only: specific injuries or suspensions with their tactical implication, surprising form facts. Skip generic observations.'
  ),
  connections: z.array(z.string()).max(3).describe(
    'Explicit connections between a news fact and a stat signal. Example: "Kamara suspended → Villa press disrupted → opponent midfield throughput trends more relevant." Also include signals to deprioritise given the news.'
  ),
  topBets: z.array(z.string()).max(2).describe(
    'Best 1-2 bets as one sentence each: player + market + why it stands out in this specific match. If no strong signals exist, return an empty array — do not fabricate.'
  ),
});

type Digest = z.infer<typeof digestSchema>;

function serialiseDigest(digest: Digest): string {
  const lines: string[] = [];
  if (digest.signals.length > 0) {
    lines.push('SIGNALS:\n' + digest.signals.map(s => `- ${s}`).join('\n'));
  }
  if (digest.newsFacts.length > 0) {
    lines.push('NEWS FACTS:\n' + digest.newsFacts.map(f => `- ${f}`).join('\n'));
  }
  if (digest.connections.length > 0) {
    lines.push('CONNECTIONS:\n' + digest.connections.map(c => `- ${c}`).join('\n'));
  }
  if (digest.topBets.length > 0) {
    lines.push('TOP BETS:\n' + digest.topBets.map(b => `- ${b}`).join('\n'));
  }
  return lines.join('\n\n');
}

npx tsc --noEmit 2>&1 | head -30

git add src/pages/api/ai-analysis.ts
git commit -m "feat: add digest schema and serialiseDigest helper to ai-analysis"

    const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000';
    const isUpcoming = !matchDate || new Date(matchDate) > new Date();
    const cookie = req.headers.cookie || '';

    // Helper to fetch trends for a specific odds range
    const fetchTrends = (from: number, to: number, pageSize = 20) =>
      fetch(`${baseUrl}/api/props/player-trends`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json', Cookie: cookie },
        body: JSON.stringify({
          games: [Number(eventId)], statTypes: [], bookmakers: [],
          oddsRange: { from, to }, page: 1, pageSize,
          sorting: { column: 'trendPercentage', direction: 'desc' }, minWindow: 5,
        }),
      }).then(r => r.json()).then(r => r?.data || []).catch(() => []);

    // Helper to summarise trends for AI prompt
    const summariseTrends = (trends: any[]) => trends.length > 0
      ? trends.map((t: any, i: number) =>
          `[${i}] ${t.playerName} (${t.teamName}): ${t.statType} ${t.oddsType} ${t.line} — ` +
          `${t.trendHits}/${t.trendWindow} (${Math.round(t.trendHits / t.trendWindow * 100)}%) — ` +
          `Best odds: ${t.bookmakers?.[0]?.oddsValue?.toFixed(2) || 'N/A'}`
        ).join('\n')
      : 'None available.';

    // Helper to summarise value bets for AI prompt
    const summariseValueBets = (vbs: any[]) => vbs.length > 0
      ? vbs.map((vb: any) =>
          `${vb.playerName} (${vb.teamName}): ${vb.marketType} over ${vb.line} — ` +
          `Fair odds: ${vb.scannerFairOdds?.toFixed(2) || 'N/A'}, Best: ${vb.bestOverOdds?.toFixed(2) || 'N/A'}, ` +
          `EV: ${vb.scannerEdge != null ? `${vb.scannerEdge.toFixed(1)}%` : 'N/A'}, ` +
          `L10: ${vb.hitRates?.l10 != null ? `${Math.round(vb.hitRates.l10)}%` : 'N/A'}`
        ).join('\n')
      : 'None available.';

    // AI curation schema for each category
    const categorySchema = z.object({
      bestIndices: z.array(z.number()).max(5).describe('Indices of the best 3-5 picks from this category'),
    });

    // --- PHASE 1: Fetch everything in parallel ---
    const [builderTrends, singlesTrends, longshotTrends, valueBetsRaw, perplexityResult] = await Promise.all([
      fetchTrends(1.01, 1.59, 15),
      fetchTrends(1.60, 3.00, 20),
      fetchTrends(3.01, 50, 15),
      fetch(`${baseUrl}/api/value-bets-v2?eventIds=${eventId}&mode=scanner&perPage=15`, { headers: { Cookie: cookie } })
        .then(r => r.json()).then(r => r?.data || []).catch(() => []),
      webSearch(
        `${homeTeamName} vs ${awayTeamName} match preview ${tournamentName || 'football'}. ` +
        `Include: team form, key injuries/suspensions, tactical notes, head-to-head recent history. Be concise.`
      ).catch(() => null),
    ]);

    const matchPreview = perplexityResult?.data?.answer || 'Match preview unavailable.';

    // --- PHASE 2: Internal digest (not streamed) ---
    let digestStr = '';
    try {
      const allTrendsSummary = [
        builderTrends.length > 0 ? `BET BUILDER TRENDS (low odds):\n${summariseTrends(builderTrends)}` : '',
        singlesTrends.length > 0 ? `SINGLES TRENDS (mid odds):\n${summariseTrends(singlesTrends)}` : '',
        longshotTrends.length > 0 ? `LONGSHOT TRENDS (high odds):\n${summariseTrends(longshotTrends)}` : '',
      ].filter(Boolean).join('\n\n') || 'No trends available.';

      const valueBetsSummary = summariseValueBets(valueBetsRaw);

      const { object: digest } = await generateObject({
        model: gateway('xai/grok-4.1-fast-non-reasoning'),
        temperature: 0.3,
        schema: digestSchema,
        prompt: `You are a football betting analyst. Analyse the following data for ${homeTeamName} vs ${awayTeamName}${tournamentName ? ` (${tournamentName})` : ''} and produce a structured internal digest.

MATCH PREVIEW (from web search):
${matchPreview}

PLAYER TRENDS:
${allTrendsSummary}

VALUE BETS:
${valueBetsSummary}

Instructions:
- Extract the 2-3 strongest statistical signals (high hit rate + good sample size + relevant odds)
- Extract only concrete, specific facts from the match preview (injuries with named players, specific form stats)
- Identify explicit connections between news facts and statistical signals — e.g. how an injury changes which trends become more or less meaningful
- List the 1-2 best bets that combine strong stats AND match context
- If there is no meaningful data in a category, leave it empty — do not fabricate`,
      });

      digestStr = serialiseDigest(digest);
    } catch (digestErr) {
      console.error('[AI-ANALYSIS] Digest failed, proceeding without context:', digestErr);
      // digestStr remains '' — pipeline degrades gracefully
    }

    const digestContext = digestStr
      ? `You have already analysed this match. Your findings:\n${digestStr}`
      : '';

    const BANNED_PHRASES = [
      '"counter-attacking prowess"', '"wing play"', '"ball-winning ability"',
      '"could be a good bet"', '"form, injuries, and tactical notes"',
    ].join(', ');

    // --- PHASE 3a: Match context ---
    const { object: ctxResult } = await generateObject({
      model: gateway('xai/grok-4.1-fast-non-reasoning'),
      temperature: 0.5,
      schema: z.object({ matchContext: z.string() }),
      system: digestContext || undefined,
      prompt: `Write a match context for ${homeTeamName} vs ${awayTeamName}${tournamentName ? ` (${tournamentName})` : ''} for an ${isUpcoming ? 'upcoming' : 'post-match'} analysis.

Rules:
- Lead with the most surprising or important fact — not a generic form summary
- Connect at least one news fact to a stat signal explicitly
- Name specific players where relevant
- 2-3 sentences maximum
- Write as a sharp analyst advising a knowledgeable bettor
- Do NOT use these phrases: ${BANNED_PHRASES}
- Every sentence must be traceable to a specific fact or stat — no generic observations`,
    });

    sendEvent(res, 'matchContext', ctxResult.matchContext);

    // --- PHASE 3b: Best pick ---
    const singlesText = summariseTrends(singlesTrends);
    const { object: pickResult } = await generateObject({
      model: gateway('xai/grok-4.1-fast-non-reasoning'),
      temperature: 0.3,
      schema: z.object({
        bestPickIndex: z.number().nullable().describe('0-based index into the singles list, or null if no singles exist'),
        bestPickReason: z.string().describe('One concrete sentence connecting the stat signal to the match context'),
      }),
      system: digestContext || undefined,
      prompt: `Pick the single best bet from this singles list for ${homeTeamName} vs ${awayTeamName}.

SINGLES (indexed 0-based):
${singlesText}

Rules:
- bestPickIndex: the index of the single best trend (balance hit rate, sample size, odds value)
- bestPickReason: one sentence that names the specific stat signal (e.g. "8/10 games") AND a match context factor (e.g. an injury or form run) that makes this pick compelling in this specific fixture
- If no singles exist, return bestPickIndex: null`,
    });

    const bestPickIndex = pickResult.bestPickIndex;
    if (bestPickIndex != null && singlesTrends[bestPickIndex]) {
      sendEvent(res, 'bestPick', { ...singlesTrends[bestPickIndex], reason: pickResult.bestPickReason });
    }

    // --- PHASE 4: Trend curation (parallel, uses bestPickIndex for deduplication) ---
    const deprioritiseInstruction = digestStr
      ? '\n\nAdditionally: deprioritise any trend for a player whose relevance is undermined by the match news in the digest (e.g. injured players, suspended players, or players whose team context makes the stat less meaningful).'
      : '';

    const curateCategory = async (trendsList: any[], label: string, criteria: string) => {
      if (trendsList.length <= 5) return trendsList;
      const text = summariseTrends(trendsList);
      const { object } = await generateObject({
        model: gateway('xai/grok-4.1-fast-non-reasoning'),
        temperature: 0.3,
        schema: categorySchema,
        system: digestContext || undefined,
        prompt: `Pick the best 3-5 trends from this ${label} list. ${criteria}${deprioritiseInstruction}

TRENDS (indexed):
${text}

Pick indices that offer the best value — consider hit rate vs odds, sample size, and diversity of stat types and teams.`,
      });
      return object.bestIndices.map((i: number) => trendsList[i]).filter(Boolean);
    };

    const [curatedBuilder, curatedSingles, curatedLongshots] = await Promise.all([
      curateCategory(builderTrends, 'Bet Builder Adds (under 1.60 odds)', 'These are low-odds banker legs. Prefer very high hit rates (85%+) and large sample sizes.'),
      curateCategory(
        singlesTrends.filter((_: any, i: number) => i !== bestPickIndex),
        'Singles (1.60-3.00 odds)',
        'These are the core singles range. Balance hit rate with odds value — a 70% hit rate at 2.50 is better than 90% at 1.65.',
      ),
      curateCategory(longshotTrends, 'Longshots (3.00+ odds)', 'These are bigger odds plays. Accept lower hit rates but look for decent sample sizes and standout odds.'),
    ]);

    if (curatedBuilder.length > 0) sendEvent(res, 'trends_builder', curatedBuilder);
    if (curatedSingles.length > 0) sendEvent(res, 'trends_singles', curatedSingles);
    if (curatedLongshots.length > 0) sendEvent(res, 'trends_longshots', curatedLongshots);

    // --- PHASE 3c: Verdict (after curation, before valueBets) ---
    const topBetsContext = digestStr ? `\n\nTop bets from your analysis:\n${digestStr.split('TOP BETS:')[1]?.trim() || ''}` : '';
    const { object: verdictResult } = await generateObject({
      model: gateway('xai/grok-4.1-fast-non-reasoning'),
      temperature: 0.5,
      schema: z.object({ verdict: z.string() }),
      system: digestContext || undefined,
      prompt: `Write a verdict for ${homeTeamName} vs ${awayTeamName}${tournamentName ? ` (${tournamentName})` : ''}.${topBetsContext}

Rules:
- 2-3 sentences
- Name at least one specific bet (player + market) and explain why it stands out in THIS specific match
- Reference the match situation (not just stats) — injuries, form, tactical context
- Write as if advising a trusted friend — opinionated, direct, specific
- Do NOT use: ${BANNED_PHRASES}
- No hedging language like "could be a good bet" or "worth considering"`,
    });

    sendEvent(res, 'verdict', verdictResult.verdict);

    // Value bets — raw, unchanged, sent after verdict
    if (valueBetsRaw.length > 0) {
      sendEvent(res, 'valueBets', valueBetsRaw.map((vb: any) => ({
        playerName: vb.playerName, playerId: vb.playerId,
        teamName: vb.teamName, teamId: vb.teamId,
        position: vb.position || null,
        marketType: vb.marketType, line: vb.line,
        bestOverOdds: vb.bestOverOdds || null,
        scannerFairOdds: vb.scannerFairOdds || null,
        scannerModelName: vb.scannerModelName || null,
        edge: vb.scannerEdge || vb.avgOverEdge || null,
        hitRates: vb.hitRates || null,
        sampleSize: vb.sampleSize || null,
        recentGames: (vb.recentGames || []).slice(0, 10),
        bookmakers: (vb.bookmakers || []).map((b: any) => ({ source: b.source, overOdds: b.overOdds })),
        activityInfo: vb.activityInfo || null,
      })));
    }

    sendEvent(res, 'done', null);
    res.end();

npx tsc --noEmit 2>&1 | head -40

git add src/pages/api/ai-analysis.ts
git commit -m "feat: replace ai-analysis main handler with 4-phase agentic pipeline"

bun run dev

grep -n "console.log" src/pages/api/ai-analysis.ts

git add src/pages/api/ai-analysis.ts
git commit -m "feat: complete ai-analysis agentic pipeline — digest-driven grounded analysis"