push new routes

src/index.ts

@@ -11,6 +11,7 @@ import suggestRoute from "./routes/suggest";
 import wardrobeRoute from "./routes/wardrobe";
 import profileRoute from "./routes/profile";
 import avatarRoute from "./routes/avatar";
+import chatRoute from "./routes/chat";
 
 dotenv.config();
 
@@ -41,7 +42,9 @@ app.get("/", (req, res) => {
         profile: "/api/profile",
         upload: "/api/upload",
         suggest: "/api/suggest",
-        wardrobe: "/api/wardrobe"
+        chat: "/api/chat",
+        wardrobe: "/api/wardrobe",
+        avatar: "/api/avatar"
       }
     },
     technologies: [
@@ -164,7 +167,8 @@ const swaggerOptions: swaggerJsdoc.Options = {
       { name: "Authentication", description: "User registration and login" },
       { name: "Profile", description: "User profile management" },
       { name: "Upload", description: "Wardrobe item upload and classification" },
-      { name: "Suggest", description: "AI-powered outfit suggestions" },
+      { name: "Suggest", description: "AI-powered outfit suggestions with wardrobe" },
+      { name: "Chat", description: "Fashion chat without wardrobe" },
       { name: "Avatar", description: "Ready Player Me avatar management" },
       { name: "Health", description: "Health check endpoints" }
     ]
@@ -218,6 +222,7 @@ app.use("/api/upload", uploadRoute);
 app.use("/api/suggest", suggestRoute);
 app.use("/api/wardrobe", wardrobeRoute);
 app.use("/api/avatar", avatarRoute);
+app.use("/api/chat", chatRoute);
 
 const PORT = process.env.PORT || 7860;
 

src/routes/chat.ts

@@ -0,0 +1,216 @@
+import express from "express";
+import axios from "axios";
+import dotenv from "dotenv";
+dotenv.config();
+
+const router = express.Router();
+
+const CHAT_ENDPOINT = process.env.CHAT_ENDPOINT || "";
+const STREAM_ENDPOINT = process.env.STREAM_ENDPOINT || process.env.CHAT_ENDPOINT?.replace('/chat', '/chat/upload/stream') || '';
+const AI_TIMEOUT = 10 * 60 * 1000;
+
+/**
+ * @openapi
+ * /api/chat:
+ *   post:
+ *     summary: Fashion chat without wardrobe (proxied to AI)
+ *     tags: [Chat]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - message
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 description: User's fashion question
+ *               session_id:
+ *                 type: string
+ *                 description: Session ID for conversation context
+ *               images:
+ *                 type: array
+ *                 items:
+ *                   type: string
+ *                 description: Optional array of image URLs or base64 images
+ *     responses:
+ *       200:
+ *         description: Chat response from AI
+ *       400:
+ *         description: Bad request
+ *       500:
+ *         description: Server error
+ */
+router.post("/", async (req, res) => {
+  try {
+    const { message, session_id, images } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ success: false, error: "message is required" });
+    }
+
+    const requestBody: any = {
+      message: message,
+      session_id: session_id || "default",
+    };
+
+    if (images && Array.isArray(images) && images.length > 0) {
+      requestBody.images = images;
+    }
+
+    console.log(`[Chat] Sending request to AI (timeout: ${AI_TIMEOUT / 1000}s)`);
+
+    const response = await axios.post(
+      CHAT_ENDPOINT,
+      requestBody,
+      { 
+        headers: { "Content-Type": "application/json" },
+        timeout: AI_TIMEOUT,
+      }
+    );
+
+    let aiResponse = "";
+    if (typeof response.data === 'string') {
+      aiResponse = response.data;
+    } else if (response.data.response) {
+      aiResponse = response.data.response;
+    } else if (response.data.message) {
+      aiResponse = response.data.message;
+    } else if (response.data.text) {
+      aiResponse = response.data.text;
+    } else {
+      aiResponse = JSON.stringify(response.data);
+    }
+
+    res.json({ 
+      success: true, 
+      response: aiResponse,
+      session_id: session_id || "default"
+    });
+  } catch (error: any) {
+    console.error("Chat error:", error.message);
+    res.status(500).json({ success: false, error: error.message || "Chat failed" });
+  }
+});
+
+/**
+ * @openapi
+ * /api/chat/stream:
+ *   post:
+ *     summary: Fashion chat with streaming response (proxied to AI)
+ *     tags: [Chat]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - message
+ *             properties:
+ *               message:
+ *                 type: string
+ *                 description: User's fashion question
+ *               session_id:
+ *                 type: string
+ *                 description: Session ID for conversation context
+ *               images:
+ *                 type: array
+ *                 items:
+ *                   type: string
+ *                 description: Optional array of image URLs or base64 images
+ *     responses:
+ *       200:
+ *         description: Server-Sent Events stream
+ *         content:
+ *           text/event-stream:
+ *             schema:
+ *               type: string
+ *       400:
+ *         description: Bad request
+ *       500:
+ *         description: Server error
+ */
+router.post("/stream", async (req, res) => {
+  try {
+    const { message, session_id, images } = req.body;
+
+    if (!message) {
+      return res.status(400).json({ success: false, error: "message is required" });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+
+    const FormData = (await import('form-data')).default;
+    const formData = new FormData();
+    formData.append('message', message);
+    formData.append('session_id', session_id || 'default');
+    
+    if (images && Array.isArray(images) && images.length > 0) {
+      images.forEach((image: string) => {
+        formData.append('images', image);
+      });
+    }
+
+    console.log(`[Chat Stream] Calling streaming endpoint: ${STREAM_ENDPOINT} (timeout: ${AI_TIMEOUT / 1000}s)`);
+
+    const response = await axios({
+      method: 'post',
+      url: STREAM_ENDPOINT,
+      data: formData,
+      headers: {
+        ...formData.getHeaders(),
+      },
+      responseType: 'stream',
+      timeout: AI_TIMEOUT,
+    });
+
+    response.data.on('data', (chunk: Buffer) => {
+      const lines = chunk.toString().split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data:')) {
+          try {
+            const jsonStr = line.substring(5).trim();
+            if (jsonStr) {
+              const data = JSON.parse(jsonStr);
+              if (data.type === 'chunk' && data.content) {
+                res.write(`data: ${JSON.stringify({ type: "chunk", content: data.content })}\n\n`);
+              }
+            }
+          } catch (e) {
+          }
+        }
+      }
+    });
+
+    response.data.on('end', () => {
+      console.log(`[Chat Stream] Stream complete`);
+      res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
+      res.end();
+    });
+
+    response.data.on('error', (error: Error) => {
+      console.error('[Chat Stream] Stream error:', error);
+      res.write(`data: ${JSON.stringify({ type: "error", message: error.message })}\n\n`);
+      res.end();
+    });
+
+    req.on('close', () => {
+      console.log('[Chat Stream] Client disconnected');
+      response.data.destroy();
+    });
+
+  } catch (error: any) {
+    console.error("Chat stream error:", error.message);
+    res.write(`data: ${JSON.stringify({ type: "error", message: error.message || "Streaming failed" })}\n\n`);
+    res.end();
+  }
+});
+
+export default router;
+