@theihtisham/ai-agent-starter-kit 1.0.0

package/src/app/(dashboard)/settings/billing/page.tsx

@@ -0,0 +1,59 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { PlanBadge } from '@/components/billing/plan-badge';
+import { UsageMeter } from '@/components/billing/usage-meter';
+
+export default function BillingPage() {
+  const [planId, setPlanId] = useState('free');
+  const [usage, setUsage] = useState({ messages: 0, tokens: 0, agents: 0 });
+  const [limits, setLimits] = useState({ maxMessages: 50, maxTokens: 100000, maxAgents: 2 });
+
+  useEffect(() => {
+    fetch('/api/usage')
+      .then((r) => r.json())
+      .then((res) => {
+        if (res.success) {
+          setPlanId(res.data?.planId ?? 'free');
+          setUsage(res.data?.usage ?? usage);
+          setLimits(res.data?.limits ?? limits);
+        }
+      })
+      .catch(() => {});
+  }, []);
+
+  const handleManageBilling = async () => {
+    const res = await fetch('/api/stripe/portal', { method: 'POST' });
+    if (res.ok) {
+      const { url } = await res.json();
+      window.location.href = url;
+    }
+  };
+
+  return (
+    <div className="max-w-2xl mx-auto space-y-6">
+      <h1 className="text-2xl font-bold">Billing</h1>
+
+      <Card>
+        <CardHeader className="flex flex-row items-center justify-between">
+          <CardTitle>Current Plan</CardTitle>
+          <PlanBadge planId={planId} />
+        </CardHeader>
+        <CardContent className="space-y-6">
+          <UsageMeter label="Messages" used={usage.messages} limit={limits.maxMessages} />
+          <UsageMeter label="Tokens" used={usage.tokens} limit={limits.maxTokens} />
+          <UsageMeter label="Agents" used={usage.agents} limit={limits.maxAgents} />
+
+          <div className="flex gap-3 pt-4">
+            <Button onClick={() => window.location.href = '/pricing'}>Change Plan</Button>
+            {planId !== 'free' && (
+              <Button variant="outline" onClick={handleManageBilling}>Manage Billing</Button>
+            )}
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/src/app/(dashboard)/settings/page.tsx

@@ -0,0 +1,45 @@
+'use client';
+
+import { useSession } from 'next-auth/react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Input } from '@/components/ui/input';
+import { Button } from '@/components/ui/button';
+
+export default function SettingsPage() {
+  const { data: session } = useSession();
+
+  return (
+    <div className="max-w-2xl mx-auto space-y-6">
+      <h1 className="text-2xl font-bold">Settings</h1>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Profile</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          <div className="space-y-2">
+            <label className="text-sm font-medium">Name</label>
+            <Input defaultValue={session?.user?.name ?? ''} />
+          </div>
+          <div className="space-y-2">
+            <label className="text-sm font-medium">Email</label>
+            <Input defaultValue={session?.user?.email ?? ''} disabled />
+          </div>
+          <Button>Save Changes</Button>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Danger Zone</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <p className="text-sm text-muted-foreground mb-4">
+            Permanently delete your account and all associated data.
+          </p>
+          <Button variant="destructive">Delete Account</Button>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/src/app/(dashboard)/usage/page.tsx

@@ -0,0 +1,46 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { StatCard } from '@/components/dashboard/stat-card';
+
+interface UsageData {
+  messages: number;
+  toolCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+export default function UsagePage() {
+  const [usage, setUsage] = useState<UsageData>({ messages: 0, toolCalls: 0, inputTokens: 0, outputTokens: 0 });
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetch('/api/usage')
+      .then((r) => r.json())
+      .then((res) => {
+        if (res.success) setUsage(res.data?.usage ?? usage);
+      })
+      .catch(() => {})
+      .finally(() => setLoading(false));
+  }, []);
+
+  return (
+    <div className="space-y-6">
+      <h1 className="text-2xl font-bold">Usage</h1>
+      <Card>
+        <CardHeader>
+          <CardTitle>Current Billing Period</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
+            <StatCard title="Messages" value={loading ? '...' : usage.messages} />
+            <StatCard title="Tool Calls" value={loading ? '...' : usage.toolCalls} />
+            <StatCard title="Input Tokens" value={loading ? '...' : usage.inputTokens.toLocaleString()} />
+            <StatCard title="Output Tokens" value={loading ? '...' : usage.outputTokens.toLocaleString()} />
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

package/src/app/api/agents/[id]/chat/route.ts

@@ -0,0 +1,100 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { chatMessageSchema } from '@/lib/utils/validation';
+import { AgentEngine, type AgentConfig } from '@/lib/ai/agent';
+import { loadHistory, saveMessage, createChat, getOrCreateChat } from '@/lib/ai/memory';
+import { generateChatTitle } from '@/lib/utils/id';
+import { checkUsageLimit, recordUsage } from '@/lib/stripe/usage';
+import { applyRateLimit } from '@/lib/rate-limit/rules';
+
+export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id: agentId } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const rl = await applyRateLimit(session.user.id, 'chat:message');
+    if (!rl.allowed) {
+      return NextResponse.json(
+        { success: false, error: { code: 'RATE_LIMITED', message: 'Too many messages' } },
+        { status: 429, headers: { 'Retry-After': String(Math.ceil((rl.resetAt - Date.now()) / 1000)) } },
+      );
+    }
+
+    const usageCheck = await checkUsageLimit(session.user.id, 'messages');
+    if (!usageCheck.allowed) {
+      return NextResponse.json(
+        { success: false, error: { code: 'LIMIT_EXCEEDED', message: 'Message limit reached. Upgrade your plan.' } },
+        { status: 402 },
+      );
+    }
+
+    const body = await req.json();
+    const { message, chatId } = chatMessageSchema.parse(body);
+
+    // Get agent
+    const agent = await prisma.agent.findFirst({
+      where: { id: agentId, userId: session.user.id },
+    });
+
+    if (!agent) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'Agent not found' } }, { status: 404 });
+    }
+
+    // Get or create chat
+    const chat = chatId
+      ? await prisma.chat.findUnique({ where: { id: chatId } })
+      : await createChat(agentId, session.user.id, generateChatTitle(message));
+
+    if (!chat) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'Chat not found' } }, { status: 404 });
+    }
+
+    // Save user message
+    await saveMessage(chat.id, 'user', message);
+    await recordUsage(session.user.id, 'message', 1);
+
+    // Load history and build agent engine
+    const history = await loadHistory(chat.id);
+    const config: AgentConfig = {
+      model: agent.model,
+      systemPrompt: agent.systemPrompt,
+      temperature: agent.temperature,
+      maxTokens: agent.maxTokens,
+      toolIds: agent.tools as string[],
+    };
+
+    const engine = new AgentEngine(config);
+    const { stream, getResult } = await engine.chatStream(history, message);
+
+    // Start processing in background and save results
+    const resultPromise = getResult().then(async (result) => {
+      await saveMessage(chat.id, 'assistant', result.content);
+      await recordUsage(session.user.id, 'token_input', result.inputTokens);
+      await recordUsage(session.user.id, 'token_output', result.outputTokens);
+      if (result.toolCalls > 0) {
+        await recordUsage(session.user.id, 'tool_call', result.toolCalls);
+      }
+      return result;
+    });
+
+    // Fire-and-forget result saving
+    resultPromise.catch(() => {});
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'X-Chat-Id': chat.id,
+      },
+    });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/agents/[id]/chats/route.ts

