deploy to test AI

app/api/organizations/[orgId]/ai-settings/route.ts

···
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/auth';
+import { 
+  getOrganizationAiSettings, 
+  updateOrganizationAiSettings, 
+  AiSettings,
+  UpdateAiSettingsPayload
+} from '@/lib/repositories';
+import { getOrganizationRole } from '@/lib/repositories/user-repository';
+
+// GET current AI settings for an organization
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ orgId: string }> }
+) {
+  const { orgId } = await params;
+  const session = await auth();
+
+  if (!session || !session.user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const numericOrgId = parseInt(orgId);
+  if (isNaN(numericOrgId)) {
+    return NextResponse.json({ error: 'Invalid organization ID' }, { status: 400 });
+  }
+
+  const role = await getOrganizationRole(session.user.id, numericOrgId);
+  if (!role || (role !== 'admin' && role !== 'owner')) { 
+    return NextResponse.json({ error: 'Forbidden: User does not have permission to view settings for this organization' }, { status: 403 });
+  }
+
+  try {
+    const aiSettings: AiSettings = await getOrganizationAiSettings(numericOrgId);
+    return NextResponse.json(aiSettings);
+  } catch (error) {
+    console.error(`Error fetching AI settings for org ${orgId}:`, error);
+    return NextResponse.json({ error: 'Failed to fetch AI settings' }, { status: 500 });
+  }
+}
+
+// PUT (update) AI settings for an organization
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ orgId: string }> }
+) {
+  const { orgId } = await params;
+  const session = await auth();
+
+  if (!session || !session.user) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+
+  const numericOrgId = parseInt(orgId);
+  if (isNaN(numericOrgId)) {
+    return NextResponse.json({ error: 'Invalid organization ID' }, { status: 400 });
+  }
+
+  const role = await getOrganizationRole(session.user.id, numericOrgId);
+  if (!role || (role !== 'admin' && role !== 'owner')) { 
+    return NextResponse.json({ error: 'Forbidden: User does not have permission to update settings for this organization' }, { status: 403 });
+  }
+
+  try {
+    const body = await request.json() as UpdateAiSettingsPayload;
+    
+    // Basic validation for the new payload
+    if (body.selectedModelId !== undefined && (typeof body.selectedModelId !== 'string' && body.selectedModelId !== null)) {
+      return NextResponse.json({ error: 'Invalid selectedModelId value' }, { status: 400 });
+    }
+
+    // Validate API keys: must be string or null if provided
+    if (body.openaiApiKey !== undefined && typeof body.openaiApiKey !== 'string' && body.openaiApiKey !== null) {
+      return NextResponse.json({ error: 'Invalid openaiApiKey value. Must be a string or null.' }, { status: 400 });
+    }
+    if (body.googleApiKey !== undefined && typeof body.googleApiKey !== 'string' && body.googleApiKey !== null) {
+      return NextResponse.json({ error: 'Invalid googleApiKey value. Must be a string or null.' }, { status: 400 });
+    }
+    if (body.anthropicApiKey !== undefined && typeof body.anthropicApiKey !== 'string' && body.anthropicApiKey !== null) {
+      return NextResponse.json({ error: 'Invalid anthropicApiKey value. Must be a string or null.' }, { status: 400 });
+    }
+            
+    await updateOrganizationAiSettings(numericOrgId, body);
+    return NextResponse.json({ message: 'AI settings updated successfully' });
+  } catch (error) {
+    console.error(`Error updating AI settings for org ${orgId}:`, error);
+    if (error instanceof SyntaxError) {
+        return NextResponse.json({ error: 'Invalid JSON payload' }, { status: 400 });
+    }
+    return NextResponse.json({ error: 'Failed to update AI settings' }, { status: 500 });
+  }
+} 

app/api/webhook/github/route.ts

···
   updatePullRequest,
   createPullRequestReview,
   findReviewByGitHubId,
-  updatePullRequestReview
+  updatePullRequestReview,
+  updatePullRequestCategory,
+  getOrganizationCategories,
+  getOrganizationAiSettings,
+  getOrganizationApiKey,
+  findCategoryByNameAndOrg as findCategoryByNameAndOrgFromRepo
 } from '@/lib/repositories';
 import { GitHubClient } from '@/lib/github';
