Merge pull request #326 from traceroot-ai/feat/move_chat_reason_next

feat: move chat reasoning fetching to nextjs

Author: zechengz

rest/config/rate_limit.py

@@ -21,7 +21,6 @@ class RateLimitConfig:
     delete_integrate_limit: str = "20/minute"
     # TODO: Improve this
     get_verify_credentials_limit: str = "7200/minute"
-    get_chat_reasoning_limit: str = "1200/minute"
 
     # Global defaults
     default_limit: str = "120/minute"

rest/routers/explore.py

@@ -247,9 +247,6 @@ def _setup_routes(self):
             self.limiter.limit(self.rate_limit_config.get_chat_history_limit
                                )(self.get_chat_history)
         )
-        self.router.get("/chat/{chat_id}/reasoning")(
-            self.limiter.limit("1200/minute")(self.get_chat_reasoning)
-        )
         self.router.get("/get-line-context-content")(
             self.limiter.limit(self.rate_limit_config.get_line_context_content_limit
                                )(self.get_line_context_content)
@@ -761,27 +758,6 @@ async def get_chat_metadata(
             return {}
         return chat_metadata.model_dump()
 
-    async def get_chat_reasoning(
-        self,
-        request: Request,
-        chat_id: str,
-    ) -> dict[str,
-              Any]:
-        """Get reasoning/thinking data for a specific chat."""
-        # Get user credentials (fake in local mode, real in remote mode)
-        _, _, _ = get_user_credentials(request)
-
-        try:
-            # Query for reasoning data from the database
-            # Look for records with is_streaming=True for the given chat_id
-            reasoning_records = await self.db_client.get_chat_reasoning(chat_id=chat_id)
-
-            return {"chat_id": chat_id, "reasoning": reasoning_records}
-
-        except Exception as e:
-            self.logger.error(f"Error fetching reasoning for chat {chat_id}: {e}")
-            raise HTTPException(status_code=500, detail="Failed to fetch reasoning data")
-
     async def get_github_token(self, user_email: str) -> str | None:
         return await self.db_client.get_integration_token(
             user_email=user_email,

ui/src/app/api/chat/[chat_id]/reasoning/route.ts

@@ -1,5 +1,6 @@
 import { NextResponse } from "next/server";
-import { createBackendAuthHeaders } from "@/lib/server-auth-headers";
+import { connectToDatabase, isMongoDBAvailable } from "@/lib/mongodb";
+import { ReasoningRecordModel } from "@/models/chat";
 
 interface ReasoningData {
   chunk_id: number;
@@ -25,49 +26,46 @@ export async function GET(
       return NextResponse.json(null, { status: 400 });
     }
 
-    const restApiEndpoint = process.env.REST_API_ENDPOINT;
+    // Check if MongoDB is available
+    if (!isMongoDBAvailable()) {
+      return NextResponse.json({
+        chat_id,
+        reasoning: [],
+      });
+    }
 
-    if (restApiEndpoint) {
-      try {
-        // Get auth headers (automatically uses Clerk's auth() and currentUser())
-        const headers = await createBackendAuthHeaders();
+    try {
+      // Connect to MongoDB
+      await connectToDatabase();
 
-        const apiUrl = `${restApiEndpoint}/v1/explore/chat/${encodeURIComponent(chat_id)}/reasoning`;
-        const apiResponse = await fetch(apiUrl, {
-          method: "GET",
-          headers,
-        });
+      // Query reasoning_streams collection
+      const reasoningRecords = await ReasoningRecordModel.find({
+        chat_id,
+      })
+        .sort({ chunk_id: 1, timestamp: 1 })
+        .lean();
 
-        if (!apiResponse.ok) {
-          if (apiResponse.status === 404) {
-            // Return empty reasoning data for 404 instead of null
-            return NextResponse.json({
-              chat_id,
-              reasoning: [],
-            });
-          }
-          throw new Error(
-            `REST API call failed with status: ${apiResponse.status}`,
-          );
-        }
+      // Transform the data to match the expected format
+      const reasoning: ReasoningData[] = reasoningRecords.map((doc) => ({
+        chunk_id: doc.chunk_id,
+        content: doc.content,
+        status: doc.status,
+        timestamp: doc.timestamp.toISOString(),
+        trace_id: doc.trace_id,
+      }));
 
-        const apiData: ReasoningResponse = await apiResponse.json();
-        return NextResponse.json(apiData);
-      } catch (apiError) {
-        console.error("REST API call failed:", apiError);
-        // Fall back to empty reasoning response if REST API fails
-        return NextResponse.json({
-          chat_id,
-          reasoning: [],
-        });
-      }
+      return NextResponse.json({
+        chat_id,
+        reasoning,
+      });
+    } catch (dbError) {
+      console.error("MongoDB query failed:", dbError);
+      // Fall back to empty reasoning response if MongoDB query fails
+      return NextResponse.json({
+        chat_id,
+        reasoning: [],
+      });
     }
-
-    // Fallback to empty reasoning response when REST_API_ENDPOINT is not set
-    return NextResponse.json({
-      chat_id,
-      reasoning: [],
-    });
   } catch (error) {
     console.error("Get Chat Reasoning API Error:", error);
     return NextResponse.json(null, { status: 500 });

ui/src/models/chat.ts

@@ -141,3 +141,38 @@ ChatMetadataSchema.index({ chat_id: 1 });
 export const ChatMetadataModel: Model<IChatMetadata> =
   mongoose.models.ChatMetadataModel ||
   mongoose.model<IChatMetadata>("ChatMetadataModel", ChatMetadataSchema);
+
+// Mongoose model for reasoning_streams collection
+export interface IReasoningRecord {
+  chat_id: string;
+  chunk_id: number;
+  content: string;
+  status: string;
+  timestamp: Date;
+  trace_id?: string;
+}
+
+const ReasoningRecordSchema = new Schema<IReasoningRecord>(
+  {
+    chat_id: { type: String, required: true },
+    chunk_id: { type: Number, required: true },
+    content: { type: String, required: true },
+    status: { type: String, required: true },
+    timestamp: { type: Date, required: true },
+    trace_id: { type: String, required: false },
+  },
+  {
+    collection: process.env.DB_REASONING_COLLECTION || "reasoning_streams",
+    versionKey: false,
+  },
+);
+
+// Index on chat_id for fast lookups
+ReasoningRecordSchema.index({ chat_id: 1 });
+
+export const ReasoningRecordModel: Model<IReasoningRecord> =
+  mongoose.models.ReasoningRecordModel ||
+  mongoose.model<IReasoningRecord>(
+    "ReasoningRecordModel",
+    ReasoningRecordSchema,
+  );