@@ -0,0 +1,36 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { getChatsForAgent, createChat } from '@/lib/ai/memory';
+
+export async function GET(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const chats = await getChatsForAgent(id, session.user.id);
+    return NextResponse.json({ success: true, data: chats });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}
+
+export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const chat = await createChat(id, session.user.id, 'New Chat');
+    return NextResponse.json({ success: true, data: chat }, { status: 201 });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/agents/[id]/route.ts

@@ -0,0 +1,97 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { updateAgentSchema } from '@/lib/utils/validation';
+
+export async function GET(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const agent = await prisma.agent.findFirst({
+      where: { id, userId: session.user.id },
+    });
+
+    if (!agent) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'Agent not found' } }, { status: 404 });
+    }
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        ...agent,
+        tools: agent.tools as string[],
+      },
+    });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}
+
+export async function PATCH(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const existing = await prisma.agent.findFirst({ where: { id, userId: session.user.id } });
+    if (!existing) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'Agent not found' } }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const data = updateAgentSchema.parse(body);
+
+    const agent = await prisma.agent.update({
+      where: { id },
+      data: {
+        ...(data.name !== undefined && { name: data.name }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.systemPrompt !== undefined && { systemPrompt: data.systemPrompt }),
+        ...(data.model !== undefined && { model: data.model }),
+        ...(data.temperature !== undefined && { temperature: data.temperature }),
+        ...(data.maxTokens !== undefined && { maxTokens: data.maxTokens }),
+        ...(data.tools !== undefined && { tools: data.tools }),
+        ...(data.isPublic !== undefined && { isPublic: data.isPublic }),
+      },
+    });
+
+    return NextResponse.json({ success: true, data: agent });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}
+
+export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const existing = await prisma.agent.findFirst({ where: { id, userId: session.user.id } });
+    if (!existing) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'Agent not found' } }, { status: 404 });
+    }
+
+    // Delete associated chats and messages
+    const chats = await prisma.chat.findMany({ where: { agentId: id }, select: { id: true } });
+    if (chats.length > 0) {
+      await prisma.message.deleteMany({ where: { chatId: { in: chats.map((c) => c.id) } } });
+      await prisma.chat.deleteMany({ where: { agentId: id } });
+    }
+    await prisma.agent.delete({ where: { id } });
+
+    return NextResponse.json({ success: true });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/agents/route.ts

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { createAgentSchema } from '@/lib/utils/validation';
+import { applyRateLimit } from '@/lib/rate-limit/rules';
+
+export async function GET() {
+  try {
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const agents = await prisma.agent.findMany({
+      where: { userId: session.user.id },
+      orderBy: { updatedAt: 'desc' },
+      include: {
+        _count: { select: { chats: true } },
+        chats: {
+          orderBy: { updatedAt: 'desc' },
+          take: 1,
+          include: { _count: { select: { messages: true } } },
+        },
+      },
+    });
+
+    const data = agents.map((agent) => ({
+      id: agent.id,
+      name: agent.name,
+      description: agent.description,
+      model: agent.model,
+      isPublic: agent.isPublic,
+      tools: agent.tools as string[],
+      temperature: agent.temperature,
+      maxTokens: agent.maxTokens,
+      messageCount: agent.chats.reduce((sum, c) => sum + c._count.messages, 0),
+      lastUsed: agent.chats[0]?.updatedAt?.toISOString() ?? null,
+    }));
+
+    return NextResponse.json({ success: true, data });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const rl = await applyRateLimit(session.user.id, 'agent:create');
+    if (!rl.allowed) {
+      return NextResponse.json(
+        { success: false, error: { code: 'RATE_LIMITED', message: 'Too many requests' } },
+        { status: 429, headers: { 'Retry-After': String(Math.ceil((rl.resetAt - Date.now()) / 1000)) } },
+      );
+    }
+
+    const body = await req.json();
+    const data = createAgentSchema.parse(body);
+
+    const agent = await prisma.agent.create({
+      data: {
+        userId: session.user.id,
+        name: data.name,
+        description: data.description ?? '',
+        systemPrompt: data.systemPrompt,
+        model: data.model,
+        temperature: data.temperature ?? 0.7,
+        maxTokens: data.maxTokens ?? 4096,
+        tools: data.tools ?? [],
+        isPublic: data.isPublic ?? false,
+      },
+    });
+
+    return NextResponse.json({ success: true, data: agent }, { status: 201 });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/api-keys/[id]/route.ts

@@ -0,0 +1,25 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+
+export async function DELETE(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  try {
+    const { id } = await params;
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const key = await prisma.apiKey.findFirst({ where: { id, userId: session.user.id } });
+    if (!key) {
+      return NextResponse.json({ success: false, error: { code: 'NOT_FOUND', message: 'API key not found' } }, { status: 404 });
+    }
+
+    await prisma.apiKey.delete({ where: { id } });
+    return NextResponse.json({ success: true });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/api-keys/route.ts

@@ -0,0 +1,72 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { createApiKeySchema } from '@/lib/utils/validation';
+import { generateApiKey } from '@/lib/utils/id';
+import { applyRateLimit } from '@/lib/rate-limit/rules';
+import { hash } from 'bcryptjs';
+
+export async function GET() {
+  try {
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const keys = await prisma.apiKey.findMany({
+      where: { userId: session.user.id },
+      select: { id: true, name: true, prefix: true, lastUsed: true, createdAt: true },
+      orderBy: { createdAt: 'desc' },
+    });
+
+    return NextResponse.json({ success: true, data: keys });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      return NextResponse.json({ success: false, error: { code: 'UNAUTHORIZED', message: 'Not authenticated' } }, { status: 401 });
+    }
+
+    const rl = await applyRateLimit(session.user.id, 'api-key:create');
+    if (!rl.allowed) {
+      return NextResponse.json(
+        { success: false, error: { code: 'RATE_LIMITED', message: 'Too many API key creation attempts' } },
+        { status: 429 },
+      );
+    }
+
+    const body = await req.json();
+    const data = createApiKeySchema.parse(body);
+
+    const { key, prefix, hashed } = generateApiKey();
+
+    const apiKey = await prisma.apiKey.create({
+      data: {
+        userId: session.user.id,
+        name: data.name,
+        key: hashed,
+        prefix,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        id: apiKey.id,
+        name: apiKey.name,
+        prefix: apiKey.prefix,
+        key, // Only returned on creation
+        createdAt: apiKey.createdAt,
+      },
+    }, { status: 201 });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,5 @@
+import NextAuth from 'next-auth';
+import { authOptions } from '@/lib/auth/nextauth';
+
+const handler = NextAuth(authOptions);
+export { handler as GET, handler as POST };

package/src/app/api/auth/register/route.ts

@@ -0,0 +1,53 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { hash } from 'bcryptjs';
+import prisma from '@/lib/db/client';
+import { handleApiError } from '@/lib/utils/api-response';
+import { z } from 'zod';
+
+const registerSchema = z.object({
+  name: z.string().min(2).max(50),
+  email: z.string().email(),
+  password: z.string().min(8),
+});
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const data = registerSchema.parse(body);
+
+    const existing = await prisma.user.findUnique({ where: { email: data.email } });
+    if (existing) {
+      return NextResponse.json(
+        { success: false, error: { code: 'EMAIL_EXISTS', message: 'Email already registered' } },
+        { status: 409 },
+      );
+    }
+
+    const hashedPassword = await hash(data.password, 12);
+
+    const user = await prisma.user.create({
+      data: {
+        name: data.name,
+        email: data.email,
+        // NextAuth PrismaAdapter expects the password on the Account model
+        // For credentials provider, store in a custom field or handle in callback
+      },
+    });
+
+    // Create a credentials account for the user
+    await prisma.account.create({
+      data: {
+        userId: user.id,
+        type: 'credentials',
+        provider: 'credentials',
+        providerAccountId: user.id,
+        // Store hashed password in a separate mechanism
+        // In production, use a proper credentials provider setup
+      },
+    });
+
+    return NextResponse.json({ success: true, data: { id: user.id, email: user.email } }, { status: 201 });
+  } catch (err) {
+    return handleApiError(err);
+  }
+}

package/src/app/api/health/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import prisma from '@/lib/db/client';
+
+export async function GET() {
+  const checks: Record<string, 'ok' | 'down' | 'not_configured'> = {
+    database: 'down',
+    redis: process.env.REDIS_URL ? 'down' : 'not_configured',
+    stripe: process.env.STRIPE_SECRET_KEY ? 'ok' : 'not_configured',
+  };
+
+  try {
+    await prisma.$queryRaw`SELECT 1`;
+    checks.database = 'ok';
+  } catch {
+    checks.database = 'down';
+  }
+
+  const status = checks.database === 'ok' ? 'ok' : 'down';
+
+  return NextResponse.json({
+    status,
+    timestamp: new Date().toISOString(),
+    version: process.env.npm_package_version ?? '0.1.0',
+    services: checks,
+  }, { status: status === 'ok' ? 200 : 503 });
+}