-import { PRReview } from '@/lib/types';
+import { PRReview, Category } from '@/lib/types';
+import { openai } from '@ai-sdk/openai';
+import { generateText, CoreTool } from 'ai';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { allModels } from '@/lib/ai-models'; // Import shared models
+
+export const runtime = 'nodejs';
 
 // GitHub webhook payload types
 interface GitHubWebhookPayload {
···
   // Check if PR already exists in our database
   const existingPR = await findPullRequestByNumber(repoInDb.id, pr.number);
   
-  // For synchronization actions, we need to fetch detailed PR data
-  let needsFurtherData = ['opened', 'reopened', 'edited', 'ready_for_review', 'converted_to_draft'].includes(action);
-  
   if (existingPR) {
     // Update existing PR
     await updatePullRequest(existingPR.id, {
···
     
     console.log(`Updated PR #${pr.number} in ${repository.full_name}`);
     
-    // If significant action, fetch additional data
-    if (needsFurtherData) {
-      await fetchAdditionalPRData(repository, pr, existingPR.id);
+    // Conditionally call fetchAdditionalPRData ONLY if action is 'opened' 
+    // (even for existing PRs, though 'opened' usually implies a new PR).
+    // This handles cases like a PR being created, then a webhook failing, then succeeding on a retry 
+    // where the PR might now exist but the action is still 'opened' from GitHub's perspective.
+    if (action === 'opened') {
+      console.log(`PR #${pr.number} action is 'opened'. Preparing to fetch additional data.`);
+      if (repoInDb.organization_id !== null) {
+        await fetchAdditionalPRData(repository, pr, existingPR.id, repoInDb.organization_id);
+      } else {
+        console.warn(`Organization ID is null for repository ${repoInDb.full_name}. Skipping AI categorization.`);
+      }
     }
   } else {
     // Create new PR
···
     
     console.log(`Created new PR #${pr.number} in ${repository.full_name}`);
     
-    // Fetch additional data for new PRs
-    await fetchAdditionalPRData(repository, pr, newPR.id);
+    // Fetch additional data for new PRs IFF the action was 'opened'
+    if (action === 'opened') {
+      console.log(`New PR #${pr.number} action is 'opened'. Preparing to fetch additional data.`);
+      if (repoInDb.organization_id !== null) {
+        await fetchAdditionalPRData(repository, pr, newPR.id, repoInDb.organization_id);
+      } else {
+        console.warn(`Organization ID is null for new PR in repository ${repoInDb.full_name}. Skipping AI categorization.`);
+      }
+    } else {
+      // This case (new PR but action is not 'opened') should be rare for webhooks 
+      // unless it's a manual trigger or a very delayed/retried event.
+      console.log(`New PR #${pr.number} created, but action was '${action}', not 'opened'. Skipping fetchAdditionalPRData.`);
+    }
   }
 }
 
···
   }
 }
 
-async function fetchAdditionalPRData(repository: PullRequestPayload['repository'], pr: PullRequestPayload['pull_request'], prDbId: number) {
-  // We need a GitHub token to fetch additional data
-  // This is a challenge since the webhook doesn't provide a token
-  // For now, we'll log this and handle it in a background job
-  
-  console.log(`Additional data should be fetched for PR #${pr.number} in ${repository.full_name} (DB ID: ${prDbId})`);
+async function fetchAdditionalPRData(
+  repository: PullRequestPayload['repository'], 
+  pr: PullRequestPayload['pull_request'], 
+  prDbId: number,
+  organizationId: number
+) {
+  console.log(`Fetching additional data for PR #${pr.number} in org ${organizationId}`);
+
+  if (!organizationId) {
+    console.error('Organization ID not provided to fetchAdditionalPRData. Cannot fetch AI settings.');
+    return;
+  }
+
+  // 1. Fetch Organization's AI Settings
+  const aiSettings = await getOrganizationAiSettings(organizationId);
+  if (!aiSettings || !aiSettings.selectedModelId) {
+    console.log(`AI categorization disabled for organization ${organizationId} (no model selected).`);
+    return;
+  }
+
+  const selectedModelId = aiSettings.selectedModelId;
+  console.log(`Organization ${organizationId} selected AI model: ${selectedModelId}`);
+
+  // 2. Determine Provider and API Key
+  const modelInfo = allModels.find(m => m.id === selectedModelId); // Use imported allModels
+  if (!modelInfo) {
+    console.error(`Selected model ID ${selectedModelId} not found in shared allModels for organization ${organizationId}.`);
+    return;
+  }
+  const provider = modelInfo.provider;
+  console.log(`Determined provider: ${provider} for model ${selectedModelId}`);
+
+  const apiKey = await getOrganizationApiKey(organizationId, provider);
+  if (!apiKey) {
+    console.warn(`API key for provider ${provider} not set for organization ${organizationId}. Skipping AI categorization.`);
+    return;
+  }
+  console.log(`API key found for provider ${provider}.`);
+
+  // 3. Instantiate AI Client
+  let aiClientProvider;
+  try {
+    switch (provider) {
+      case 'openai':
+        aiClientProvider = createOpenAI({ apiKey: apiKey });
+        break;
+      case 'google':
+        aiClientProvider = createGoogleGenerativeAI({ apiKey: apiKey });
+        break;
+      case 'anthropic':
+        aiClientProvider = createAnthropic({ apiKey: apiKey });
+        break;
+      default:
+        console.error(`Unsupported AI provider: ${provider} for organization ${organizationId}`);
+        return;
+    }
+  } catch (error) {
+    console.error(`Error instantiating AI client provider for ${provider}:`, error);
+    return;
+  }
+  console.log(`AI client provider instantiated for: ${provider}`);
   
-  // In the future, we can implement a background job that uses a service account token to fetch:
-  // 1. PR files
-  // 2. PR commits
-  // 3. PR reviews
-  // 4. Any other detailed data needed for AI processing
+  // Get the specific model instance from the provider
+  const modelInstance = aiClientProvider(selectedModelId);
+  if (!modelInstance) {
+    console.error(`Could not get model instance for ${selectedModelId} from provider ${provider}`);
+    return;
+  }
+
+  // Placeholder for GitHub App authentication to fetch PR diff
+  // This part needs robust auth, e.g., creating an installation token
+  const githubToken = process.env.GITHUB_APP_INSTALLATION_TOKEN || process.env.GITHUB_SYSTEM_TOKEN;
+  if (!githubToken) {
+    console.warn('GitHub token not available, cannot fetch PR diff.');
+    // Potentially proceed without diff, or return if diff is critical
+    return; 
+  }
+  const githubClient = new GitHubClient(githubToken);
+
+  try {
+    console.log(`Fetching PR diff for ${repository.full_name}#${pr.number}`);
+    const diff = await githubClient.getPullRequestDiff(repository.owner.login, repository.name, pr.number);
+    
+    if (!diff) {
+        console.warn(`Could not fetch PR diff for ${repository.full_name}#${pr.number}. Skipping categorization.`);
+        return;
+    }
+
+    const orgCategories = await getOrganizationCategories(organizationId);
+    const categoryNames = orgCategories.map(c => c.name);
+
+    if (categoryNames.length === 0) {
+        console.warn(`No categories found for organization ${organizationId}. Skipping categorization.`);
+        return;
+    }
+
+    const systemPrompt = `You are an expert at categorizing GitHub pull requests. Analyze the pull request title, body, and diff. Respond with the most relevant category from the provided list and a confidence score (0-1). Available categories: ${categoryNames.join(', ')}. Respond in the format: Category: [Selected Category], Confidence: [Score]. Example: Category: Bug Fix, Confidence: 0.9`;
+    const userPrompt = `Title: ${pr.title}\nBody: ${pr.body || ''}\nDiff:\n${diff}`;
+
+    console.log(`Generating text with model ${selectedModelId} for PR #${pr.number}`);
+
+    const { text } = await generateText({
+      model: modelInstance,
+      system: systemPrompt,
+      prompt: userPrompt,
+    });
+
+    console.log(`AI Response for PR #${pr.number}: ${text}`);
+
+    const categoryMatch = text.match(/Category: (.*?), Confidence: (\d\.?\d*)/i);
+    if (categoryMatch && categoryMatch[1] && categoryMatch[2]) {
+      const categoryName = categoryMatch[1].trim();
+      const confidence = parseFloat(categoryMatch[2]);
+
+      const category = await findCategoryByNameAndOrgFromRepo(organizationId, categoryName);
+      if (category) {
+        await updatePullRequestCategory(prDbId, category.id, confidence);
+        console.log(`Categorized PR #${pr.number} as '${categoryName}' with confidence ${confidence}`);
+      } else {
+        console.warn(`AI suggested category '${categoryName}' not found for organization ${organizationId}.`);
+      }
+    } else {
+      console.warn(`Could not parse category and confidence from AI response for PR #${pr.number}: ${text}`);
+    }
+
+  } catch (error) {
+    console.error(`Error during AI categorization for PR #${pr.number}:`, error);
+    // Decide if this error should halt further processing or just be logged
+  }
 }
 
 // Helper to map GitHub review state to our enum

app/dashboard/settings/page.tsx

···
 import { IconRefresh } from "@tabler/icons-react"
 import { ReloadOrganizationsButton } from "@/components/ui/reload-organizations-button"
 import { OrganizationSettingsTab } from "@/components/ui/organization-settings-tab"
+import { AiSettingsTab } from "@/components/ui/ai-settings-tab"
 
 export default function SettingsPage() {
   // GitHub App installation URL (replace with your app's actual URL if needed)
···
                     <OrganizationSettingsTab />
                   </TabsContent>
                   <TabsContent value="ai">
-                    <Card>
-                      <CardHeader>
-                        <CardTitle>AI Settings (Coming Soon)</CardTitle>
-                        <CardDescription>
-                          Configure AI-powered PR categorization and analytics features.
-                        </CardDescription>
-                      </CardHeader>
-                      <CardContent>
-                        <p className="text-muted-foreground text-sm">
-                          More AI and automation options will be available here in the future.
-                        </p>
-                      </CardContent>
-                    </Card>
+                    <AiSettingsTab />
                   </TabsContent>
                 </Tabs>
               </div>

components/ui/ai-settings-tab.tsx

···
+'use client';
+
+import React, { useEffect, useState, useCallback } from 'react';
+import { useSession } from 'next-auth/react';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card';
+import { Label } from '@/components/ui/label';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Input } from '@/components/ui/input';
+import { toast } from 'sonner';
+import { AiSettings as FetchedAiSettings, UpdateAiSettingsPayload } from '@/lib/repositories';
+import { Organization } from '@/lib/types';
+import { Avatar, AvatarImage, AvatarFallback } from './avatar';
+import { allModels, ModelDefinition } from '@/lib/ai-models'; // Import shared models and definition
+
+export function AiSettingsTab() {
+  const { data: session, status: sessionStatus } = useSession();
+  const [organizations, setOrganizations] = useState<Organization[]>([]);
+  const [selectedOrganization, setSelectedOrganization] = useState<Organization | null>(null);
+
+  const [fetchedSettings, setFetchedSettings] = useState<FetchedAiSettings | null>(null);
+  
+  const [selectedModelId, setSelectedModelId] = useState<string | null>(null);
+  const [openaiApiKeyInput, setOpenaiApiKeyInput] = useState('');
+  const [googleApiKeyInput, setGoogleApiKeyInput] = useState('');
+  const [anthropicApiKeyInput, setAnthropicApiKeyInput] = useState('');
+
+  const [isLoadingSettings, setIsLoadingSettings] = useState(false);
+  const [isSaving, setIsSaving] = useState(false);
+
+  useEffect(() => {
+    if (session?.organizations && Array.isArray(session.organizations)) {
+      setOrganizations(session.organizations as Organization[]);
+    }
+  }, [session]);
+
+  useEffect(() => {
+    async function fetchSettings() {
+      if (!selectedOrganization) return;
+      setIsLoadingSettings(true);
+      setFetchedSettings(null);
+      setSelectedModelId(null);
+      setOpenaiApiKeyInput('');
+      setGoogleApiKeyInput('');
+      setAnthropicApiKeyInput('');
+      try {
+        const response = await fetch(`/api/organizations/${selectedOrganization.id}/ai-settings`);
+        if (!response.ok) {
+          throw new Error('Failed to fetch AI settings');
+        }
+        const data: FetchedAiSettings = await response.json();
+        setFetchedSettings(data);
+        setSelectedModelId(data.selectedModelId);
+      } catch (error) {
+        toast.error(error instanceof Error ? error.message : 'Could not load AI settings.');
+      } finally {
+        setIsLoadingSettings(false);
+      }
+    }
+    if (selectedOrganization?.id) {
+      fetchSettings();
+    } else {
+      setFetchedSettings(null);
+      setSelectedModelId(null);
+      setOpenaiApiKeyInput('');
+      setGoogleApiKeyInput('');
+      setAnthropicApiKeyInput('');
+      setIsLoadingSettings(false);
+    }
+  }, [selectedOrganization]);
+
+  const currentSelectedModelDetails = selectedModelId ? allModels.find(m => m.id === selectedModelId) : null;
+
+  const handleSave = async () => {
+    if (!selectedOrganization) return;
+    setIsSaving(true);
+
+    const payload: UpdateAiSettingsPayload = {
+      selectedModelId: selectedModelId,
+    };
+
+    const modelDetails = selectedModelId ? allModels.find(m => m.id === selectedModelId) : null;
+
+    if (modelDetails) {
+      let currentInput = '';
+      let apiKeyCurrentlySet = false;
+      let apiKeyPayloadKey: keyof UpdateAiSettingsPayload | null = null;
+
+      switch (modelDetails.provider) {
+        case 'openai':
+          currentInput = openaiApiKeyInput;
+          apiKeyCurrentlySet = !!fetchedSettings?.isOpenAiKeySet;
+          apiKeyPayloadKey = 'openaiApiKey';
+          break;
+        case 'google':
+          currentInput = googleApiKeyInput;
+          apiKeyCurrentlySet = !!fetchedSettings?.isGoogleKeySet;
+          apiKeyPayloadKey = 'googleApiKey';
+          break;
+        case 'anthropic':
+          currentInput = anthropicApiKeyInput;
+          apiKeyCurrentlySet = !!fetchedSettings?.isAnthropicKeySet;
+          apiKeyPayloadKey = 'anthropicApiKey';
+          break;
+      }
+
+      if (apiKeyPayloadKey) {
+        let keyForPayload: string | null | undefined = undefined;
+
+        if (currentInput) { // User typed something
+          keyForPayload = currentInput;
+        } else { // Input is blank
+          if (apiKeyCurrentlySet) { // Key was set, and input is now blank
+            keyForPayload = null; // Send null to clear
+          }
+          // If input is blank AND key was NOT set, keyForPayload remains undefined
+        }
+
+        // Only add to payload if keyForPayload is a string or null (but not undefined)
+        if (keyForPayload !== undefined) {
+          payload[apiKeyPayloadKey] = keyForPayload;
+        }
+      }
+    }
+
+    try {
+      const response = await fetch(`/api/organizations/${selectedOrganization.id}/ai-settings`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error || 'Failed to save AI settings');
+      }
+      toast.success('AI settings saved successfully!');
+      const fetchResponse = await fetch(`/api/organizations/${selectedOrganization.id}/ai-settings`);
+      const data: FetchedAiSettings = await fetchResponse.json();
+      setFetchedSettings(data);
+      setSelectedModelId(data.selectedModelId);
+      setOpenaiApiKeyInput(''); 
+      setGoogleApiKeyInput('');
+      setAnthropicApiKeyInput('');
+
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : 'Could not save AI settings.');
+    } finally {
+      setIsSaving(false);
+    }
+  };
+  
+  const getApiKeyInputProps = (provider: 'openai' | 'google' | 'anthropic') => {
+    let value = '';
+    let onChange: (e: React.ChangeEvent<HTMLInputElement>) => void = () => {};
+    let isSet = false;
+    let placeholder = 'Enter API Key';
+
+    if (provider === 'openai') {
+      value = openaiApiKeyInput;
+      onChange = (e) => setOpenaiApiKeyInput(e.target.value);
+      isSet = !!fetchedSettings?.isOpenAiKeySet;
+    } else if (provider === 'google') {
+      value = googleApiKeyInput;
+      onChange = (e) => setGoogleApiKeyInput(e.target.value);
+      isSet = !!fetchedSettings?.isGoogleKeySet;
+    } else if (provider === 'anthropic') {
+      value = anthropicApiKeyInput;
+      onChange = (e) => setAnthropicApiKeyInput(e.target.value);
+      isSet = !!fetchedSettings?.isAnthropicKeySet;
+    }
+    if (isSet && !value) placeholder = 'API Key is set. Enter new key to update or clear.';
+    else if (isSet && value) placeholder = 'Update API Key';
+
+    return { value, onChange, placeholder, isSet };
+  };
+
+  if (sessionStatus === 'loading') {
+    return <p>Loading session data...</p>;
+  }
+
+  if (!session || organizations.length === 0) {
+    return (
+      <Card>
+        <CardHeader>
+          <CardTitle>AI Categorization Settings</CardTitle>
+          <CardDescription>
+            No organizations found. Please sync your organizations from the GitHub tab first.
+          </CardDescription>
+        </CardHeader>
+      </Card>
+    );
+  }
+
+  return (
+    <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
+      <div className="md:col-span-1">
+        <Card>
+          <CardHeader>
+            <CardTitle>Your Organizations</CardTitle>
+            <CardDescription>Select an organization to configure its AI settings.</CardDescription>
+          </CardHeader>
+          <CardContent>
+            {organizations.length === 0 && <p>No organizations linked.</p>}
+            <ul className="space-y-2">
+              {organizations.map((org) => (
+                <li key={org.id || org.github_id}>
+                  <Button
+                    variant={selectedOrganization?.id === org.id ? 'secondary' : 'ghost'}
+                    className="w-full justify-start text-left h-auto py-2"
+                    onClick={() => setSelectedOrganization(org)}
+                  >
+                    <div className="flex items-center gap-3">
+                      <Avatar className="size-8">
+                        <AvatarImage src={org.avatar_url || undefined} alt={org.name} />
+                        <AvatarFallback>{org.name[0]}</AvatarFallback>
+                      </Avatar>
+                      <span>{org.name}</span>
+                    </div>
+                  </Button>
+                </li>
+              ))}
+            </ul>
+          </CardContent>
+        </Card>
+      </div>
+
+      <div className="md:col-span-2">
+        {!selectedOrganization ? (
+          <Card>
+            <CardHeader>
+              <CardTitle>AI Categorization Settings</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <p className="text-muted-foreground">
+                Please select an organization from the list to configure its AI settings.
+              </p>
+            </CardContent>
+          </Card>
+        ) : isLoadingSettings ? (
+            <p>Loading AI settings for {selectedOrganization.name}...</p>
+        ) : (
+          <Card>
+            <CardHeader>
+              <CardTitle>AI Settings for {selectedOrganization.name}</CardTitle>
+              <CardDescription>
+                Select an AI model and provide the necessary API key for automatic pull request categorization. API keys are stored securely per organization.
+              </CardDescription>
+            </CardHeader>
+            <CardContent className="space-y-6">
+              <div className="space-y-2">
+                <Label htmlFor="ai-model-select">AI Model</Label>
+                <Select
+                  value={selectedModelId === null ? '__none__' : selectedModelId}
+                  onValueChange={(value) => {
+                    const newModelId = value === '__none__' ? null : value;
+                    setSelectedModelId(newModelId);
+                    setOpenaiApiKeyInput('');
+                    setGoogleApiKeyInput('');
+                    setAnthropicApiKeyInput('');
+                  }}
+                >
+                  <SelectTrigger id="ai-model-select">
+                    <SelectValue placeholder="Select a model (or None)" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="__none__">None (Disable AI Categorization)</SelectItem>
+                    {allModels.map(model => (
+                      <SelectItem key={model.id} value={model.id}>
+                        {model.providerName}: {model.name}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+
+              {currentSelectedModelDetails && (
+                <div className="space-y-2">
+                  <Label htmlFor={`api-key-${currentSelectedModelDetails.provider}`}>
+                    {currentSelectedModelDetails.providerName} API Key
+                  </Label>
+                  <Input
+                    id={`api-key-${currentSelectedModelDetails.provider}`}
+                    type="password"
+                    value={getApiKeyInputProps(currentSelectedModelDetails.provider).value}
+                    onChange={getApiKeyInputProps(currentSelectedModelDetails.provider).onChange}
+                    placeholder={getApiKeyInputProps(currentSelectedModelDetails.provider).placeholder}
+                  />
+                  {getApiKeyInputProps(currentSelectedModelDetails.provider).isSet && 
+                   !getApiKeyInputProps(currentSelectedModelDetails.provider).value && (
+                    <p className="text-xs text-muted-foreground">
+                      An API key is currently set for {currentSelectedModelDetails.providerName}.
+                      To update it, enter the new key. 
+                      To clear this key, leave this field blank and click "Save AI Settings".
+                    </p>
+                  )}
+                   {!getApiKeyInputProps(currentSelectedModelDetails.provider).isSet && 
+                    currentSelectedModelDetails.provider && ( // Ensure provider exists to show specific message
+                     <p className="text-xs text-muted-foreground">
+                      Enter your {currentSelectedModelDetails.providerName} API key.
+                    </p>
+                   )
+                   }
+                </div>
+              )}
+              
+              {selectedModelId && !currentSelectedModelDetails && (
+                <p className="text-destructive text-xs">Error: Selected model details not found. Please re-select.</p>
+              )}
+
+            </CardContent>
+            <CardFooter>
+              <Button onClick={handleSave} disabled={isSaving || isLoadingSettings || !selectedOrganization}>
+                {isSaving ? 'Saving...' : 'Save AI Settings'}
+              </Button>
+            </CardFooter>
+          </Card>
+        )}
+      </div>
+    </div>
+  );
+} 

components/ui/organization-settings-tab.tsx

···
                   >
                     <div className="flex items-center gap-3">
                       <Avatar className="size-8">
-                        <AvatarImage src={org.avatar_url ?? undefined} alt={org.name} />
+                        <AvatarImage src={org.avatar_url || undefined} alt={org.name} />
                         <AvatarFallback>{org.name[0]}</AvatarFallback>
                       </Avatar>
                       <span>{org.name}</span>

lib/ai-models.ts

···
+import type { UpdateAiSettingsPayload, AiSettings as FetchedAiSettings } from "./repositories";
+
+// Shared interface for AI Model Definitions
+export interface ModelDefinition {
+  id: string; // e.g., "gpt-4o", "gemini-2.0-flash"
+  name: string; // User-friendly name, e.g., "GPT-4o (Latest)"
+  provider: "openai" | "google" | "anthropic"; // Provider key
+  providerName: string; // User-friendly provider name, e.g., "OpenAI"
+  apiKeyPayloadKey: keyof UpdateAiSettingsPayload; // Key used in UpdateAiSettingsPayload for this provider's API key
+  isKeySetSelector: (settings: FetchedAiSettings | null) => boolean; // Function to check if the API key is set for this provider
+}
+
+// Centralized list of all available AI models
+export const allModels: ModelDefinition[] = [
+  // OpenAI Models
+  {
+    id: "gpt-4o",
+    name: "GPT-4o (Latest)",
+    provider: "openai",
+    providerName: "OpenAI",
+    apiKeyPayloadKey: "openaiApiKey",
+    isKeySetSelector: (s) => !!s?.isOpenAiKeySet
+  },
+  {
+    id: "gpt-4-turbo",
+    name: "GPT-4 Turbo",
+    provider: "openai",
+    providerName: "OpenAI",
+    apiKeyPayloadKey: "openaiApiKey",
+    isKeySetSelector: (s) => !!s?.isOpenAiKeySet
+  },
+  {
+    id: "gpt-3.5-turbo",
+    name: "GPT-3.5 Turbo (Fast, Cost-Effective)",
+    provider: "openai",
+    providerName: "OpenAI",
+    apiKeyPayloadKey: "openaiApiKey",
+    isKeySetSelector: (s) => !!s?.isOpenAiKeySet
+  },
+  
+  // Google Gemini Models
+  {
+    id: "gemini-2.5-pro-preview-05-06",
+    name: "Gemini 2.5 Pro (Preview, Max Capability)",
+    provider: "google",
+    providerName: "Google",
+    apiKeyPayloadKey: "googleApiKey",
+    isKeySetSelector: (s) => !!s?.isGoogleKeySet
+  },
+  {
+    id: "gemini-2.0-flash",
+    name: "Gemini 2.0 Flash (Recommended Default)",
+    provider: "google",
+    providerName: "Google",
+    apiKeyPayloadKey: "googleApiKey",
+    isKeySetSelector: (s) => !!s?.isGoogleKeySet
+  },
+
+  // Anthropic Claude Models
+  {
+    id: "claude-3.7-sonnet-20250219", // Note: Fictional future date, replace with actual if available
+    name: "Claude 3.7 Sonnet (Most Intelligent - Preview)",
+    provider: "anthropic",
+    providerName: "Anthropic",
+    apiKeyPayloadKey: "anthropicApiKey",
+    isKeySetSelector: (s) => !!s?.isAnthropicKeySet
+  },
+  {
+    id: "claude-3.5-sonnet-20240620",
+    name: "Claude 3.5 Sonnet (Strong Balance)",
+    provider: "anthropic",
+    providerName: "Anthropic",
+    apiKeyPayloadKey: "anthropicApiKey",
+    isKeySetSelector: (s) => !!s?.isAnthropicKeySet
+  },
+  {
+    id: "claude-3-opus-20240229",
+    name: "Claude 3 Opus (High Capability)",
+    provider: "anthropic",
+    providerName: "Anthropic",
+    apiKeyPayloadKey: "anthropicApiKey",
+    isKeySetSelector: (s) => !!s?.isAnthropicKeySet
+  },
+  {
+    id: "claude-3-haiku-20240307",
+    name: "Claude 3 Haiku (Fastest)",
+    provider: "anthropic",
+    providerName: "Anthropic",
+    apiKeyPayloadKey: "anthropicApiKey",
+    isKeySetSelector: (s) => !!s?.isAnthropicKeySet
+  },
+]; 

lib/github.ts

···
     return data as unknown as PullRequestReview[];
   }
   
+  async getPullRequestDiff(owner: string, repo: string, pullNumber: number): Promise<string> {
+    const { data } = await this.octokit.pulls.get({
+      owner,
+      repo,
+      pull_number: pullNumber,
+      mediaType: {
+        format: 'diff'
+      }
+    });
+    // The response for a diff is a string
+    return data as unknown as string;
+  }
+  
   async getRepositoryWebhooks(owner: string, repo: string): Promise<RepositoryWebhook[]> {
     const { data } = await this.octokit.repos.listWebhooks({
       owner,

lib/repositories/category-repository.ts

···
   return query<Category>('SELECT * FROM categories WHERE is_default = 1 ORDER BY name');
 }
 
-export async function getOrganizationCategories(orgId: number): Promise<Category[]> {
-  return query<Category>(
-    `SELECT * FROM categories 
-     WHERE organization_id = ? OR is_default = 1 
-     ORDER BY name`,
-    [orgId]
-  );
+export async function getOrganizationCategories(organizationId: number): Promise<Category[]> {
+  return query<Category>('SELECT * FROM categories WHERE organization_id = ? OR organization_id IS NULL ORDER BY is_default DESC, name ASC', [organizationId]);
 }
 
-export async function createCategory(category: Omit<Category, 'id' | 'created_at' | 'updated_at'>): Promise<Category> {
+export async function createCategory(category: Omit<Category, 'id' | 'created_at' | 'updated_at' | 'is_default'>): Promise<Category> {
   const result = await execute(
     `INSERT INTO categories 
      (organization_id, name, description, color, is_default) 
···
       category.name,
       category.description,
       category.color,
-      category.is_default ? 1 : 0
+      0 // is_default is omitted from the type, so we default to 0
     ]
   );
   
···
      ORDER BY count DESC, c.name ASC`,
     [orgId]
   );
+}
+
+export async function findCategoryByNameAndOrg(organizationId: number, name: string): Promise<Category | null> {
+  // First, try to find an organization-specific category
+  const orgCategories = await query<Category>(
+    'SELECT * FROM categories WHERE organization_id = ? AND name = ? COLLATE NOCASE',
+    [organizationId, name]
+  );
+  if (orgCategories.length > 0) {
+    return orgCategories[0];
+  }
+  // If not found, try to find a default category (organization_id IS NULL)
+  const defaultCategories = await query<Category>(
+    'SELECT * FROM categories WHERE organization_id IS NULL AND name = ? COLLATE NOCASE',
+    [name]
+  );
+  return defaultCategories.length > 0 ? defaultCategories[0] : null;
+}
+
+export async function getCategoriesByOrganization(organizationId: number): Promise<Category[]> {
+  return query<Category>('SELECT * FROM categories WHERE organization_id = ? OR organization_id IS NULL ORDER BY is_default DESC, name ASC', [organizationId]);
 } 

lib/repositories/index.ts

···
   createPullRequestReview,
   findReviewByGitHubId,
   updatePullRequestReview,
+  updatePullRequestCategory,
 } from './pr-repository';
 export { 
   getDefaultCategories, 
···
   createCategory, 
   updateCategory, 
   deleteCategory, 
-  findCategoryById
+  findCategoryById,
+  findCategoryByNameAndOrg,
 } from './category-repository';
+
+// Export settings repository functions
+export {
+  getOrganizationAiSettings,
+  updateOrganizationAiSettings,
+  getOrganizationApiKey,
+  type AiSettings,
+  type UpdateAiSettingsPayload,
+} from './settings-repository';
+
 // Commented out sections for missing files remain for user to address
 // export { 
 //   getSettings, 

lib/repositories/settings-repository.ts

···
+import { query, execute } from '@/lib/db';
+import { Setting } from '@/lib/types';
+
+// Old keys (will be replaced or unused for AI settings)
+// const AI_PROVIDER_KEY = 'ai_provider';
+// const AI_MODEL_ID_KEY = 'ai_model_id';
+
+// New keys for AI settings
+const AI_SELECTED_MODEL_ID_KEY = 'ai_selected_model_id';
+const AI_OPENAI_API_KEY_KEY = 'ai_openai_api_key';
+const AI_GOOGLE_API_KEY_KEY = 'ai_google_api_key'; // Or GEMINI_API_KEY if that naming is preferred
+const AI_ANTHROPIC_API_KEY_KEY = 'ai_anthropic_api_key';
+
+// Interface for data returned to the client (keys are not sent)
+export interface AiSettings { // Renamed from GetAiSettingsResponse for brevity in frontend
+  selectedModelId: string | null;
+  isOpenAiKeySet: boolean;
+  isGoogleKeySet: boolean;
+  isAnthropicKeySet: boolean;
+}
+
+// Interface for payload when updating settings (actual keys are sent)
+export interface UpdateAiSettingsPayload {
+  selectedModelId?: string | null;    // To change the model or disable AI (null)
+  openaiApiKey?: string | null;    // To set or clear/remove a key. Null to clear.
+  googleApiKey?: string | null;
+  anthropicApiKey?: string | null;
+}
+
+async function getOrganizationSetting(organizationId: number, key: string): Promise<string | null> {
+  const settings = await query<Setting>(
+    'SELECT value FROM settings WHERE organization_id = ? AND key = ?',
+    [organizationId, key]
+  );
+  return settings.length > 0 ? settings[0].value : null;
+}
+
+async function updateOrganizationSetting(organizationId: number, key: string, value: string | null): Promise<void> {
+  // If value is null, we might want to DELETE the setting row or store NULL 
+  // depending on desired behavior for "cleared" keys.
+  // Storing NULL allows distinguishing between "never set" and "explicitly cleared".
+  // For simplicity, current behavior is upsert, so null will store NULL.
+  await execute(
+    `INSERT INTO settings (organization_id, key, value, created_at, updated_at) 
+     VALUES (?, ?, ?, datetime('now'), datetime('now'))
+     ON CONFLICT(organization_id, key) DO UPDATE SET 
+       value = excluded.value,
+       updated_at = datetime('now')`,
+    [organizationId, key, value]
+  );
+}
+
+export async function getOrganizationAiSettings(organizationId: number): Promise<AiSettings> {
+  const selectedModelId = await getOrganizationSetting(organizationId, AI_SELECTED_MODEL_ID_KEY);
+  const openAiKey = await getOrganizationSetting(organizationId, AI_OPENAI_API_KEY_KEY);
+  const googleKey = await getOrganizationSetting(organizationId, AI_GOOGLE_API_KEY_KEY);
+  const anthropicKey = await getOrganizationSetting(organizationId, AI_ANTHROPIC_API_KEY_KEY);
+
+  return {
+    selectedModelId,
+    isOpenAiKeySet: !!openAiKey, // True if key exists and is not empty string (could refine if empty string is valid)
+    isGoogleKeySet: !!googleKey,
+    isAnthropicKeySet: !!anthropicKey,
+  };
+}
+
+export async function updateOrganizationAiSettings(
+  organizationId: number, 
+  payload: UpdateAiSettingsPayload
+): Promise<void> {
+  if (payload.selectedModelId !== undefined) {
+    await updateOrganizationSetting(organizationId, AI_SELECTED_MODEL_ID_KEY, payload.selectedModelId);
+  }
+  if (payload.openaiApiKey !== undefined) {
+    await updateOrganizationSetting(organizationId, AI_OPENAI_API_KEY_KEY, payload.openaiApiKey);
+  }
+  if (payload.googleApiKey !== undefined) {
+    await updateOrganizationSetting(organizationId, AI_GOOGLE_API_KEY_KEY, payload.googleApiKey);
+  }
+  if (payload.anthropicApiKey !== undefined) {
+    await updateOrganizationSetting(organizationId, AI_ANTHROPIC_API_KEY_KEY, payload.anthropicApiKey);
+  }
+}
+
+// New function to get a specific API key for an organization and provider
+export async function getOrganizationApiKey(organizationId: number, provider: 'openai' | 'google' | 'anthropic'): Promise<string | null> {
+  let apiKeyDBKey = '';
+  switch (provider) {
+    case 'openai':
+      apiKeyDBKey = AI_OPENAI_API_KEY_KEY;
+      break;
+    case 'google':
+      apiKeyDBKey = AI_GOOGLE_API_KEY_KEY;
+      break;
+    case 'anthropic':
+      apiKeyDBKey = AI_ANTHROPIC_API_KEY_KEY;
+      break;
+    default:
+      // Should not happen with TypeScript, but good for safety
+      console.error(`Invalid provider specified for getOrganizationApiKey: ${provider}`);
+      return null;
+  }
+  return getOrganizationSetting(organizationId, apiKeyDBKey);
+} 

lib/services/github-service.ts

···
         
         console.log(`Linking user ${userId} to organization ${dbOrg.id} (${org.login})`);
         
-        // Link the user to the organization as a member
-        await addUserToOrganization(userId, dbOrg.id, 'member');
+        // Link the user to the organization as an owner
+        await addUserToOrganization(userId, dbOrg.id, 'owner');
         
         // Fetch and sync repositories for this organization 
         await this.syncOrganizationRepositories(org.login);
···
   }
   
   async removeRepositoryTracking(repositoryId: number, appUrl: string): Promise<{ success: boolean; message: string }> {
+    console.log(`[removeRepositoryTracking] Called with repositoryId: ${repositoryId}, appUrl: ${appUrl}`);
     // Find repository in database
     const repository = await findRepositoryByGitHubId(repositoryId);
     
     if (!repository) {
+      console.error(`[removeRepositoryTracking] Repository not found for GitHub ID: ${repositoryId}`);
       throw new Error('Repository not found');
     }
     
-    // Extract owner and repo from full_name (format: owner/repo)
     const [owner, repo] = repository.full_name.split('/');
+    console.log(`[removeRepositoryTracking] Extracted owner: ${owner}, repo: ${repo}`);
     
     if (!owner || !repo) {
+      console.error(`[removeRepositoryTracking] Invalid repository full_name format: ${repository.full_name}`);
       throw new Error('Invalid repository full_name format');
     }
     
     const webhookUrl = `${appUrl}/api/webhook/github`;
+    console.log(`[removeRepositoryTracking] Constructed webhookUrl to match: ${webhookUrl}`);
     
     // Find and delete existing webhooks
     const existingWebhooks = await this.client.getRepositoryWebhooks(owner, repo);
+    console.log(`[removeRepositoryTracking] Found ${existingWebhooks.length} existing webhooks on GitHub for ${owner}/${repo}:`, JSON.stringify(existingWebhooks, null, 2));
+    
     const targetWebhooks = existingWebhooks.filter(webhook => 
-      webhook.config.url === webhookUrl || webhook.config.url === `${webhookUrl}/`
+      webhook.config.url === webhookUrl || webhook.config.url === `${webhookUrl}/` // Handle trailing slash
     );
+    console.log(`[removeRepositoryTracking] Found ${targetWebhooks.length} target webhooks matching URL ${webhookUrl}:`, JSON.stringify(targetWebhooks, null, 2));
     
+    let deletedCount = 0;
+    if (targetWebhooks.length === 0) {
+      console.warn(`[removeRepositoryTracking] No webhooks found on GitHub matching the URL ${webhookUrl} for repository ${owner}/${repo}. Marking as untracked in DB anyway.`);
+    }
+
     for (const webhook of targetWebhooks) {
-      await this.client.deleteRepositoryWebhook(owner, repo, webhook.id);
+      try {
+        console.log(`[removeRepositoryTracking] Attempting to delete webhook with ID: ${webhook.id} for ${owner}/${repo}`);
+        await this.client.deleteRepositoryWebhook(owner, repo, webhook.id);
+        console.log(`[removeRepositoryTracking] Successfully deleted webhook ID: ${webhook.id} from GitHub for ${owner}/${repo}`);
+        deletedCount++;
+      } catch (error) {
+        console.error(`[removeRepositoryTracking] Failed to delete webhook ID: ${webhook.id} for ${owner}/${repo} from GitHub. Error:`, error);
+        // Decide if you want to throw here or just log and continue to mark as untracked in DB
+        // For now, we'll log and continue, so it still gets marked as untracked in the DB.
+      }
     }
     
     // Mark repository as not tracked
     await setRepositoryTracking(repository.id, false);
+    console.log(`[removeRepositoryTracking] Marked repository ${repository.id} (GitHub ID: ${repository.github_id}) as not tracked in DB.`);
     
     return { 
       success: true, 
-      message: `Removed ${targetWebhooks.length} webhooks and repository is no longer being tracked`
+      message: `Attempted to remove ${targetWebhooks.length} webhooks (successfully deleted ${deletedCount}) and repository is no longer being tracked`
     };
   }
 } 

package.json

···
     "generate-mock-data": "node scripts/generate-mock-data.js"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^1.2.11",
+    "@ai-sdk/google": "^1.2.17",
+    "@ai-sdk/openai": "^1.3.22",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
     "@dnd-kit/sortable": "^10.0.0",
···
     "@radix-ui/react-tooltip": "^1.2.4",
     "@tabler/icons-react": "^3.31.0",
     "@tanstack/react-table": "^8.21.3",
+    "ai": "^4.3.15",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",

pnpm-lock.yaml

···
 
   .:
     dependencies:
+      '@ai-sdk/anthropic':
+        specifier: ^1.2.11
+        version: 1.2.11(zod@3.24.3)
+      '@ai-sdk/google':
+        specifier: ^1.2.17
+        version: 1.2.17(zod@3.24.3)
+      '@ai-sdk/openai':
+        specifier: ^1.3.22
+        version: 1.3.22(zod@3.24.3)
       '@dnd-kit/core':
         specifier: ^6.3.1
         version: 6.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
···
       '@tanstack/react-table':
         specifier: ^8.21.3
         version: 8.21.3(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+      ai:
+        specifier: ^4.3.15
+        version: 4.3.15(react@19.1.0)(zod@3.24.3)
       class-variance-authority:
         specifier: ^0.7.1
         version: 0.7.1
···
         version: 0.503.0(react@19.1.0)
       next:
         specifier: 15.3.1
-        version: 15.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+        version: 15.3.1(@opentelemetry/api@1.9.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       next-auth:
         specifier: ^5.0.0-beta.27
-        version: 5.0.0-beta.27(next@15.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0)
+        version: 5.0.0-beta.27(next@15.3.1(@opentelemetry/api@1.9.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0)
       next-themes:
         specifier: ^0.4.6
         version: 0.4.6(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
···
 
 packages:
 
+  '@ai-sdk/anthropic@1.2.11':
+    resolution: {integrity: sha512-lZLcEMh8MXY4NVSrN/7DyI2rnid8k7cn/30nMmd3bwJrnIsOuIuuFvY8f0nj+pFcTi6AYK7ujLdqW5dQVz1YQw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
+  '@ai-sdk/google@1.2.17':
+    resolution: {integrity: sha512-mLFLDMCJaDK+j1nvoqeNszazSZIyeSMPi5X+fs5Wh3xWZljGGE0WmFg32RNkFujRB+UnM63EnhPG70WdqOx/MA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
+  '@ai-sdk/openai@1.3.22':
+    resolution: {integrity: sha512-QwA+2EkG0QyjVR+7h6FE7iOu2ivNqAVMm9UJZkVxxTk5OIq5fFJDTEI/zICEMuHImTTXR2JjsL6EirJ28Jc4cw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
+  '@ai-sdk/provider-utils@2.2.8':
+    resolution: {integrity: sha512-fqhG+4sCVv8x7nFzYnFo19ryhAa3w096Kmc3hWxMQfW/TubPOmt3A6tYZhl4mUfQWWQMsuSkLrtjlWuXBVSGQA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.23.8
+
+  '@ai-sdk/provider@1.1.3':
+    resolution: {integrity: sha512-qZMxYJ0qqX/RfnuIaab+zp8UAeJn/ygXXAffR5I4N0n1IrvA6qBsjc8hXLmBiMV2zoXlifkacF7sEFnYnjBcqg==}
+    engines: {node: '>=18'}
+
+  '@ai-sdk/react@1.2.12':
+    resolution: {integrity: sha512-jK1IZZ22evPZoQW3vlkZ7wvjYGYF+tRBKXtrcolduIkQ/m/sOAVcVeVDUDvh1T91xCnWCdUGCPZg2avZ90mv3g==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: ^18 || ^19 || ^19.0.0-rc
+      zod: ^3.23.8
+    peerDependenciesMeta:
+      zod:
+        optional: true
+
+  '@ai-sdk/ui-utils@1.2.11':
+    resolution: {integrity: sha512-3zcwCc8ezzFlwp3ZD15wAPjf2Au4s3vAbKsXQVyhxODHcmu0iyPO2Eua6D/vicq/AUm/BAo60r97O6HU+EI0+w==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.23.8
+
   '@alloc/quick-lru@5.2.0':
     resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
     engines: {node: '>=10'}
···
 
   '@octokit/types@14.0.0':
     resolution: {integrity: sha512-VVmZP0lEhbo2O1pdq63gZFiGCKkm8PPp8AUOijlwPO6hojEVjspA0MWKP7E4hbvGxzFKNqKr6p0IYtOH/Wf/zA==}
+
+  '@opentelemetry/api@1.9.0':
+    resolution: {integrity: sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==}
+    engines: {node: '>=8.0.0'}
 
   '@panva/hkdf@1.2.1':
     resolution: {integrity: sha512-6oclG6Y3PiDFcoyk8srjLfVKyMfVCKJ27JwNPViuXziFpmdz+MZnZN/aKY0JGXgYuO/VghU0jcOAZgWXZ1Dmrw==}
···
   '@types/d3-timer@3.0.2':
     resolution: {integrity: sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==}
 
+  '@types/diff-match-patch@1.0.36':
+    resolution: {integrity: sha512-xFdR6tkm0MWvBfO8xXCSsinYxHcqkQUlcHeSpMC2ukzOb6lwQAfDmW+Qt0AvlGd8HpsS28qKsB+oPeJn9I39jg==}
+
   '@types/estree@1.0.7':
     resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
 
···
     engines: {node: '>=0.4.0'}
     hasBin: true
 
+  ai@4.3.15:
+    resolution: {integrity: sha512-TYKRzbWg6mx/pmTadlAEIhuQtzfHUV0BbLY72+zkovXwq/9xhcH24IlQmkyBpElK6/4ArS0dHdOOtR1jOPVwtg==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      react: ^18 || ^19 || ^19.0.0-rc
+      zod: ^3.23.8
+    peerDependenciesMeta:
+      react:
+        optional: true
+
   ajv@6.12.6:
     resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
 
···
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
     engines: {node: '>=10'}
 
+  chalk@5.4.1:
+    resolution: {integrity: sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==}
+    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+
   class-variance-authority@0.7.1:
     resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
 
···
     resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
     engines: {node: '>= 0.4'}
 
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
   detect-libc@2.0.2:
     resolution: {integrity: sha512-UX6sGumvvqSaXgdKGUsgZWqcUyIXZ/vZTrlRT/iobiKhGL0zL4d3osHj3uqllWJK+i+sixDS/3COVEOFbupFyw==}
     engines: {node: '>=8'}
···
 
   detect-node-es@1.1.0:
     resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
+
+  diff-match-patch@1.0.5:
+    resolution: {integrity: sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw==}
 
   doctrine@2.1.0:
     resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==}
···
   json-schema-traverse@0.4.1:
     resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
 
+  json-schema@0.4.0:
+    resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==}
+
   json-stable-stringify-without-jsonify@1.0.1:
     resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
 
···
     resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==}
     hasBin: true
 
+  jsondiffpatch@0.6.0:
+    resolution: {integrity: sha512-3QItJOXp2AP1uv7waBkao5nCvhEv+QmJAd38Ybq7wNI74Q+BBmnLn4EDKz6yI9xGAIQoUF87qHt+kc1IVxB4zQ==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+    hasBin: true
+
   jsx-ast-utils@3.3.5:
     resolution: {integrity: sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==}
     engines: {node: '>=4.0'}
···
   scheduler@0.26.0:
     resolution: {integrity: sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==}
 
+  secure-json-parse@2.7.0:
+    resolution: {integrity: sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==}
+
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
···
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
+  swr@2.3.3:
+    resolution: {integrity: sha512-dshNvs3ExOqtZ6kJBaAsabhPdHyeY4P2cKwRCniDVifBMoG/SVI7tfLWqPXriVspf2Rg4tPzXJTnwaihIeFw2A==}
+    peerDependencies:
+      react: ^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
   tailwind-merge@3.2.0:
     resolution: {integrity: sha512-FQT/OVqCD+7edmmJpsgCsY820RTD5AkBryuG5IUqR5YQZSdj5xlH5nLgH7YPths7WsLPSpSBNneJdM8aS8aeFA==}
 
···
     resolution: {integrity: sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==}
     engines: {node: '>=6'}
 
+  throttleit@2.1.0:
+    resolution: {integrity: sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw==}
+    engines: {node: '>=18'}
+
   tiny-invariant@1.3.3:
     resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
 
···
     resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
     engines: {node: '>=10'}
 
+  zod-to-json-schema@3.24.5:
+    resolution: {integrity: sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==}
+    peerDependencies:
+      zod: ^3.24.1
+
   zod@3.24.3:
     resolution: {integrity: sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg==}
 
 snapshots:
 
+  '@ai-sdk/anthropic@1.2.11(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      zod: 3.24.3
+
+  '@ai-sdk/google@1.2.17(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      zod: 3.24.3
+
+  '@ai-sdk/openai@1.3.22(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      zod: 3.24.3
+
+  '@ai-sdk/provider-utils@2.2.8(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      nanoid: 3.3.11
+      secure-json-parse: 2.7.0
+      zod: 3.24.3
+
+  '@ai-sdk/provider@1.1.3':
+    dependencies:
+      json-schema: 0.4.0
+
+  '@ai-sdk/react@1.2.12(react@19.1.0)(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      '@ai-sdk/ui-utils': 1.2.11(zod@3.24.3)
+      react: 19.1.0
+      swr: 2.3.3(react@19.1.0)
+      throttleit: 2.1.0
+    optionalDependencies:
+      zod: 3.24.3
+
+  '@ai-sdk/ui-utils@1.2.11(zod@3.24.3)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      zod: 3.24.3
+      zod-to-json-schema: 3.24.5(zod@3.24.3)
+
   '@alloc/quick-lru@5.2.0': {}
 
   '@auth/core@0.39.0':
···
   '@octokit/types@14.0.0':
     dependencies:
       '@octokit/openapi-types': 25.0.0
+
+  '@opentelemetry/api@1.9.0': {}
 
   '@panva/hkdf@1.2.1': {}
 
···
 
   '@types/d3-timer@3.0.2': {}
 
+  '@types/diff-match-patch@1.0.36': {}
+
   '@types/estree@1.0.7': {}
 
   '@types/json-schema@7.0.15': {}
···
 
   acorn@8.14.1: {}
 
+  ai@4.3.15(react@19.1.0)(zod@3.24.3):
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.24.3)
+      '@ai-sdk/react': 1.2.12(react@19.1.0)(zod@3.24.3)
+      '@ai-sdk/ui-utils': 1.2.11(zod@3.24.3)
+      '@opentelemetry/api': 1.9.0
+      jsondiffpatch: 0.6.0
+      zod: 3.24.3
+    optionalDependencies:
+      react: 19.1.0
+
   ajv@6.12.6:
     dependencies:
       fast-deep-equal: 3.1.3
···
       ansi-styles: 4.3.0
       supports-color: 7.2.0
 
+  chalk@5.4.1: {}
+
   class-variance-authority@0.7.1:
     dependencies:
       clsx: 2.1.1
···
       has-property-descriptors: 1.0.2
       object-keys: 1.1.1
 
+  dequal@2.0.3: {}
+
   detect-libc@2.0.2: {}
 
   detect-libc@2.0.4: {}
 
   detect-node-es@1.1.0: {}
+
+  diff-match-patch@1.0.5: {}
 
   doctrine@2.1.0:
     dependencies:
···
 
   json-schema-traverse@0.4.1: {}
 
+  json-schema@0.4.0: {}
+
   json-stable-stringify-without-jsonify@1.0.1: {}
 
   json5@1.0.2:
     dependencies:
       minimist: 1.2.8
 
+  jsondiffpatch@0.6.0:
+    dependencies:
+      '@types/diff-match-patch': 1.0.36
+      chalk: 5.4.1
+      diff-match-patch: 1.0.5
+
   jsx-ast-utils@3.3.5:
     dependencies:
       array-includes: 3.1.8
···
 
   natural-compare@1.4.0: {}
 
-  next-auth@5.0.0-beta.27(next@15.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0):
+  next-auth@5.0.0-beta.27(next@15.3.1(@opentelemetry/api@1.9.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0))(react@19.1.0):
     dependencies:
       '@auth/core': 0.39.0
-      next: 15.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
+      next: 15.3.1(@opentelemetry/api@1.9.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0)
       react: 19.1.0
 
   next-themes@0.4.6(react-dom@19.1.0(react@19.1.0))(react@19.1.0):
···
       react: 19.1.0
       react-dom: 19.1.0(react@19.1.0)
 
-  next@15.3.1(react-dom@19.1.0(react@19.1.0))(react@19.1.0):
+  next@15.3.1(@opentelemetry/api@1.9.0)(react-dom@19.1.0(react@19.1.0))(react@19.1.0):
     dependencies:
       '@next/env': 15.3.1
       '@swc/counter': 0.1.3
···
       '@next/swc-linux-x64-musl': 15.3.1
       '@next/swc-win32-arm64-msvc': 15.3.1
       '@next/swc-win32-x64-msvc': 15.3.1
+      '@opentelemetry/api': 1.9.0
       sharp: 0.34.1
     transitivePeerDependencies:
       - '@babel/core'
···
 
   scheduler@0.26.0: {}
 
+  secure-json-parse@2.7.0: {}
+
   semver@6.3.1: {}
 
   semver@7.7.1: {}
···
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
+  swr@2.3.3(react@19.1.0):
+    dependencies:
+      dequal: 2.0.3
+      react: 19.1.0
+      use-sync-external-store: 1.5.0(react@19.1.0)
+
   tailwind-merge@3.2.0: {}
 
   tailwindcss@4.1.4: {}
 
   tapable@2.2.1: {}
+
+  throttleit@2.1.0: {}
 
   tiny-invariant@1.3.3: {}
 
···
   ws@8.18.2: {}
 
   yocto-queue@0.1.0: {}
+
+  zod-to-json-schema@3.24.5(zod@3.24.3):
+    dependencies:
+      zod: 3.24.3
 
   zod@3.24.3: {}