@nextsparkjs/theme-default 0.1.0-beta.1

package/api/ai/orchestrator/route.ts

@@ -0,0 +1,226 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { authenticateRequest } from '@nextsparkjs/core/lib/api/auth/dual-auth'
+import { processMessage } from '@/themes/default/lib/langchain/orchestrator'
+import { dbMemoryStore } from '@/plugins/langchain/lib/db-memory-store'
+import type { ChatMessage } from '@/plugins/langchain/types/langchain.types'
+
+// Schema for request validation
+const ChatRequestSchema = z.object({
+    message: z.string().min(1).max(2000),
+    sessionId: z.string().optional(),
+})
+
+// Helper to convert messages to API format
+// Filters out internal messages (tool results, system messages, empty AI messages)
+function convertToApiMessages(
+    messages: Awaited<ReturnType<typeof dbMemoryStore.getMessages>>
+): ChatMessage[] {
+    return messages
+        .filter((msg) => {
+            const type = msg._getType()
+
+            // Skip tool messages - these are internal tool results (e.g., API responses)
+            if (type === 'tool') return false
+
+            // Skip system messages - these are internal prompts
+            if (type === 'system') return false
+
+            // Skip AI messages with empty content (these are tool_call-only messages)
+            if (type === 'ai') {
+                const content = msg.content
+                if (!content || (typeof content === 'string' && content.trim() === '')) {
+                    return false
+                }
+            }
+
+            return true
+        })
+        .map((msg, index) => ({
+            id: `msg-${index}`,
+            role: msg._getType() === 'human' ? 'user' : 'assistant',
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            timestamp: Date.now() - (messages.length - index) * 1000,
+        }))
+}
+
+/**
+ * AI Chat Endpoint for Default Theme
+ *
+ * Uses the Multi-Agent Orchestrator pattern:
+ * - Orchestrator analyzes user intent and routes to specialized agents
+ * - Sub-agents: task-assistant, customer-assistant, page-assistant
+ * - Handles ambiguous requests by asking for clarification
+ */
+export async function POST(req: NextRequest) {
+    try {
+        // 1. Dual authentication (API key or session)
+        const authResult = await authenticateRequest(req)
+        if (!authResult.success || !authResult.user) {
+            return NextResponse.json(
+                { success: false, error: 'Unauthorized' },
+                { status: 401 }
+            )
+        }
+
+        // 2. Team context required for team-scoped operations
+        const teamId = req.headers.get('x-team-id')
+        if (!teamId) {
+            return NextResponse.json(
+                { success: false, error: 'Team context required', code: 'TEAM_CONTEXT_REQUIRED' },
+                { status: 400 }
+            )
+        }
+
+        const userId = authResult.user.id
+        const userName = authResult.user.name || 'system'
+
+        // 3. Parse and Validate Request
+        const body = await req.json()
+        const result = ChatRequestSchema.safeParse(body)
+
+        if (!result.success) {
+            return NextResponse.json(
+                { success: false, error: 'Invalid request', details: result.error.issues },
+                { status: 400 }
+            )
+        }
+
+        const { message, sessionId: requestedSessionId } = result.data
+
+        // Generate a session ID if not provided
+        const sessionId = requestedSessionId || crypto.randomUUID()
+
+        // 4. Process through orchestrator (routes to appropriate sub-agent)
+        // Uses graph-based orchestrator if LANGCHAIN_USE_GRAPH_ORCHESTRATOR=true
+        const response = await processMessage(message, {
+            userId,
+            teamId,
+            sessionId,
+            userName,
+        })
+
+        // 5. Return Response
+        return NextResponse.json({
+            success: true,
+            data: {
+                message: response.content,
+                sessionId: response.sessionId,
+                agentUsed: response.agentUsed,
+            },
+        })
+    } catch (error) {
+        console.error('AI Chat Error:', error)
+        return NextResponse.json(
+            { success: false, error: 'Internal Server Error' },
+            { status: 500 }
+        )
+    }
+}
+
+/**
+ * GET - Retrieve conversation history
+ */
+export async function GET(req: NextRequest) {
+    const { searchParams } = new URL(req.url)
+    const sessionId = searchParams.get('sessionId')
+
+    // Return API documentation if no sessionId
+    if (!sessionId) {
+        return NextResponse.json({
+            endpoint: '/api/v1/theme/default/ai/orchestrator',
+            description: 'Multi-agent orchestrator - routes to specialized sub-agents',
+            methods: {
+                POST: {
+                    description: 'Send message to AI assistant',
+                    body: { message: 'string', sessionId: 'string (optional)' },
+                },
+                GET: {
+                    description: 'Get conversation history',
+                    query: { sessionId: 'string (required)' },
+                },
+                DELETE: {
+                    description: 'Clear conversation',
+                    body: { sessionId: 'string (required)' },
+                },
+            },
+        })
+    }
+
+    // Auth
+    const authResult = await authenticateRequest(req)
+    if (!authResult.success || !authResult.user) {
+        return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const teamId = req.headers.get('x-team-id')
+    if (!teamId) {
+        return NextResponse.json(
+            { success: false, error: 'Team context required' },
+            { status: 400 }
+        )
+    }
+
+    const context = { userId: authResult.user.id, teamId }
+
+    try {
+        const session = await dbMemoryStore.getSession(sessionId, context)
+        if (!session) {
+            return NextResponse.json({ success: false, error: 'Conversation not found' }, { status: 404 })
+        }
+
+        const messages = await dbMemoryStore.getMessages(sessionId, context)
+
+        return NextResponse.json({
+            success: true,
+            data: {
+                sessionId,
+                name: session.name,
+                messageCount: session.messageCount,
+                isPinned: session.isPinned,
+                messages: convertToApiMessages(messages),
+            },
+        })
+    } catch (error) {
+        console.error('[AI Chat] Get history error:', error)
+        return NextResponse.json({ success: false, error: 'Failed to get history' }, { status: 500 })
+    }
+}
+
+/**
+ * DELETE - Clear conversation
+ */
+export async function DELETE(req: NextRequest) {
+    const authResult = await authenticateRequest(req)
+    if (!authResult.success || !authResult.user) {
+        return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const teamId = req.headers.get('x-team-id')
+    if (!teamId) {
+        return NextResponse.json(
+            { success: false, error: 'Team context required' },
+            { status: 400 }
+        )
+    }
+
+    try {
+        const body = await req.json().catch(() => ({}))
+        const sessionId = body.sessionId
+
+        if (!sessionId) {
+            return NextResponse.json({ success: false, error: 'sessionId required' }, { status: 400 })
+        }
+
+        await dbMemoryStore.clearSession(sessionId, { userId: authResult.user.id, teamId })
+
+        return NextResponse.json({
+            success: true,
+            message: 'Conversation cleared',
+            sessionId,
+        })
+    } catch (error) {
+        console.error('[AI Chat] Clear error:', error)
+        return NextResponse.json({ success: false, error: 'Failed to clear' }, { status: 500 })
+    }
+}

package/api/ai/single-agent/route.ts

@@ -0,0 +1,291 @@
+/**
+ * ============================================================================
+ * SINGLE AGENT CHAT ENDPOINT
+ * ============================================================================
+ *
+ * A unified agent with access to ALL entity tools (tasks, customers, pages).
+ * Use this for simpler interactions where routing overhead is unnecessary.
+ *
+ * Configuration is centralized in: config/langchain.config.ts
+ *
+ * ============================================================================
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { authenticateRequest } from '@nextsparkjs/core/lib/api/auth/dual-auth'
+import { createAgent } from '@/plugins/langchain/lib/agent-factory'
+import {
+    dbMemoryStore,
+    CONVERSATION_LIMITS,
+    generateSessionId,
+} from '@/plugins/langchain/lib/db-memory-store'
+import {
+    getAgentConfig,
+    getAgentModelConfig,
+    getAgentTools,
+    getAgentPromptName,
+} from '@/themes/default/lib/langchain/langchain.config'
+import { loadSystemPrompt } from '@/themes/default/lib/langchain/agents'
+import type { ChatMessage } from '@/plugins/langchain/types/langchain.types'
+
+// Agent name - matches key in AGENTS config
+const AGENT_NAME = 'single-agent'
+
+// Request validation
+const ChatRequestSchema = z.object({
+    message: z.string().min(1).max(2000),
+    sessionId: z.string().optional(),
+})
+
+// Helper to convert messages to API format
+// Filters out internal messages (tool results, system messages, empty AI messages)
+function convertToApiMessages(
+    messages: Awaited<ReturnType<typeof dbMemoryStore.getMessages>>
+): ChatMessage[] {
+    return messages
+        .filter((msg) => {
+            const type = msg._getType()
+
+            // Skip tool messages - these are internal tool results (e.g., API responses)
+            if (type === 'tool') return false
+
+            // Skip system messages - these are internal prompts
+            if (type === 'system') return false
+
+            // Skip AI messages with empty content (these are tool_call-only messages)
+            if (type === 'ai') {
+                const content = msg.content
+                if (!content || (typeof content === 'string' && content.trim() === '')) {
+                    return false
+                }
+            }
+
+            return true
+        })
+        .map((msg, index) => ({
+            id: `msg-${index}`,
+            role: msg._getType() === 'human' ? 'user' : 'assistant',
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            timestamp: Date.now() - (messages.length - index) * 1000,
+        }))
+}
+
+/**
+ * POST - Send message to single agent
+ */
+export async function POST(req: NextRequest) {
+    try {
+        // 1. Authentication
+        const authResult = await authenticateRequest(req)
+        if (!authResult.success || !authResult.user) {
+            return NextResponse.json(
+                { success: false, error: 'Unauthorized' },
+                { status: 401 }
+            )
+        }
+
+        // 2. Team context
+        const teamId = req.headers.get('x-team-id')
+        if (!teamId) {
+            return NextResponse.json(
+                { success: false, error: 'Team context required', code: 'TEAM_CONTEXT_REQUIRED' },
+                { status: 400 }
+            )
+        }
+
+        const userId = authResult.user.id
+        const userName = authResult.user.name || 'system'
+        const context = { userId, teamId, userName }
+
+        // 3. Validate request
+        const body = await req.json()
+        const validation = ChatRequestSchema.safeParse(body)
+
+        if (!validation.success) {
+            return NextResponse.json(
+                { success: false, error: 'Invalid request', details: validation.error.issues },
+                { status: 400 }
+            )
+        }
+
+        const { message, sessionId: requestedSessionId } = validation.data
+
+        // 4. Session management
+        let sessionId: string
+        let isNewSession = false
+
+        if (requestedSessionId) {
+            sessionId = requestedSessionId
+            const existingSession = await dbMemoryStore.getSession(sessionId, context)
+            isNewSession = !existingSession
+        } else {
+            sessionId = generateSessionId(userId)
+            isNewSession = true
+        }
+
+        // 5. Check conversation limits
+        if (isNewSession) {
+            const currentCount = await dbMemoryStore.countSessions(context)
+
+            if (currentCount >= CONVERSATION_LIMITS.MAX_CONVERSATIONS) {
+                return NextResponse.json({
+                    success: false,
+                    error: 'CONVERSATION_LIMIT_REACHED',
+                    message: `Maximum of ${CONVERSATION_LIMITS.MAX_CONVERSATIONS} conversations reached.`,
+                    data: { currentCount, maxAllowed: CONVERSATION_LIMITS.MAX_CONVERSATIONS },
+                }, { status: 400 })
+            }
+        }
+
+        // 6. Get agent configuration from centralized config
+        const agentConfig = getAgentConfig(AGENT_NAME)
+        if (!agentConfig) {
+            throw new Error(`Agent '${AGENT_NAME}' not configured`)
+        }
+
+        // 7. Load system prompt from .md file
+        const promptName = getAgentPromptName(AGENT_NAME)
+        if (!promptName) {
+            throw new Error(`No system prompt configured for agent '${AGENT_NAME}'`)
+        }
+        const systemPrompt = loadSystemPrompt(promptName as any)
+
+        // 8. Create agent with config from langchain.config.ts
+        const agent = await createAgent({
+            sessionId,
+            agentName: AGENT_NAME,
+            context,
+            systemPrompt,
+            tools: getAgentTools(AGENT_NAME, context),
+            modelConfig: getAgentModelConfig(AGENT_NAME),
+        })
+
+        // 9. Process message
+        const response = await agent.chat(message)
+
+        return NextResponse.json({
+            success: true,
+            data: {
+                message: response.content,
+                sessionId: response.sessionId,
+                isNewSession,
+            },
+        })
+    } catch (error) {
+        console.error('[Single Agent] Error:', error)
+        return NextResponse.json(
+            { success: false, error: 'Failed to process message' },
+            { status: 500 }
+        )
+    }
+}
+
+/**
+ * GET - Retrieve conversation history
+ */
+export async function GET(req: NextRequest) {
+    const { searchParams } = new URL(req.url)
+    const sessionId = searchParams.get('sessionId')
+
+    // Return API documentation if no sessionId
+    if (!sessionId) {
+        const agentConfig = getAgentConfig(AGENT_NAME)
+        return NextResponse.json({
+            endpoint: '/api/v1/theme/default/ai/single-agent',
+            description: agentConfig?.description || 'Single agent chat endpoint',
+            agent: AGENT_NAME,
+            methods: {
+                POST: {
+                    description: 'Send message to AI assistant',
+                    body: { message: 'string', sessionId: 'string (optional)' },
+                },
+                GET: {
+                    description: 'Get conversation history',
+                    query: { sessionId: 'string (required)' },
+                },
+                DELETE: {
+                    description: 'Clear conversation',
+                    body: { sessionId: 'string (required)' },
+                },
+            },
+        })
+    }
+
+    // Auth
+    const authResult = await authenticateRequest(req)
+    if (!authResult.success || !authResult.user) {
+        return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const teamId = req.headers.get('x-team-id')
+    if (!teamId) {
+        return NextResponse.json(
+            { success: false, error: 'Team context required' },
+            { status: 400 }
+        )
+    }
+
+    const context = { userId: authResult.user.id, teamId }
+
+    try {
+        const session = await dbMemoryStore.getSession(sessionId, context)
+        if (!session) {
+            return NextResponse.json({ success: false, error: 'Conversation not found' }, { status: 404 })
+        }
+
+        const messages = await dbMemoryStore.getMessages(sessionId, context)
+
+        return NextResponse.json({
+            success: true,
+            data: {
+                sessionId,
+                name: session.name,
+                messageCount: session.messageCount,
+                isPinned: session.isPinned,
+                messages: convertToApiMessages(messages),
+            },
+        })
+    } catch (error) {
+        console.error('[Single Agent] Get history error:', error)
+        return NextResponse.json({ success: false, error: 'Failed to get history' }, { status: 500 })
+    }
+}
+
+/**
+ * DELETE - Clear conversation
+ */
+export async function DELETE(req: NextRequest) {
+    const authResult = await authenticateRequest(req)
+    if (!authResult.success || !authResult.user) {
+        return NextResponse.json({ success: false, error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const teamId = req.headers.get('x-team-id')
+    if (!teamId) {
+        return NextResponse.json(
+            { success: false, error: 'Team context required' },
+            { status: 400 }
+        )
+    }
+
+    try {
+        const body = await req.json().catch(() => ({}))
+        const sessionId = body.sessionId
+
+        if (!sessionId) {
+            return NextResponse.json({ success: false, error: 'sessionId required' }, { status: 400 })
+        }
+
+        await dbMemoryStore.clearSession(sessionId, { userId: authResult.user.id, teamId })
+
+        return NextResponse.json({
+            success: true,
+            message: 'Conversation cleared',
+            sessionId,
+        })
+    } catch (error) {
+        console.error('[Single Agent] Clear error:', error)
+        return NextResponse.json({ success: false, error: 'Failed to clear' }, { status: 500 })
+    }
+}

package/api/ai/usage/route.ts

@@ -0,0 +1,122 @@
+/**
+ * ============================================================================
+ * TOKEN USAGE API ENDPOINT
+ * ============================================================================
+ *
+ * Provides token usage statistics for users and teams.
+ * Supports different time periods and user/team views.
+ *
+ * GET /api/ai/usage
+ *   Query params:
+ *     - period: 'today' | '7d' | '30d' | 'all' (default: '30d')
+ *     - type: 'user' | 'team' (default: 'user')
+ *
+ * Returns:
+ *   - stats: Aggregated usage statistics
+ *   - daily: Daily breakdown for charts
+ *
+ * ============================================================================
+ */
+
+import { NextRequest, NextResponse } from 'next/server'
+import { authenticateRequest } from '@nextsparkjs/core/lib/api/auth/dual-auth'
+import { tokenTracker } from '@/plugins/langchain/lib/token-tracker'
+import { queryOne } from '@nextsparkjs/core/lib/db'
+
+type Period = 'today' | '7d' | '30d' | 'all'
+
+/**
+ * GET - Retrieve token usage statistics
+ */
+export async function GET(request: NextRequest) {
+    try {
+        // 1. Authentication
+        const authResult = await authenticateRequest(request)
+        if (!authResult.success || !authResult.user) {
+            return NextResponse.json(
+                { success: false, error: 'Unauthorized' },
+                { status: 401 }
+            )
+        }
+
+        // 2. Team context
+        const teamId = request.headers.get('x-team-id')
+        if (!teamId) {
+            return NextResponse.json(
+                { success: false, error: 'Team context required', code: 'TEAM_CONTEXT_REQUIRED' },
+                { status: 400 }
+            )
+        }
+
+        const userId = authResult.user.id
+
+        // 3. Parse query parameters
+        const { searchParams } = new URL(request.url)
+        const period = (searchParams.get('period') || '30d') as Period
+        const type = searchParams.get('type') || 'user'
+
+        // Validate period
+        if (!['today', '7d', '30d', 'all'].includes(period)) {
+            return NextResponse.json(
+                { success: false, error: 'Invalid period. Must be: today, 7d, 30d, or all' },
+                { status: 400 }
+            )
+        }
+
+        // 4. Check permissions for team usage
+        if (type === 'team') {
+            // Get user's team role to check if they're admin
+            const teamMembership = await queryOne<{ role: string }>(
+                `SELECT role FROM public.team_members
+                 WHERE "userId" = $1 AND "teamId" = $2`,
+                [userId, teamId]
+            )
+
+            const isTeamAdmin = teamMembership?.role === 'admin' || teamMembership?.role === 'owner'
+
+            if (!isTeamAdmin) {
+                return NextResponse.json(
+                    { success: false, error: 'Team usage requires admin permissions' },
+                    { status: 403 }
+                )
+            }
+        }
+
+        const context = {
+            userId,
+            teamId,
+        }
+
+        // 5. Fetch usage statistics
+        const [stats, daily] = await Promise.all([
+            type === 'team'
+                ? tokenTracker.getTeamUsage(teamId, period)
+                : tokenTracker.getUsage(context, period),
+            tokenTracker.getDailyUsage(
+                context,
+                period === 'all' ? 365 : period === '30d' ? 30 : period === '7d' ? 7 : 1
+            ),
+        ])
+
+        // 6. Return results
+        return NextResponse.json({
+            success: true,
+            data: {
+                stats,
+                daily,
+                period,
+                type,
+            },
+        })
+    } catch (error) {
+        console.error('[AI Usage] Error:', error)
+        return NextResponse.json(
+            {
+                success: false,
+                error: 'Failed to retrieve usage statistics',
+                details: error instanceof Error ? error.message : 'Unknown error',
+            },
+            { status: 500 }
+        )
+    }
+}