// ai/providers/anthropic.ts — Claude integration
import { anthropic } from "@ai-sdk/anthropic";
import { generateText, streamText } from "ai";
 
// Synchronous text generation
export async function generateAnalysis(content: string) {
  const result = await generateText({
    model: anthropic("claude-sonnet-4-20250514"),
    system: `You are an expert analyst. Provide concise,
      structured analysis with clear recommendations.`,
    prompt: `Analyze the following content:\n\n${content}`,
    maxTokens: 2048,
    temperature: 0.3, // Lower temperature for analytical tasks
  });
 
  return result.text;
}
 
// Streaming text generation for real-time UI
export async function streamResponse(
  messages: Array<{ role: "user" | "assistant"; content: string }>
) {
  const result = streamText({
    model: anthropic("claude-sonnet-4-20250514"),
    system: "You are a helpful assistant.",
    messages,
    maxTokens: 4096,
    temperature: 0.7,
    onFinish: ({ usage }) => {
      // Track token usage for cost monitoring
      console.log(`Tokens: ${usage.promptTokens} in, ${usage.completionTokens} out`);
    },
  });
 
  return result.toDataStreamResponse();
}

// ai/prompts/structured-output.ts — Type-safe LLM outputs
import { anthropic } from "@ai-sdk/anthropic";
import { generateObject } from "ai";
import { z } from "zod/v4";
 
const sentimentSchema = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  confidence: z.number().min(0).max(1),
  reasoning: z.string().describe("Brief explanation of the sentiment assessment"),
  keyPhrases: z.array(z.string()).describe("Key phrases that influenced the assessment"),
  topics: z.array(z.string()).describe("Main topics discussed"),
});
 
type SentimentAnalysis = z.infer<typeof sentimentSchema>;
 
export async function analyzeSentiment(text: string): Promise<SentimentAnalysis> {
  const { object } = await generateObject({
    model: anthropic("claude-sonnet-4-20250514"),
    schema: sentimentSchema,
    prompt: `Analyze the sentiment of the following text:\n\n"${text}"`,
  });
 
  return object;
}
 
// Usage:
// const result = await analyzeSentiment("This product is amazing!");
// result.sentiment === "positive"
// result.confidence === 0.95

// ai/rag/retrieve.ts — Vector search with pgvector
import { embed } from "ai";
import { openai } from "@ai-sdk/openai";
import { db } from "@/db";
import { documents } from "@/db/schema/embeddings";
import { cosineDistance, sql, desc, gt, and, eq } from "drizzle-orm";
 
interface RetrievalResult {
  content: string;
  metadata: Record<string, unknown>;
  similarity: number;
}
 
export async function retrieveRelevantDocuments(
  query: string,
  options: {
    topK?: number;
    similarityThreshold?: number;
    filter?: { category?: string };
  } = {}
): Promise<RetrievalResult[]> {
  const { topK = 5, similarityThreshold = 0.7, filter } = options;
 
  // Generate query embedding
  const { embedding } = await embed({
    model: openai.embedding("text-embedding-3-small"),
    value: query,
  });
 
  // Vector similarity search with optional metadata filtering
  const similarity = sql<number>`1 - (${cosineDistance(documents.embedding, embedding)})`;
 
  const conditions = [gt(similarity, similarityThreshold)];
  if (filter?.category) {
    conditions.push(eq(documents.category, filter.category));
  }
 
  const results = await db
    .select({
      content: documents.content,
      metadata: documents.metadata,
      similarity,
    })
    .from(documents)
    .where(and(...conditions))
    .orderBy(desc(similarity))
    .limit(topK);
 
  return results;
}
 
// RAG generation combining retrieval with LLM
export async function ragQuery(query: string) {
  const documents = await retrieveRelevantDocuments(query);
 
  const context = documents
    .map((doc) => `[Source: ${doc.metadata.title}]\n${doc.content}`)
    .join("\n\n---\n\n");
 
  const result = await generateText({
    model: anthropic("claude-sonnet-4-20250514"),
    system: `You are a helpful assistant. Answer questions based on the
      provided context. If the context doesn't contain the answer, say so.
      Always cite your sources.`,
    prompt: `Context:\n${context}\n\nQuestion: ${query}`,
  });
 
  return {
    answer: result.text,
    sources: documents.map((d) => d.metadata),
  };
}

