@retrivora-ai/rag-engine 1.9.6 → 1.9.8

package/src/handlers/index.ts

@@ -3,7 +3,147 @@ import { VectorPlugin } from '../core/VectorPlugin';
 import { RagConfig } from '../config/RagConfig';
 import { ChatMessage, ChatResponse } from '../types';
 import { DocumentParser } from '../utils/DocumentParser';
-import { UITransformer } from '../utils/UITransformer'
+import { UITransformer } from '../utils/UITransformer';
+import { DatabaseStorage, HistoryMessage } from '../core/DatabaseStorage';
+
+export interface HandlerOptions {
+  onAuthorize?: (req: NextRequest) => boolean | Promise<boolean> | Response | Promise<Response>;
+}
+
+async function checkAuth(
+  req: NextRequest,
+  onAuthorize?: (req: NextRequest) => boolean | Promise<boolean> | Response | Promise<Response>
+): Promise<Response | null> {
+  if (!onAuthorize) return null;
+  try {
+    const res = await onAuthorize(req);
+    if (res === false) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+    if (res instanceof Response) {
+      return res;
+    }
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Authorization check failed';
+    return NextResponse.json({ error: msg }, { status: 401 });
+  }
+}
+
+
+// ─── Rate Limiter ─────────────────────────────────────────────────────────────
+
+/**
+ * In-memory sliding-window rate limiter.
+ * Keyed by IP + licenseKey. Rejects requests that exceed the limit.
+ * Automatically prunes expired entries to avoid memory growth.
+ */
+class RateLimiter {
+  private readonly hits = new Map<string, number[]>();
+  private readonly windowMs: number;
+  private readonly max: number;
+
+  constructor(windowMs = 60_000, max = 30) {
+    this.windowMs = windowMs;
+    this.max = max;
+  }
+
+  /** Returns true if the request should be allowed, false if rate-limited. */
+  allow(key: string): boolean {
+    const now = Date.now();
+    const cutoff = now - this.windowMs;
+    const existing = (this.hits.get(key) || []).filter(t => t > cutoff);
+    existing.push(now);
+    this.hits.set(key, existing);
+    // Periodically prune stale entries to avoid memory leak
+    if (this.hits.size > 5000) {
+      for (const [k, timestamps] of this.hits.entries()) {
+        if (timestamps.every(t => t <= cutoff)) this.hits.delete(k);
+      }
+    }
+    return existing.length <= this.max;
+  }
+
+  retryAfterSec(key: string): number {
+    const now = Date.now();
+    const cutoff = now - this.windowMs;
+    const existing = (this.hits.get(key) || []).filter(t => t > cutoff);
+    if (existing.length === 0) return 0;
+    return Math.ceil((existing[0] + this.windowMs - now) / 1000);
+  }
+}
+
+// Global singleton rate limiter: 30 requests per 60s per IP
+const _g = global as any;
+const rateLimiter: RateLimiter = _g.__retrivoraRateLimiter ??
+  (_g.__retrivoraRateLimiter = new RateLimiter(60_000, 30));
+
+/** Derive a rate-limit key from request headers. */
+function getRateLimitKey(req: NextRequest): string {
+  const ip = req.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
+    || req.headers.get('x-real-ip')
+    || '127.0.0.1';
+  return `ip:${ip}`;
+}
+
+/** Check rate limit and return a 429 response if exceeded, else null. */
+function checkRateLimit(req: NextRequest): Response | null {
+  const key = getRateLimitKey(req);
+  if (!rateLimiter.allow(key)) {
+    const retryAfter = rateLimiter.retryAfterSec(key);
+    return new Response(
+      JSON.stringify({ error: { code: 'RATE_LIMITED', message: 'Too many requests. Please slow down.' } }),
+      {
+        status: 429,
+        headers: {
+          'Content-Type': 'application/json',
+          'Retry-After': String(retryAfter),
+          'X-RateLimit-Limit': '30',
+          'X-RateLimit-Window': '60',
+        },
+      }
+    );
+  }
+  return null;
+}
+
+// ─── Input Sanitization ───────────────────────────────────────────────────────
+
+const MAX_MESSAGE_LENGTH = 8000;
+
+/**
+ * Sanitize a chat message:
+ *   - Strip Unicode control characters (except standard whitespace)
+ *   - Enforce max character length
+ */
+function sanitizeInput(raw: string): { ok: true; value: string } | { ok: false; error: string } {
+  // Strip control chars (U+0000–U+001F except tab/newline/CR, and U+007F–U+009F)
+  const stripped = raw.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+  const trimmed = stripped.trim();
+  if (!trimmed) {
+    return { ok: false, error: 'message must not be empty' };
+  }
+  if (trimmed.length > MAX_MESSAGE_LENGTH) {
+    return { ok: false, error: `message must be ≤ ${MAX_MESSAGE_LENGTH} characters` };
+  }
+  return { ok: true, value: trimmed };
+}
+
+// ─── Plugin Singleton ─────────────────────────────────────────────────────────
+
+/**
+ * Get or create a module-level VectorPlugin singleton keyed by a stable hash of the config.
+ * Prevents unnecessary DB connection pool recreation on hot reloads and serverless cold starts.
+ */
+function getOrCreatePlugin(configOrPlugin: Partial<RagConfig> | VectorPlugin | undefined): VectorPlugin {
+  if (configOrPlugin instanceof VectorPlugin) return configOrPlugin;
+  // Use a global to survive Next.js hot reloads in dev
+  const cacheKey = '__retrivoraPlugin_' + JSON.stringify(configOrPlugin ?? {}).slice(0, 64);
+  if (!_g[cacheKey]) {
+    _g[cacheKey] = new VectorPlugin(configOrPlugin);
+  }
+  return _g[cacheKey];
+}
 
 // ─── SSE helpers ──────────────────────────────────────────────────────────────
 