// ai/agents/research.ts — Multi-step research agent
import { anthropic } from "@ai-sdk/anthropic";
import { generateText, tool } from "ai";
import { z } from "zod/v4";
 
const searchTool = tool({
  description: "Search the knowledge base for relevant information",
  parameters: z.object({
    query: z.string().describe("The search query"),
    category: z.string().optional().describe("Filter by category"),
  }),
  execute: async ({ query, category }) => {
    const results = await retrieveRelevantDocuments(query, {
      filter: category ? { category } : undefined,
    });
    return results.map((r) => r.content).join("\n\n");
  },
});
 
const calculatorTool = tool({
  description: "Perform mathematical calculations",
  parameters: z.object({
    expression: z.string().describe("Mathematical expression to evaluate"),
  }),
  execute: async ({ expression }) => {
    // Safe math evaluation (never use eval)
    const result = evaluateMathExpression(expression);
    return `${expression} = ${result}`;
  },
});
 
export async function runResearchAgent(query: string) {
  const result = await generateText({
    model: anthropic("claude-sonnet-4-20250514"),
    system: `You are a research assistant. Use the available tools to
      find information and provide comprehensive answers. Break complex
      questions into sub-queries and search multiple times if needed.`,
    prompt: query,
    tools: { search: searchTool, calculator: calculatorTool },
    maxSteps: 10, // Allow up to 10 tool calls
    onStepFinish: ({ stepType, toolCalls }) => {
      // Log each step for observability
      if (stepType === "tool-result" && toolCalls) {
        console.log(`Agent used tools: ${toolCalls.map((t) => t.toolName).join(", ")}`);
      }
    },
  });
 
  return {
    answer: result.text,
    steps: result.steps.length,
    toolCalls: result.steps.flatMap((s) => s.toolCalls ?? []),
  };
}

// ai/rag/ingest.ts — Document chunking and embedding
import { embedMany } from "ai";
import { openai } from "@ai-sdk/openai";
import { db } from "@/db";
import { documents } from "@/db/schema/embeddings";
 
interface DocumentInput {
  title: string;
  content: string;
  category: string;
  sourceUrl: string;
}
 
// Recursive character text splitting
function chunkText(
  text: string,
  options: { chunkSize?: number; overlap?: number } = {}
): string[] {
  const { chunkSize = 1000, overlap = 200 } = options;
  const chunks: string[] = [];
 
  // Split by paragraphs first, then recombine to target size
  const paragraphs = text.split(/\n\n+/);
  let currentChunk = "";
 
  for (const paragraph of paragraphs) {
    if (currentChunk.length + paragraph.length > chunkSize && currentChunk.length > 0) {
      chunks.push(currentChunk.trim());
      // Keep overlap from the end of the previous chunk
      const words = currentChunk.split(" ");
      const overlapWords = words.slice(-Math.floor(overlap / 5));
      currentChunk = overlapWords.join(" ") + "\n\n" + paragraph;
    } else {
      currentChunk += (currentChunk ? "\n\n" : "") + paragraph;
    }
  }
 
  if (currentChunk.trim()) {
    chunks.push(currentChunk.trim());
  }
 
  return chunks;
}
 
export async function ingestDocument(doc: DocumentInput) {
  const chunks = chunkText(doc.content);
 
  // Generate embeddings in batch (max 2048 per request)
  const { embeddings } = await embedMany({
    model: openai.embedding("text-embedding-3-small"),
    values: chunks,
  });
 
  // Store chunks with embeddings in database
  const records = chunks.map((content, index) => ({
    content,
    embedding: embeddings[index],
    metadata: {
      title: doc.title,
      category: doc.category,
      sourceUrl: doc.sourceUrl,
      chunkIndex: index,
      totalChunks: chunks.length,
    },
    category: doc.category,
  }));
 
  await db.insert(documents).values(records);
 
  return { chunksCreated: chunks.length };
}