@@ -48,6 +188,8 @@ const SSE_HEADERS: Record<string, string> = {
   'X-Accel-Buffering': 'no', // Disable Nginx buffering for streaming
 };
 
+
+
 // ─── Handler Factories ────────────────────────────────────────────────────────
 
 /**
@@ -64,27 +206,66 @@ const SSE_HEADERS: Record<string, string> = {
  * const plugin = new VectorPlugin(getRagConfig());
  * export const POST = createChatHandler(plugin);
  */
-export function createChatHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createChatHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const storage = new DatabaseStorage(plugin.getConfig());
+  const onAuthorize = options?.onAuthorize;
 
   return async function POST(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
+    // 1. Rate limit check
+    const rateLimited = checkRateLimit(req);
+    if (rateLimited) return rateLimited;
+
     try {
       const body = await req.json();
-      const { message, history = [], namespace } = body as {
+      const { message: rawMessage, history = [], namespace, sessionId = 'default', messageId, userMessageId } = body as {
         message: string;
         history?: ChatMessage[];
         namespace?: string;
+        sessionId?: string;
+        messageId?: string;
+        userMessageId?: string;
       };
 
-      if (!message?.trim()) {
-        return NextResponse.json({ error: 'message is required' }, { status: 400 });
+      // 2. Input sanitization
+      const sanitized = sanitizeInput(rawMessage ?? '');
+      if (!sanitized.ok) {
+        return NextResponse.json({ error: { code: 'INVALID_INPUT', message: sanitized.error } }, { status: 400 });
       }
+      const message = sanitized.value;
+
+      // Save user message to history
+      const userMsgId = userMessageId || `user_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+      await storage.saveMessage(sessionId, {
+        id: userMsgId,
+        role: 'user',
+        content: message,
+      }).catch(err => console.warn('[createChatHandler] Failed to save user message:', err));
 
       const result = await plugin.chat(message, history, namespace);
-      return NextResponse.json(result);
+
+      // Save assistant message to history
+      const assistantMsgId = messageId || `assistant_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+      await storage.saveMessage(sessionId, {
+        id: assistantMsgId,
+        role: 'assistant',
+        content: result.reply,
+        sources: result.sources,
+        uiTransformation: result.ui_transformation,
+        trace: result.trace,
+      }).catch(err => console.warn('[createChatHandler] Failed to save assistant message:', err));
+
+      return NextResponse.json({
+        ...result,
+        messageId: assistantMsgId,
+        userMessageId: userMsgId,
+      });
     } catch (err) {
       const message = err instanceof Error ? err.message : 'Internal server error';
       return NextResponse.json({ error: message }, { status: 500 });
@@ -114,32 +295,61 @@ export function createChatHandler(configOrPlugin?: Partial<RagConfig> | VectorPl
  * //   }
  * // }
  */
-export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createStreamHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const storage = new DatabaseStorage(plugin.getConfig());
+  const onAuthorize = options?.onAuthorize;
 
   return async function POST(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
+    // 1. Rate limit check
+    const rateLimited = checkRateLimit(req);
+    if (rateLimited) return rateLimited;
+
     // Parse body first so we can return a normal JSON 400 before opening the stream
-    let body: { message?: string; history?: ChatMessage[]; namespace?: string };
+    let body: {
+      message?: string;
+      history?: ChatMessage[];
+      namespace?: string;
+      sessionId?: string;
+      messageId?: string;
+      userMessageId?: string;
+    };
     try {
       body = await req.json();
     } catch {
-      return new Response(JSON.stringify({ error: 'Invalid JSON body' }), {
+      return new Response(JSON.stringify({ error: { code: 'INVALID_JSON', message: 'Invalid JSON body' } }), {
         status: 400,
         headers: { 'Content-Type': 'application/json' },
       });
     }
 
-    const { message, history = [], namespace } = body;
+    const { message: rawMessage, history = [], namespace, sessionId = 'default', messageId, userMessageId } = body;
 
-    if (!message?.trim()) {
-      return new Response(JSON.stringify({ error: 'message is required' }), {
-        status: 400,
-        headers: { 'Content-Type': 'application/json' },
-      });
+    // 2. Input sanitization
+    const sanitized = sanitizeInput(rawMessage ?? '');
+    if (!sanitized.ok) {
+      return new Response(
+        JSON.stringify({ error: { code: 'INVALID_INPUT', message: sanitized.error } }),
+        { status: 400, headers: { 'Content-Type': 'application/json' } }
+      );
     }
+    const message = sanitized.value;
+
+    // Save user message to history
+    const userMsgId = userMessageId || `user_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    await storage.saveMessage(sessionId, {
+      id: userMsgId,
+      role: 'user',
+      content: message,
+    }).catch(err => console.warn('[createStreamHandler] Failed to save user message:', err));
+
+    const assistantMsgId = messageId || `assistant_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
 
     const encoder = new TextEncoder();
     let isActive = true;
@@ -157,10 +367,12 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
 
         try {
           const pipelineStream = plugin.chatStream(message, history, namespace);
+          let fullReply = '';
 
           for await (const chunk of pipelineStream) {
             if (!isActive) break;
             if (typeof chunk === 'string') {
+              fullReply += chunk;
               enqueue(sseTextFrame(chunk));
             } else if (chunk && typeof chunk === 'object' && 'type' in chunk && (chunk as any).type === 'thinking') {
               enqueue(`data: ${JSON.stringify(chunk)}\n\n`);
@@ -177,12 +389,13 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
                 enqueue(sseObservabilityFrame(responseChunk.trace));
               }
 
+              let uiTransformation = responseChunk?.ui_transformation;
               if (sources.length > 0) {
                 try {
                   // The pipeline already computed ui_transformation inside askStream().
                   // We ONLY fall back to the cheap heuristic transform (no LLM call) when
                   // the pipeline didn't produce one — never call analyzeAndDecide() here.
-                  const uiTransformation =
+                  uiTransformation =
                     responseChunk?.ui_transformation ??
                     UITransformer.transform(message, sources, plugin.getConfig());
 
@@ -193,10 +406,23 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
                   console.warn('[createStreamHandler] UI transformation warning:', transformError);
                   try {
                     const fallback = UITransformer.transform(message, sources, plugin.getConfig());
-                    if (fallback) enqueue(sseUIFrame(fallback));
+                    if (fallback) {
+                      uiTransformation = fallback;
+                      enqueue(sseUIFrame(fallback));
+                    }
                   } catch { /* silent */ }
                 }
               }
+
+              // Save final completed assistant response to history
+              await storage.saveMessage(sessionId, {
+                id: assistantMsgId,
+                role: 'assistant',
+                content: fullReply,
+                sources,
+                uiTransformation,
+                trace: responseChunk?.trace,
+              }).catch(err => console.warn('[createStreamHandler] Failed to save assistant message:', err));
             }
           }
         } catch (streamError) {
@@ -224,20 +450,24 @@ export function createStreamHandler(configOrPlugin?: Partial<RagConfig> | Vector
       }
     });
 
-    return new Response(stream, { headers: SSE_HEADERS });
+    return new Response(stream, { headers: { ...SSE_HEADERS, 'x-message-id': assistantMsgId, 'x-user-message-id': userMsgId } });
   };
 }
 
 /**
  * createIngestHandler — factory for the document ingestion endpoint.
  */
-export function createIngestHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createIngestHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
 
   return async function POST(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
     try {
       const body = await req.json();
       const { documents, namespace } = body as {
@@ -261,13 +491,19 @@ export function createIngestHandler(configOrPlugin?: Partial<RagConfig> | Vector
 /**
  * createHealthHandler — factory for the health-check endpoint.
  */
-export function createHealthHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createHealthHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
+
+  return async function GET(req?: NextRequest) {
+    if (req) {
+      const authResult = await checkAuth(req, onAuthorize);
+      if (authResult) return authResult as any;
+    }
 
-  return async function GET() {
     try {
       const health = await plugin.checkHealth();
       const status = health.allHealthy ? 'ok' : 'degraded';
@@ -286,13 +522,17 @@ export function createHealthHandler(configOrPlugin?: Partial<RagConfig> | Vector
 /**
  * createUploadHandler — factory for the file upload ingestion endpoint.
  */
-export function createUploadHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createUploadHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
 
   return async function POST(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
     try {
       const formData = await req.formData();
       const files = formData.getAll('files') as File[];
@@ -386,13 +626,17 @@ export function createUploadHandler(configOrPlugin?: Partial<RagConfig> | Vector
 /**
  * createSuggestionsHandler — factory for the auto-suggestions endpoint.
  */
-export function createSuggestionsHandler(configOrPlugin?: Partial<RagConfig> | VectorPlugin) {
-  const plugin =
-    configOrPlugin instanceof VectorPlugin
-      ? configOrPlugin
-      : new VectorPlugin(configOrPlugin);
+export function createSuggestionsHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
 
   return async function POST(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
     try {
       const body = await req.json();
       const { query, namespace } = body as {
@@ -413,5 +657,218 @@ export function createSuggestionsHandler(configOrPlugin?: Partial<RagConfig> | V
   };
 }
 
+/**
+ * createHistoryHandler — factory for GET /api/retrivora/history and POST /api/retrivora/history/clear.
+ */
+export function createHistoryHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const storage = new DatabaseStorage(plugin.getConfig());
+  const onAuthorize = options?.onAuthorize;
+
+  return async function handler(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
+    const url = new URL(req.url);
+    const sessionId = url.searchParams.get('sessionId') || 'default';
+
+    if (req.method === 'GET') {
+      try {
+        const history = await storage.getHistory(sessionId);
+        return NextResponse.json({ history });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to fetch history';
+        return NextResponse.json({ error: message }, { status: 500 });
+      }
+    } else if (req.method === 'POST') {
+      try {
+        const body = await req.json().catch(() => ({}));
+        const sid = body.sessionId || sessionId;
+        await storage.clearHistory(sid);
+        return NextResponse.json({ success: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to clear history';
+        return NextResponse.json({ error: message }, { status: 500 });
+      }
+    }
+    return NextResponse.json({ error: 'Method Not Allowed' }, { status: 405 });
+  };
+}
+
+/**
+ * createFeedbackHandler — factory for POST /api/retrivora/feedback.
+ */
+export function createFeedbackHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const storage = new DatabaseStorage(plugin.getConfig());
+  const onAuthorize = options?.onAuthorize;
+
+  return async function handler(req: NextRequest) {
+    const authResult = await checkAuth(req, onAuthorize);
+    if (authResult) return authResult as any;
+
+    if (req.method === 'GET') {
+      try {
+        const url = new URL(req.url);
+        const messageId = url.searchParams.get('messageId');
+        if (!messageId) {
+          const feedbackList = await storage.listFeedback();
+          return NextResponse.json({ feedback: feedbackList });
+        }
+        const feedback = await storage.getFeedback(messageId);
+        return NextResponse.json({ feedback });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to fetch feedback';
+        return NextResponse.json({ error: message }, { status: 500 });
+      }
+    } else if (req.method === 'POST') {
+      try {
+        const body = await req.json();
+        const { messageId, sessionId = 'default', rating, comment } = body as {
+          messageId: string;
+          sessionId?: string;
+          rating: 'thumbs_up' | 'thumbs_down';
+          comment?: string;
+        };
+
+        if (!messageId) {
+          return NextResponse.json({ error: 'messageId is required' }, { status: 400 });
+        }
+        if (!rating) {
+          return NextResponse.json({ error: 'rating is required' }, { status: 400 });
+        }
+
+        await storage.saveFeedback({ messageId, sessionId, rating, comment });
+        return NextResponse.json({ success: true });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to save feedback';
+        return NextResponse.json({ error: message }, { status: 500 });
+      }
+    }
+    return NextResponse.json({ error: 'Method Not Allowed' }, { status: 405 });
+  };
+}
+
+/**
+ * createSessionsHandler — factory for GET /api/retrivora/sessions.
+ */
+export function createSessionsHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const storage = new DatabaseStorage(plugin.getConfig());
+  const onAuthorize = options?.onAuthorize;
+
+  return async function GET(req?: NextRequest) {
+    if (req) {
+      const authResult = await checkAuth(req, onAuthorize);
+      if (authResult) return authResult as any;
+    }
+    void req;
+    try {
+      const sessions = await storage.listSessions();
+      return NextResponse.json({ sessions });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Failed to list sessions';
+      return NextResponse.json({ error: message }, { status: 500 });
+    }
+  };
+}
+
+/**
+ * createRagHandler — factory that returns GET and POST handlers for a catch-all route
+ * (e.g. `src/app/api/retrivora/[[...retrivora]]/route.ts`).
+ */
+export function createRagHandler(
+  configOrPlugin?: Partial<RagConfig> | VectorPlugin,
+  options?: HandlerOptions
+) {
+  const plugin = getOrCreatePlugin(configOrPlugin);
+  const onAuthorize = options?.onAuthorize;
+
+  const chatHandler = createChatHandler(plugin, { onAuthorize });
+  const streamHandler = createStreamHandler(plugin, { onAuthorize });
+  const uploadHandler = createUploadHandler(plugin, { onAuthorize });
+  const healthHandler = createHealthHandler(plugin, { onAuthorize });
+  const suggestionsHandler = createSuggestionsHandler(plugin, { onAuthorize });
+  const historyHandler = createHistoryHandler(plugin, { onAuthorize });
+  const feedbackHandler = createFeedbackHandler(plugin, { onAuthorize });
+  const sessionsHandler = createSessionsHandler(plugin, { onAuthorize });
+
+  async function routePostRequest(req: NextRequest, segment: string) {
+    switch (segment) {
+      case 'chat':
+        return streamHandler(req);
+      case 'chat-sync':
+        return chatHandler(req);
+      case 'upload':
+        return uploadHandler(req);
+      case 'suggestions':
+        return suggestionsHandler(req);
+      case 'health':
+        return healthHandler(req);
+      case 'history':
+      case 'history/clear':
+        return historyHandler(req);
+      case 'feedback':
+        return feedbackHandler(req);
+      default:
+        return NextResponse.json({ error: `Not Found: POST segment "${segment}" not supported.` }, { status: 404 });
+    }
+  }
+
+  async function routeGetRequest(req: NextRequest, segment: string) {
+    switch (segment) {
+      case 'health':
+        return healthHandler(req);
+      case 'history':
+        return historyHandler(req);
+      case 'feedback':
+        return feedbackHandler(req);
+      case 'sessions':
+        return sessionsHandler(req);
+      default:
+        return NextResponse.json({ error: `Method Not Allowed: GET segment "${segment}" not supported.` }, { status: 405 });
+    }
+  }
+
+  async function getSegment(context: any): Promise<string> {
+    const resolvedParams = typeof context?.params?.then === 'function'
+      ? await context.params
+      : context?.params;
+    
+    const segments: string[] = resolvedParams?.retrivora || [];
+    return segments.join('/') || 'chat';
+  }
+
+  return {
+    GET: async (req: NextRequest, context: any) => {
+      try {
+        const segment = await getSegment(context);
+        return await routeGetRequest(req, segment);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'GET Routing failed';
+        return NextResponse.json({ error: msg }, { status: 500 });
+      }
+    },
+    POST: async (req: NextRequest, context: any) => {
+      try {
+        const segment = await getSegment(context);
+        return await routePostRequest(req, segment);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : 'POST Routing failed';
+        return NextResponse.json({ error: msg }, { status: 500 });
+      }
+    }
+  };
+}
+
 // Re-export SSE helpers so host apps can use them in custom handlers
 export { sseFrame, sseTextFrame, sseMetaFrame, sseErrorFrame, sseUIFrame, sseObservabilityFrame };