Spaces:

adaptsum
/

demo

Runtime error

App Files Files Community

chansung commited on Mar 3

Commit

2190187

verified ·

1 Parent(s): 37da0c0

Upload folder using huggingface_hub

Browse files

Files changed (12) hide show

.gitignore +2 -0
README.md +24 -0
standalone/favicon-32x32.png +0 -0
standalone/index.html +8 -2
standalone/script.js +132 -36
standalone/server/main.py +10 -220
standalone/server/stream/anthropic.py +95 -0
standalone/server/stream/google.py +102 -0
standalone/server/stream/huggingface.py +101 -0
standalone/server/stream/openai.py +101 -0
standalone/server/stream/utils.py +66 -0
standalone/style.css +235 -156

.gitignore CHANGED Viewed

@@ -1,3 +1,5 @@
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

+.DS_Store
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

README.md CHANGED Viewed

@@ -275,3 +275,27 @@ $ python main.py # or gradio main.py
 # Acknowledgments
 This is a project built during the Vertex sprints held by Google's ML Developer Programs team. We are thankful to be granted good amount of GCP credits to do this project.

 # Acknowledgments
 This is a project built during the Vertex sprints held by Google's ML Developer Programs team. We are thankful to be granted good amount of GCP credits to do this project.
+# AdaptSum
+AdaptSum stands for Adaptive Summarization. This project focuses on developing an LLM-powered system for dynamic summarization. Instead of generating entirely new summaries with each update, the system intelligently identifies and modifies only the necessary parts of the existing summary. This approach aims to create a more efficient and fluid summarization process within a continuous chat interaction with an LLM.
+# Instructions
+1. Install dependencies
+```shell
+$ pip install requirements.txt
+```
+2. Setup Gemini API Key
+```shell
+$ export GEMINI_API_KEY=xxxxx
+```
+> note that GEMINI API KEY should be obtained from Google AI Studio. Vertex AI is not supported at the moment (this is because Gemini SDK does not provide file uploading functionality for Vertex AI usage now).
+3. Run Gradio app
+```shell
+$ python main.py # or gradio main.py
+```
+# Acknowledgments
+This is a project built during the Vertex sprints held by Google's ML Developer Programs team. We are thankful to be granted good amount of GCP credits to do this project.

standalone/favicon-32x32.png ADDED Viewed

standalone/index.html CHANGED Viewed

@@ -8,6 +8,7 @@
   <!-- Include marked.js for Markdown rendering -->
   <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
   <link rel="stylesheet" href="style.css">
 </head>
 <body>
   <div class="app-container">
@@ -19,7 +20,7 @@
         <button class="new-session-btn" id="newSessionBtn">
             <img src="new-indicator.svg" alt="Icon" class="svg-icon">
         </button>
-        <button id="toggleLayoutBtn"><img src="vertical-layout.svg" alt="Icon" class="svg-icon"></button>
       </div>
       <!-- <h3>Chat History</h3> -->
       <ul id="sessionList"></ul>
@@ -66,7 +67,7 @@
         <div id="fileAttachments" class="file-attachments"></div>
         <div class="input-row">
           <button id="attachBtn" class="attach-button">+</button>
-          <input type="file" id="fileInput" multiple accept="image/*,.pdf">
           <textarea id="chatInput" placeholder="Ask Anything"></textarea>
           <button id="sendBtn">
             <img src="send.svg" alt="Icon" class="svg-icon-non-white">
@@ -122,6 +123,11 @@
                   <option value="gemini-2.0-flash">Gemini 2.0 Flash</option>
                   <option value="gemini-2.0-flash-lite">Gemini 2.0 Flash Lite</option>
                 </optgroup>
               </select>
             </div>
           </div>

   <!-- Include marked.js for Markdown rendering -->
   <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
   <link rel="stylesheet" href="style.css">
+  <link rel="icon" type="image/png" href="favicon-32x32.png">
 </head>
 <body>
   <div class="app-container">
         <button class="new-session-btn" id="newSessionBtn">
             <img src="new-indicator.svg" alt="Icon" class="svg-icon">
         </button>
+        <button id="toggleLayoutBtn"><img src="vertical.svg" alt="Icon" class="svg-icon"></button>
       </div>
       <!-- <h3>Chat History</h3> -->
       <ul id="sessionList"></ul>
         <div id="fileAttachments" class="file-attachments"></div>
         <div class="input-row">
           <button id="attachBtn" class="attach-button">+</button>
+          <input type="file" id="fileInput" multiple accept="application/pdf">
           <textarea id="chatInput" placeholder="Ask Anything"></textarea>
           <button id="sendBtn">
             <img src="send.svg" alt="Icon" class="svg-icon-non-white">
                   <option value="gemini-2.0-flash">Gemini 2.0 Flash</option>
                   <option value="gemini-2.0-flash-lite">Gemini 2.0 Flash Lite</option>
                 </optgroup>
+                <optgroup label="Hugging Face">
+                  <option value="huggingface/meta-llama/Llama-3.3-70B-Instruct">Llama 3.3 70B Instruct</option>
+                  <option value="huggingface/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B">DeepSeek R1 Distill Qwen 32B</option>
+                  <option value="huggingface/Qwen/Qwen2.5-72B-Instruct">Qwen 2.5 72B Instruct</option>
+                </optgroup>
               </select>
             </div>
           </div>

standalone/script.js CHANGED Viewed

@@ -3,15 +3,30 @@
 const MODEL_NAME = "gpt-4o-mini";
 // Modified to scroll the current card to the bottom after updating the message.
-function updateLastMessage(content) {
   const session = sessions[currentSessionIndex];
-  session.messages[session.messages.length - 1].aiResponse = content;
   renderCurrentSession();
-  // Auto-scroll the current card to the bottom:
-  const cards = document.querySelectorAll('.card');
-  if (cards[currentCardIndex]) {
-    cards[currentCardIndex].scrollTop = cards[currentCardIndex].scrollHeight;
-  }
 }
 // ----------------- Layout and Navigation -----------------
@@ -66,14 +81,14 @@ let currentSessionIndex = 0;
 let currentCardIndex = 0;
 function initSessions() {
   sessions.push({
-    id: Date.now(),
     name: "Chat Session 1",
     title: "Chat Session 1",
     messages: [],
     summary: "# Chat Summary\n\nThis is the default summary for Chat Session 1.",
     settings: {
       temperature: 0.7,
-      maxTokens: 256,
       persona: "professional",
       model: "gpt-4o-mini" // <-- new property
     }
@@ -111,14 +126,14 @@ function renderSessionList() {
 }
 document.getElementById('newSessionBtn').addEventListener('click', () => {
     const newSession = {
-        id: Date.now(),
         name: "Chat Session " + (sessions.length + 1),
         title: "Chat Session " + (sessions.length + 1),
         messages: [],
         summary: "# Chat Summary\n\nThis is the default summary for Chat Session " + (sessions.length + 1) + ".",
         settings: {
             temperature: 0.7,
-            maxTokens: 256,
             persona: "professional",
             model: "gpt-4o-mini" // <-- default model
         }
@@ -155,7 +170,7 @@ function renderCurrentSession() {
     if (message.attachments && message.attachments.length > 0) {
       attachmentHTML = `
         <div class="vertical-file-list">
-          ${message.attachments.map(name => `<div class="file-item-vertical">${name}</div>`).join("")}
         </div>
       `;
     }
@@ -224,6 +239,25 @@ function processMessagesInContainer(container) {
   container.querySelectorAll('.message').forEach(processMessage);
 }
 // ----------------- Adding Conversation & Stream API Call -----------------
 const attachedFiles = [];
 async function addConversation(userText) {
   if (userText.trim() === '' && attachedFiles.length === 0) return;
@@ -232,20 +266,20 @@ async function addConversation(userText) {
   sessions[currentSessionIndex].messages.push({
     userText,
     aiResponse: "",
-    attachments: attachedFiles.map(file => file.name), // Store file names
-    model: sessions[currentSessionIndex].settings.model
   });
   // Clear attachments after sending
   clearFileAttachments();
   renderCurrentSession();
   const conversation = [];
   sessions[currentSessionIndex].messages.forEach(msg => {
-    conversation.push({ role: "user", content: msg.userText });
     if (msg.aiResponse) {
-      conversation.push({ role: "assistant", content: msg.aiResponse });
     }
   });
@@ -314,10 +348,12 @@ attachBtn.addEventListener('click', () => {
 fileInput.addEventListener('change', () => {
   for (const file of fileInput.files) {
     attachedFiles.push(file);
   }
   fileInput.value = "";
   updateFileAttachments();
 });
 function updateFileAttachments() {
   fileAttachments.innerHTML = "";
   attachedFiles.forEach((file, index) => {
@@ -475,36 +511,42 @@ async function callLLMStream(conversation) {
   if (model.startsWith("gpt-4o")) {
     // Call OpenAI endpoint
-    return callOpenAIStream(conversation, model, temperature, maxTokens);
   } else if (model.startsWith("claude")) {
     // Call Anthropic endpoint
-    return callAnthropicStream(conversation, model, temperature, maxTokens);
   } else if (model.startsWith("gemini")) {
     // Call Google endpoint
-    return callGoogleStream(conversation, model, temperature, maxTokens);
   } else {
     throw new Error("Unsupported model: " + model);
   }
 }
-async function callOpenAIStream(conversation) {
   const response = await fetch("http://127.0.0.1:8000/openai_stream", {
     method: "POST",
     headers: {
-      "Content-Type": "application/json"
       // Remove the Authorization header since the Python backend handles the API key.
     },
     body: JSON.stringify({
       conversation: conversation,
       temperature: sessions[currentSessionIndex].settings.temperature,
       max_tokens: sessions[currentSessionIndex].settings.maxTokens,
-      model: MODEL_NAME
     })
   });
   const reader = response.body.getReader();
   const decoder = new TextDecoder("utf-8");
   let done = false;
   let aiMessage = "";
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
@@ -523,31 +565,33 @@ async function callOpenAIStream(conversation) {
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
-          updateLastMessage(aiMessage);
         }
       } catch (err) {
         console.error("Stream parsing error:", err);
       }
     }
   }
   return aiMessage;
 }
-async function callAnthropicStream(conversation, model, temperature, maxTokens) {
   model = model.toLowerCase().replace(/\s+/g, '-').replace(/\./g, '-');
   console.log(`Calling Anthropic API with model: ${model}`);
   const response = await fetch("http://127.0.0.1:8000/anthropic_stream", {
     method: "POST",
     headers: {
-      "Content-Type": "application/json"
     },
     body: JSON.stringify({
       messages: conversation,
       temperature: temperature,
       max_tokens: maxTokens,
-      model: model + "-latest"
     })
   });
@@ -556,6 +600,7 @@ async function callAnthropicStream(conversation, model, temperature, maxTokens)
   let done = false;
   let aiMessage = "";
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
@@ -574,32 +619,33 @@ async function callAnthropicStream(conversation, model, temperature, maxTokens)
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
-          updateLastMessage(aiMessage);
         }
       } catch (err) {
         console.error("Anthropic stream parsing error:", err);
       }
     }
   }
   return aiMessage;
 }
-async function callGoogleStream(conversation, model, temperature, maxTokens) {
   // Convert conversation messages to Gemini's "contents" format.
   model = model.toLowerCase().replace(/\s+/g, '-');
   console.log(model);
   const response = await fetch("http://127.0.0.1:8000/gemini_stream", {
     method: "POST",
     headers: {
-      "Content-Type": "application/json"
     },
     body: JSON.stringify({
       messages: conversation,
       temperature: temperature,
       max_tokens: maxTokens,
-      model: model
     })
   });
@@ -607,7 +653,8 @@ async function callGoogleStream(conversation, model, temperature, maxTokens) {
   const decoder = new TextDecoder("utf-8");
   let done = false;
   let aiMessage = "";
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
@@ -626,18 +673,67 @@ async function callGoogleStream(conversation, model, temperature, maxTokens) {
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
-          updateLastMessage(aiMessage);
         }
       } catch (err) {
         console.error("Gemini stream parsing error:", err);
       }
     }
   }
   return aiMessage;
 }
 // ----------------- Initialization -----------------
 initSessions();

 const MODEL_NAME = "gpt-4o-mini";
 // Modified to scroll the current card to the bottom after updating the message.
+function updateLastMessage(content, isStreaming = false) {
   const session = sessions[currentSessionIndex];
+  const cursorHTML = `<span class="blinking-cursor"></span>`;
+  session.messages[session.messages.length - 1].aiResponse = isStreaming ? content + cursorHTML : content;
+  // Get the current scroll position of the last card before re-rendering
+  const lastCardBefore = document.querySelector('.card:last-child');
+  const prevScrollTop = lastCardBefore ? lastCardBefore.scrollTop : 0;
+  // Re-render the conversation
   renderCurrentSession();
+  // Use requestAnimationFrame to wait until the new DOM is laid out
+  requestAnimationFrame(() => {
+    const lastCardAfter = document.querySelector('.card:last-child');
+    if (lastCardAfter) {
+      if (isStreaming) {
+        lastCardAfter.scrollTop = lastCardAfter.scrollHeight;
+      } else {
+        // Restore the previous scroll position
+        lastCardAfter.scrollTop = prevScrollTop;
+      }
+    }
+  });
 }
 // ----------------- Layout and Navigation -----------------
 let currentCardIndex = 0;
 function initSessions() {
   sessions.push({
+    id: Date.now() + '-' + Math.random().toString(36).substr(2, 9),
     name: "Chat Session 1",
     title: "Chat Session 1",
     messages: [],
     summary: "# Chat Summary\n\nThis is the default summary for Chat Session 1.",
     settings: {
       temperature: 0.7,
+      maxTokens: 1024,
       persona: "professional",
       model: "gpt-4o-mini" // <-- new property
     }
 }
 document.getElementById('newSessionBtn').addEventListener('click', () => {
     const newSession = {
+        id: Date.now() + '-' + Math.random().toString(36).substr(2, 9),
         name: "Chat Session " + (sessions.length + 1),
         title: "Chat Session " + (sessions.length + 1),
         messages: [],
         summary: "# Chat Summary\n\nThis is the default summary for Chat Session " + (sessions.length + 1) + ".",
         settings: {
             temperature: 0.7,
+            maxTokens: 1024,
             persona: "professional",
             model: "gpt-4o-mini" // <-- default model
         }
     if (message.attachments && message.attachments.length > 0) {
       attachmentHTML = `
         <div class="vertical-file-list">
+          ${message.attachments.map(file => `<div class="file-item-vertical">${file.path}</div>`).join("")}
         </div>
       `;
     }
   container.querySelectorAll('.message').forEach(processMessage);
 }
 // ----------------- Adding Conversation & Stream API Call -----------------
+async function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      // Get the base64 string (remove the data URL prefix)
+      const base64 = reader.result.split(',')[1];
+      resolve({
+        name: file.name,
+        path: file.webkitRelativePath || file.path || file.name,
+        size: file.size,
+        type: file.type,
+        content: base64
+      });
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
 const attachedFiles = [];
 async function addConversation(userText) {
   if (userText.trim() === '' && attachedFiles.length === 0) return;
   sessions[currentSessionIndex].messages.push({
     userText,
     aiResponse: "",
+    attachments: await Promise.all(attachedFiles.map(fileToBase64)),
+    model: sessions[currentSessionIndex].settings.model,
+    sessionId: sessions[currentSessionIndex].id
   });
   // Clear attachments after sending
   clearFileAttachments();
   renderCurrentSession();
   const conversation = [];
   sessions[currentSessionIndex].messages.forEach(msg => {
+    conversation.push({ role: "user", content: msg.userText, attachments: msg.attachments, sessionId: msg.sessionId });
     if (msg.aiResponse) {
+      conversation.push({ role: "assistant", content: msg.aiResponse, sessionId: msg.sessionId });
     }
   });
 fileInput.addEventListener('change', () => {
   for (const file of fileInput.files) {
     attachedFiles.push(file);
+    // Display the file path in the console
   }
   fileInput.value = "";
   updateFileAttachments();
 });
 function updateFileAttachments() {
   fileAttachments.innerHTML = "";
   attachedFiles.forEach((file, index) => {
   if (model.startsWith("gpt-4o")) {
     // Call OpenAI endpoint
+    return callOpenAIStream(session.id, conversation, model, temperature, maxTokens);
   } else if (model.startsWith("claude")) {
     // Call Anthropic endpoint
+    return callAnthropicStream(session.id, conversation, model, temperature, maxTokens);
   } else if (model.startsWith("gemini")) {
     // Call Google endpoint
+    return callGoogleStream(session.id, conversation, model, temperature, maxTokens);
+  } else if (model.startsWith("huggingface")) {
+    // Call Hugging Face endpoint
+    return callHuggingFaceStream(session.id, conversation, model.replace("huggingface/", ""), temperature, maxTokens);
   } else {
     throw new Error("Unsupported model: " + model);
   }
 }
+async function callOpenAIStream(sessionId, conversation) {
   const response = await fetch("http://127.0.0.1:8000/openai_stream", {
     method: "POST",
     headers: {
+      "Content-Type": "application/json",
+      "X-Session-ID": sessionId
       // Remove the Authorization header since the Python backend handles the API key.
     },
     body: JSON.stringify({
       conversation: conversation,
       temperature: sessions[currentSessionIndex].settings.temperature,
       max_tokens: sessions[currentSessionIndex].settings.maxTokens,
+      model: MODEL_NAME,
     })
   });
   const reader = response.body.getReader();
   const decoder = new TextDecoder("utf-8");
   let done = false;
   let aiMessage = "";
+  updateLastMessage(aiMessage, true);
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
+          updateLastMessage(aiMessage, true);
         }
       } catch (err) {
         console.error("Stream parsing error:", err);
       }
     }
   }
+  updateLastMessage(aiMessage, false);
   return aiMessage;
 }
+async function callAnthropicStream(sessionId, conversation, model, temperature, maxTokens) {
   model = model.toLowerCase().replace(/\s+/g, '-').replace(/\./g, '-');
   console.log(`Calling Anthropic API with model: ${model}`);
   const response = await fetch("http://127.0.0.1:8000/anthropic_stream", {
     method: "POST",
     headers: {
+      "Content-Type": "application/json",
+      "X-Session-ID": sessionId
     },
     body: JSON.stringify({
       messages: conversation,
       temperature: temperature,
       max_tokens: maxTokens,
+      model: model + "-latest",
     })
   });
   let done = false;
   let aiMessage = "";
+  updateLastMessage(aiMessage, true);
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
+          updateLastMessage(aiMessage, true);
         }
       } catch (err) {
         console.error("Anthropic stream parsing error:", err);
       }
     }
   }
+  updateLastMessage(aiMessage, false);
   return aiMessage;
 }
+async function callGoogleStream(sessionId, conversation, model, temperature, maxTokens) {
   // Convert conversation messages to Gemini's "contents" format.
   model = model.toLowerCase().replace(/\s+/g, '-');
   console.log(model);
   const response = await fetch("http://127.0.0.1:8000/gemini_stream", {
     method: "POST",
     headers: {
+      "Content-Type": "application/json",
+      "X-Session-ID": sessionId
     },
     body: JSON.stringify({
       messages: conversation,
       temperature: temperature,
       max_tokens: maxTokens,
+      model: model,
     })
   });
   const decoder = new TextDecoder("utf-8");
   let done = false;
   let aiMessage = "";
+  updateLastMessage(aiMessage, true);
   while (!done) {
     const { value, done: doneReading } = await reader.read();
     done = doneReading;
         const delta = parsed.choices[0].delta.content;
         if (delta) {
           aiMessage += delta;
+          updateLastMessage(aiMessage, true);
         }
       } catch (err) {
         console.error("Gemini stream parsing error:", err);
       }
     }
   }
+  updateLastMessage(aiMessage, false);
   return aiMessage;
 }
+async function callHuggingFaceStream(sessionId, conversation, model, temperature, maxTokens) {
+  console.log(`Calling Hugging Face API with model: ${model}`);
+  const response = await fetch("http://127.0.0.1:8000/huggingface_stream", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Session-ID": sessionId
+    },
+    body: JSON.stringify({
+      messages: conversation,
+      temperature: temperature,
+      max_tokens: maxTokens,
+      model: model,
+    })
+  });
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8");
+  let done = false;
+  let aiMessage = "";
+  updateLastMessage(aiMessage, true);
+  while (!done) {
+    const { value, done: doneReading } = await reader.read();
+    done = doneReading;
+    const chunk = decoder.decode(value);
+    const lines = chunk.split("\n").filter(line => line.trim().startsWith("data:"));
+    for (const line of lines) {
+      const dataStr = line.replace(/^data:\s*/, "");
+      if (dataStr === "[DONE]") {
+        done = true;
+        break;
+      }
+      try {
+        const parsed = JSON.parse(dataStr);
+        const delta = parsed.choices[0].delta.content;
+        if (delta) {
+          aiMessage += delta;
+          updateLastMessage(aiMessage, true);
+        }
+      } catch (err) {
+        console.error("Hugging Face stream parsing error:", err);
+      }
+    }
+  }
+  updateLastMessage(aiMessage, false);
+  return aiMessage;
+}
 // ----------------- Initialization -----------------
 initSessions();

standalone/server/main.py CHANGED Viewed

@@ -1,10 +1,15 @@
 import json
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
-import httpx
 app = FastAPI()
 # Allow all origins for testing (adjust for production)
 app.add_middleware(
@@ -17,222 +22,7 @@ app.add_middleware(
 # Replace these with secure methods in production
 import os
-OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
-ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
-GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
-MODEL_NAME = "gpt-4o-mini"
-@app.post("/openai_stream")
-async def openai_stream(request: Request):
-    try:
-        body = await request.json()
-    except Exception as e:
-        raise HTTPException(status_code=400, detail="Invalid JSON payload") from e
-    conversation = body.get("conversation")
-    if not conversation:
-        raise HTTPException(status_code=400, detail="Missing 'conversation' in payload")
-    temperature = body.get("temperature", 0.7)
-    max_tokens = body.get("max_tokens", 256)
-    model = body.get("model", MODEL_NAME)
-    # Using OpenAI's SDK instead of direct API calls
-    from openai import AsyncOpenAI
-    # Initialize the client with the API key
-    client = AsyncOpenAI(api_key=OPENAI_API_KEY)
-    async def event_generator():
-        try:
-            print(f"Starting stream for model: {model}, temperature: {temperature}, max_tokens: {max_tokens}")
-            line_count = 0
-            # Use the SDK to create a streaming completion
-            stream = await client.chat.completions.create(
-                model=model,
-                messages=conversation,
-                temperature=temperature,
-                max_tokens=max_tokens,
-                stream=True
-            )
-            async for chunk in stream:
-                if chunk.choices and chunk.choices[0].delta.content is not None:
-                    content = chunk.choices[0].delta.content
-                    line_count += 1
-                    if line_count % 10 == 0:
-                        print(f"Processed {line_count} stream chunks")
-                    # Format the response in the same way as before
-                    response_json = json.dumps({
-                        "choices": [{"delta": {"content": content}}]
-                    })
-                    yield f"data: {response_json}\n\n"
-            # Send the [DONE] marker
-            print("Stream completed successfully")
-            yield "data: [DONE]\n\n"
-        except Exception as e:
-            print(f"Error during streaming: {str(e)}")
-            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
-        finally:
-            print(f"Stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
-    print("Returning StreamingResponse to client")
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
-@app.post("/gemini_stream")
-async def gemini_stream(request: Request):
-    """
-    Stream responses from Google's Gemini model using the Gemini SDK.
-    """
-    body = await request.json()
-    conversation = body.get("messages", [])
-    temperature = body.get("temperature", 0.7)
-    max_tokens = body.get("max_tokens", 256)
-    model = body.get("model", "gemini-pro")  # Default to gemini-pro model
-    # Using Google's Generative AI SDK
-    import google.generativeai as genai
-    from google.generativeai.types import HarmCategory, HarmBlockThreshold
-    # Initialize the client with the API key
-    genai.configure(api_key=GOOGLE_API_KEY)
-    # Convert OpenAI message format to Gemini format
-    gemini_messages = []
-    for msg in conversation:
-        role = "user" if msg["role"] == "user" else "model"
-        gemini_messages.append({"role": role, "parts": [msg["content"]]})
-    async def event_generator():
-        try:
-            print(f"Starting Gemini stream for model: {model}, temperature: {temperature}, max_tokens: {max_tokens}")
-            line_count = 0
-            # Create a Gemini model instance
-            gemini_model = genai.GenerativeModel(
-                model_name=model,
-                generation_config={
-                    "temperature": temperature,
-                    "max_output_tokens": max_tokens,
-                    "top_p": 0.95,
-                },
-                safety_settings={
-                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
-                }
-            )
-            # Start the streaming response
-            response = gemini_model.generate_content(
-                gemini_messages,
-                stream=True
-            )
-            # Fix: Use synchronous iteration instead of async for
-            for chunk in response:
-                if hasattr(chunk, 'text') and chunk.text:
-                    content = chunk.text
-                    line_count += 1
-                    if line_count % 10 == 0:
-                        print(f"Processed {line_count} Gemini stream chunks")
-                    # Format the response to match OpenAI format for client compatibility
-                    response_json = json.dumps({
-                        "choices": [{"delta": {"content": content}}]
-                    })
-                    yield f"data: {response_json}\n\n"
-            # Send the [DONE] marker
-            print("Gemini stream completed successfully")
-            yield "data: [DONE]\n\n"
-        except Exception as e:
-            print(f"Error during Gemini streaming: {str(e)}")
-            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
-        finally:
-            print(f"Gemini stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
-    print("Returning StreamingResponse from Gemini to client")
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
-@app.post("/anthropic_stream")
-async def anthropic_stream(request: Request):
-    """
-    Stream responses from Anthropic's Claude models.
-    """
-    print("Received request for Anthropic streaming")
-    # Parse the request body
-    body = await request.json()
-    messages = body.get("messages", [])
-    temperature = body.get("temperature", 0.7)
-    max_tokens = body.get("max_tokens", 1024)
-    model = body.get("model", "claude-3-opus-20240229")
-    # Load Anthropic API key from environment
-    anthropic_api_key = ANTHROPIC_API_KEY #os.environ.get("ANTHROPIC_API_KEY")
-    if not anthropic_api_key:
-        return JSONResponse(
-            status_code=500,
-            content={"error": "ANTHROPIC_API_KEY not found in environment variables"}
-        )
-    # Convert messages to Anthropic format
-    anthropic_messages = []
-    for msg in messages:
-        role = "assistant" if msg.get("role") == "assistant" else "user"
-        content = msg.get("content", "")
-        anthropic_messages.append({"role": role, "content": content})
-    line_count = 0
-    async def event_generator():
-        try:
-            import anthropic
-            # Initialize Anthropic client
-            client = anthropic.Anthropic(api_key=anthropic_api_key)
-            # Start the streaming response
-            with client.messages.stream(
-                model=model,
-                messages=anthropic_messages,
-                max_tokens=max_tokens,
-                temperature=temperature
-            ) as stream:
-                for chunk in stream:
-                    if hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text') and chunk.delta.text:
-                        content = chunk.delta.text
-                        nonlocal line_count
-                        line_count += 1
-                        if line_count % 10 == 0:
-                            print(f"Processed {line_count} Anthropic stream chunks")
-                        # Format the response to match OpenAI format for client compatibility
-                        response_json = json.dumps({
-                            "choices": [{"delta": {"content": content}}]
-                        })
-                        yield f"data: {response_json}\n\n"
-            # Send the [DONE] marker
-            print("Anthropic stream completed successfully")
-            yield "data: [DONE]\n\n"
-        except Exception as e:
-            print(f"Error during Anthropic streaming: {str(e)}")
-            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
-        finally:
-            print(f"Anthropic stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
-    print("Returning StreamingResponse from Anthropic to client")
-    return StreamingResponse(event_generator(), media_type="text/event-stream")
 @app.post("/summarize_openai")
 async def summarize_openai(request: Request):
@@ -250,7 +40,7 @@ async def summarize_openai(request: Request):
     # Load the prompt from prompts.toml
     import tomli
-    with open("configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt
@@ -306,7 +96,7 @@ async def summarize_anthropic(request: Request):
     # Load the prompt from prompts.toml
     import tomli
-    with open("configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt
@@ -361,7 +151,7 @@ async def summarize_google(request: Request):
     # Load the prompt from prompts.toml
     import tomli
-    with open("configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt

 import json
+import httpx
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import StreamingResponse
 from fastapi.middleware.cors import CORSMiddleware
+from stream import openai, anthropic, google, huggingface
 app = FastAPI()
+app.include_router(openai.router)
+app.include_router(anthropic.router)
+app.include_router(google.router)
+app.include_router(huggingface.router)
 # Allow all origins for testing (adjust for production)
 app.add_middleware(
 # Replace these with secure methods in production
 import os
+from collections import defaultdict
 @app.post("/summarize_openai")
 async def summarize_openai(request: Request):
     # Load the prompt from prompts.toml
     import tomli
+    with open("../../configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt
     # Load the prompt from prompts.toml
     import tomli
+    with open("../../configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt
     # Load the prompt from prompts.toml
     import tomli
+    with open("../../configs/prompts.toml", "rb") as f:
         prompts_config = tomli.load(f)
     # Get the prompt and system prompt

standalone/server/stream/anthropic.py ADDED Viewed

	@@ -0,0 +1,95 @@

+import os
+import json
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi import APIRouter
+from anthropic import Anthropic
+from .utils import handle_attachments
+router = APIRouter()
+ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY")
+attachments_in_anthropic = {}
+@router.post("/anthropic_stream")
+async def anthropic_stream(request: Request):
+    """
+    Stream responses from Anthropic's Claude models.
+    """
+    print("Received request for Anthropic streaming")
+    # Parse the request body
+    body = await request.json()
+    conversation = body.get("messages", [])
+    temperature = body.get("temperature", 0.7)
+    max_tokens = body.get("max_tokens", 1024)
+    model = body.get("model", "claude-3-opus-20240229")
+    # Get session ID from the request
+    session_id = request.headers.get("X-Session-ID")
+    if session_id not in attachments_in_anthropic: attachments_in_anthropic[session_id] = {}
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing 'session_id' in payload")
+    # Handle file attachments if present
+    conversation = await handle_attachments(session_id, conversation, remove_content=False)
+    anthropic_messages = []
+    for msg in conversation:
+        role = "user" if msg["role"] == "user" else "assistant"
+        pdf_base64s = []
+        if "attachments" in msg:
+            for attachment in msg["attachments"]:
+                if attachment["file_path"].endswith(".pdf"):
+                    print(attachment)
+                    if attachment["file_path"] not in attachments_in_anthropic[session_id]:
+                        pdf_base64 = {"type": "document", "source": {"type": "base64", "media_type": "application/pdf", "data": attachment["content"]}}
+                        pdf_base64s.append(pdf_base64)
+                        attachments_in_anthropic[session_id][attachment["name"]] = pdf_base64
+                    else:
+                        pdf_base64s.append(attachments_in_anthropic[session_id][attachment["name"]])
+        anthropic_messages.append({"role": role, "content": pdf_base64s + [{"type": "text", "text": msg["content"]}]})
+    line_count = 0
+    async def event_generator():
+        try:
+            # Initialize Anthropic client
+            client = Anthropic(api_key=ANTHROPIC_API_KEY)
+            # Start the streaming response
+            with client.messages.stream(
+                model=model,
+                messages=anthropic_messages,
+                max_tokens=max_tokens,
+                temperature=temperature
+            ) as stream:
+                for chunk in stream:
+                    if hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text') and chunk.delta.text:
+                        content = chunk.delta.text
+                        nonlocal line_count
+                        line_count += 1
+                        if line_count % 10 == 0:
+                            print(f"Processed {line_count} Anthropic stream chunks")
+                        # Format the response to match OpenAI format for client compatibility
+                        response_json = json.dumps({
+                            "choices": [{"delta": {"content": content}}]
+                        })
+                        yield f"data: {response_json}\n\n"
+            # Send the [DONE] marker
+            print("Anthropic stream completed successfully")
+            yield "data: [DONE]\n\n"
+        except Exception as e:
+            print(f"Error during Anthropic streaming: {str(e)}")
+            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
+        finally:
+            print(f"Anthropic stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
+    print("Returning StreamingResponse from Anthropic to client")
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

standalone/server/stream/google.py ADDED Viewed

	@@ -0,0 +1,102 @@

+import os
+import json
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi import APIRouter
+from google.genai import types
+from google import genai
+from .utils import handle_attachments
+router = APIRouter()
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+client = genai.client.AsyncClient(genai.client.ApiClient(api_key=GOOGLE_API_KEY))
+attachments_in_gcp = {}
+@router.post("/gemini_stream")
+async def gemini_stream(request: Request):
+    """
+    Stream responses from Google's Gemini model using the Gemini SDK.
+    """
+    body = await request.json()
+    conversation = body.get("messages", [])
+    temperature = body.get("temperature", 0.7)
+    max_tokens = body.get("max_tokens", 256)
+    model = body.get("model", "gemini-pro")  # Default to gemini-pro model
+    # Get session ID from the request
+    session_id = request.headers.get("X-Session-ID")
+    if session_id not in attachments_in_gcp: attachments_in_gcp[session_id] = {}
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing 'session_id' in payload")
+    # Handle file attachments if present
+    conversation = await handle_attachments(session_id, conversation)
+    # Convert OpenAI message format to Gemini format
+    gemini_messages = []
+    for msg in conversation:
+        role = "user" if msg["role"] == "user" else "model"
+        attachments = []
+        if "attachments" in msg:
+            for attachment in msg["attachments"]:
+                if attachment["file_path"] not in attachments_in_gcp[session_id]:
+                    gcp_upload = await client.files.upload(path=attachment["file_path"])
+                    path_wrap = types.Part.from_uri(file_uri=gcp_upload.uri, mime_type=gcp_upload.mime_type)
+                    attachments_in_gcp[session_id][attachment["file_path"]] = path_wrap
+                    attachments.append(path_wrap)
+                else:
+                    attachments.append(attachments_in_gcp[session_id][attachment["file_path"]])
+                    print("Uploaded File Reused")
+        gemini_messages.append(
+            types.Content(role=role, parts=[types.Part.from_text(text=msg["content"])] + attachments)
+        )
+    print(gemini_messages)
+    async def event_generator():
+        try:
+            print(f"Starting Gemini stream for model: {model}, temperature: {temperature}, max_tokens: {max_tokens}")
+            line_count = 0
+            # Create a Gemini model instance
+            response = await client.models.generate_content_stream(
+                model=model,
+                contents=gemini_messages,
+                config=types.GenerateContentConfig(
+                    temperature=temperature,
+                    max_output_tokens=max_tokens,
+                    top_p=0.95,
+                )
+            )
+            # Fix: Use synchronous iteration instead of async for
+            async for chunk in response:
+                content = chunk.text
+                line_count += 1
+                if line_count % 10 == 0:
+                    print(f"Processed {line_count} Gemini stream chunks")
+                # Format the response to match OpenAI format for client compatibility
+                response_json = json.dumps({
+                    "choices": [{"delta": {"content": content}}]
+                })
+                yield f"data: {response_json}\n\n"
+            # Send the [DONE] marker
+            print("Gemini stream completed successfully")
+            yield "data: [DONE]\n\n"
+        except Exception as e:
+            print(f"Error during Gemini streaming: {str(e)}")
+            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
+        finally:
+            print(f"Gemini stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
+    print("Returning StreamingResponse from Gemini to client")
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

standalone/server/stream/huggingface.py ADDED Viewed

	@@ -0,0 +1,101 @@

+import os
+import json
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi import APIRouter
+from huggingface_hub import AsyncInferenceClient
+from .utils import handle_attachments, extract_text_from_pdf
+router = APIRouter()
+HUGGINGFACE_TOKEN = os.environ.get("HUGGINGFACE_TOKEN")
+client = AsyncInferenceClient(api_key=HUGGINGFACE_TOKEN)
+attachments_in_huggingface = {}
+@router.post("/huggingface_stream")
+async def huggingface_stream(request: Request):
+    try:
+        body = await request.json()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail="Invalid JSON payload") from e
+    conversation = body.get("messages")
+    if not conversation:
+        raise HTTPException(status_code=400, detail="Missing 'conversation' in payload")
+    print("--------------------------------")
+    print(body)
+    print()
+    temperature = body.get("temperature", 0.7)
+    max_tokens = body.get("max_tokens", 256)
+    model = body.get("model", "meta-llama/Llama-3.3-70B-Instruct")
+    # Get session ID from the request
+    session_id = request.headers.get("X-Session-ID")
+    if session_id not in attachments_in_huggingface: attachments_in_huggingface[session_id] = {}
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing 'session_id' in payload")
+    # Handle file attachments if present)
+    conversation = await handle_attachments(session_id, conversation)
+    huggingface_messages = []
+    for msg in conversation:
+        role = "user" if msg["role"] == "user" else "assistant"
+        pdf_texts = []
+        if "attachments" in msg:
+            for attachment in msg["attachments"]:
+                if attachment["file_path"].endswith(".pdf"):
+                    if attachment["file_path"] not in attachments_in_huggingface[session_id]:
+                        pdf_text = await extract_text_from_pdf(attachment["file_path"])
+                        pdf_texts.append([attachment["name"], pdf_text])
+                        attachments_in_huggingface[session_id][attachment["name"]] = pdf_text
+                    else:
+                        pdf_texts.append([attachment["name"], attachments_in_huggingface[session_id][attachment["name"]]])
+        huggingface_messages.append({"role": role, "content": msg["content"]})
+        for pdf_text in pdf_texts:
+            huggingface_messages.append({"role": "user", "content": f"{pdf_text[0]}\n\n{pdf_text[1]}"})
+    async def event_generator():
+        try:
+            print(f"Starting stream for model: {model}, temperature: {temperature}, max_tokens: {max_tokens}")
+            line_count = 0
+            # Use the SDK to create a streaming completion
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=huggingface_messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True
+            )
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content is not None:
+                    content = chunk.choices[0].delta.content
+                    line_count += 1
+                    if line_count % 10 == 0:
+                        print(f"Processed {line_count} stream chunks")
+                    # Format the response in the same way as before
+                    response_json = json.dumps({
+                        "choices": [{"delta": {"content": content}}]
+                    })
+                    yield f"data: {response_json}\n\n"
+            # Send the [DONE] marker
+            print("Stream completed successfully")
+            yield "data: [DONE]\n\n"
+        except Exception as e:
+            print(f"Error during streaming: {str(e)}")
+            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
+        finally:
+            print(f"Stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
+    print("Returning StreamingResponse to client")
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

standalone/server/stream/openai.py ADDED Viewed

	@@ -0,0 +1,101 @@

+import os
+import json
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi import APIRouter
+from openai import AsyncOpenAI
+from .utils import handle_attachments, extract_text_from_pdf
+router = APIRouter()
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+attachments_in_openai = {}
+@router.post("/openai_stream")
+async def openai_stream(request: Request):
+    try:
+        body = await request.json()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail="Invalid JSON payload") from e
+    conversation = body.get("conversation")
+    if not conversation:
+        raise HTTPException(status_code=400, detail="Missing 'conversation' in payload")
+    print("--------------------------------")
+    print(body)
+    print()
+    temperature = body.get("temperature", 0.7)
+    max_tokens = body.get("max_tokens", 256)
+    model = body.get("model", "gpt-4o-mini")
+    # Get session ID from the request
+    session_id = request.headers.get("X-Session-ID")
+    if session_id not in attachments_in_openai: attachments_in_openai[session_id] = {}
+    if not session_id:
+        raise HTTPException(status_code=400, detail="Missing 'session_id' in payload")
+    # Handle file attachments if present
+    conversation = await handle_attachments(session_id, conversation)
+    gpt_messages = []
+    for msg in conversation:
+        role = "user" if msg["role"] == "user" else "assistant"
+        pdf_texts = []
+        if "attachments" in msg:
+            for attachment in msg["attachments"]:
+                if attachment["file_path"].endswith(".pdf"):
+                    if attachment["file_path"] not in attachments_in_openai[session_id]:
+                        pdf_text = await extract_text_from_pdf(attachment["file_path"])
+                        pdf_texts.append([attachment["name"], pdf_text])
+                        attachments_in_openai[session_id][attachment["name"]] = pdf_text
+                    else:
+                        pdf_texts.append([attachment["name"], attachments_in_openai[session_id][attachment["name"]]])
+        gpt_messages.append({"role": role, "content": msg["content"]})
+        for pdf_text in pdf_texts:
+            gpt_messages.append({"role": "user", "content": f"{pdf_text[0]}\n\n{pdf_text[1]}"})
+    async def event_generator():
+        try:
+            print(f"Starting stream for model: {model}, temperature: {temperature}, max_tokens: {max_tokens}")
+            line_count = 0
+            # Use the SDK to create a streaming completion
+            stream = await client.chat.completions.create(
+                model=model,
+                messages=gpt_messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=True
+            )
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content is not None:
+                    content = chunk.choices[0].delta.content
+                    line_count += 1
+                    if line_count % 10 == 0:
+                        print(f"Processed {line_count} stream chunks")
+                    # Format the response in the same way as before
+                    response_json = json.dumps({
+                        "choices": [{"delta": {"content": content}}]
+                    })
+                    yield f"data: {response_json}\n\n"
+            # Send the [DONE] marker
+            print("Stream completed successfully")
+            yield "data: [DONE]\n\n"
+        except Exception as e:
+            print(f"Error during streaming: {str(e)}")
+            yield f"data: {{\"error\": \"{str(e)}\"}}\n\n"
+        finally:
+            print(f"Stream ended after processing {line_count if 'line_count' in locals() else 0} chunks")
+    print("Returning StreamingResponse to client")
+    return StreamingResponse(event_generator(), media_type="text/event-stream")

standalone/server/stream/utils.py ADDED Viewed

	@@ -0,0 +1,66 @@

+import os
+import base64
+from collections import defaultdict
+import PyPDF2
+async def extract_text_from_pdf(pdf_path):
+    text = ""
+    with open(pdf_path, "rb") as pdf_file:
+        reader = PyPDF2.PdfReader(pdf_file)
+        for page in reader.pages:
+            text += page.extract_text() + "\n"
+    return text.strip()
+async def handle_attachments(session_id, conversation, remove_content=True):
+    """
+    Process attachments for each message in the conversation.
+    Args:
+        session_id (str): The unique identifier for the session
+        conversation (list): List of message objects containing attachments
+    Returns:
+        None
+    """
+    # Process attachments for each message in the conversation
+    for outer_idx, msg in enumerate(conversation):
+        if "attachments" in msg and msg["attachments"]:
+            # Create a temporary folder for this session if it doesn't exist
+            session_folder = os.path.join("temp_attachments", session_id)
+            os.makedirs(session_folder, exist_ok=True)
+            for inner_idx, attachment in enumerate(msg["attachments"]):
+                attachment_name = attachment.get("name", "unknown_file")
+                attachment_content = attachment.get("content")
+                # Check if this attachment already exists in the session
+                attachment_exists = False
+                file_path = None
+                for existing_attachment in msg["attachments"]:
+                    if existing_attachment.get("name") == attachment_name and existing_attachment.get("file_path"):
+                        attachment_exists = True
+                        file_path = existing_attachment.get("file_path")
+                        break
+                # Only decode and save if it's a new attachment
+                if not attachment_exists and attachment_content:
+                    try:
+                        file_path = os.path.join(session_folder, attachment_name)
+                        # Decode base64 content and write to file
+                        with open(file_path, "wb") as f:
+                            f.write(base64.b64decode(attachment_content))
+                    except Exception as e:
+                        print(f"Error saving attachment: {str(e)}")
+                # Add file_path to the original attachment dict
+                if file_path:
+                    if remove_content:
+                        del attachment["content"]
+                    attachment["file_path"] = file_path
+                    msg["attachments"][inner_idx] = attachment
+                    conversation[outer_idx] = msg
+    return conversation

standalone/style.css CHANGED Viewed

@@ -321,10 +321,11 @@
     gap: 5px;
   }
   .file-item-vertical {
-    background: #f0f0f0;
     padding: 6px 10px;
     border-radius: var(--border-radius);
-    font-size: 0.9em;
   }
   /* Navigation Buttons */
   .nav {
@@ -441,12 +442,14 @@
     border: none;
     outline: none;
     resize: none;
-    overflow: hidden;
     font-size: 1em;
     height: 36px;
-    line-height: 36px;
     margin: 0;
     padding: 0 8px;
   }
   #chatInput::placeholder {
     color: #999;
@@ -471,130 +474,192 @@
   #sendBtn:hover {
     background: #f0f0f0;
   }
-  /* Summary Overlay */
 #summaryOverlay {
-    position: fixed;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    height: 60%;
-    background: #fff;
-    box-shadow: 0 -4px 16px var(--light-shadow);
-    transform: translateY(100%);
-    transition: transform 0.3s ease;
-    z-index: 20;
-    display: flex;
-    flex-direction: column;
-  }
-  #summaryOverlay.active {
-    transform: translateY(0);
-  }
-  .summary-header {
-    padding-left: 20px;
-    padding-right: 20px;
-    padding-top: 10px;
-    padding-bottom: 10px;
-    background: var(--primary-color);
-    color: #fff;
-    font-size: 1.4em;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-  }
-  .summary-header-buttons {
-    display: flex;
-    gap: 12px;
-  }
-  .download-summary {
-    background: #fff;
-    color: var(--primary-color);
-    border: 1px solid var(--primary-color);
-    border-radius: 6px;
-    padding: 6px 12px;
-    cursor: pointer;
-    transition: background 0.3s, color 0.3s;
-  }
-  .download-summary:hover {
-    background: var(--primary-color);
-    color: #fff;
-  }
-  .close-summary {
-    background: none;
-    border: none;
-    color: #fff;
-    font-size: 1.4em;
-    cursor: pointer;
-  }
-  .summary-content {
-    padding: 20px;
-    overflow-y: auto;
-    flex: 1;
-  }
-    /* Settings Overlay */
-    #settingsOverlay {
-        position: fixed;
-        left: 0;
-        right: 0;
-        bottom: 0;
-        height: 40%;
-        background: #fff;
-        box-shadow: 0 -4px 16px var(--light-shadow);
-        transform: translateY(100%);
-        transition: transform 0.3s ease;
-        z-index: 20;
-        display: flex;
-        flex-direction: column;
-    }
-    #settingsOverlay.active {
-        transform: translateY(0);
-    }
-  .settings-header {
-    padding-left: 20px;
-    padding-right: 20px;
-    padding-top: 10px;
-    padding-bottom: 10px;
-    background: var(--primary-color);
-    color: #fff;
-    font-size: 1.4em;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-  }
-  .close-settings {
-    background: none;
-    border: none;
-    color: #fff;
-    font-size: 1.6em;
-    cursor: pointer;
-  }
-  .settings-content {
-    padding: 20px;
-    overflow-y: auto;
-    flex: 1;
-    font-size: 1.1em;
-    line-height: 1.5;
-  }
-  .settings-group {
-    margin-bottom: 20px;
-    display: flex;
-    align-items: center;
-    gap: 12px;
-  }
-  .settings-group label {
-    min-width: 120px;
-  }
-  .save-settings {
-    background: var(--primary-color);
-    color: #fff;
-    border: none;
-    border-radius: 8px;
-    padding: 12px 24px;
-    cursor: pointer;
-    transition: background 0.3s;
-  }
-  .save-settings:hover {
-    background: var(--primary-dark);
-  }
   @media (max-width: 600px) {
     .nav-bar {
       display: none;
@@ -677,33 +742,47 @@
 /* Markdown */
 .markdown-body {
-    font-size: 1em;
-    line-height: 1.5;
-    white-space: normal; /* Ensure paragraphs and lists break onto new lines */
-  }
-  .markdown-body p {
-    margin: 0.75em 0; /* Add vertical space between paragraphs */
-  }
-  .markdown-body ul,
-  .markdown-body ol {
-    margin: 0.75em 0;
-    padding-left: 1.5em; /* Indent bullets/numbers */
-  }
-  .markdown-body li {
-    margin: 0.3em 0;
-  }
-  .markdown-body h1,
-  .markdown-body h2,
-  .markdown-body h3,
-  .markdown-body h4,
-  .markdown-body h5,
-  .markdown-body h6 {
-    margin-top: 1em;
-    margin-bottom: 0.5em;
-    font-weight: bold;
-  }

     gap: 5px;
   }
   .file-item-vertical {
+    background: #0500e624;
     padding: 6px 10px;
     border-radius: var(--border-radius);
+    font-size: 0.5em;
+    font-style: italic;
   }
   /* Navigation Buttons */
   .nav {
     border: none;
     outline: none;
     resize: none;
+    overflow: scroll;
     font-size: 1em;
     height: 36px;
+    /* line-height: 36px; */
     margin: 0;
     padding: 0 8px;
+    padding: 10px;
+    max-height: 100px;
   }
   #chatInput::placeholder {
     color: #999;
   #sendBtn:hover {
     background: #f0f0f0;
   }
+/* Redesigned Summary Overlay with Max Height */
 #summaryOverlay {
+  position: fixed;
+  bottom: 0;
+  left: 50%;
+  transform: translateX(-50%) translateY(100%);
+  width: 90%;
+  /* max-width: 600px;  Wider than settings panel */
+  max-height: 50vh;  /* Limit to half the viewport height */
+  background: linear-gradient(135deg, #ffffff, #f7f7f7);
+  border-top-left-radius: 20px;
+  border-top-right-radius: 20px;
+  box-shadow: 0 -4px 20px rgba(0, 0, 0, 0.1);
+  transition: transform 0.3s ease;
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  padding-bottom: 50px;
+}
+#summaryOverlay.active {
+  transform: translateX(-50%) translateY(0);
+}
+.summary-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 16px 20px;
+  background: linear-gradient(135deg, #4a90e2, #4178c0);
+  color: #fff;
+  font-size: 1.5em;
+  border-top-left-radius: 20px;
+  border-top-right-radius: 20px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+.summary-header span {
+  font-weight: 500;
+}
+.summary-header-buttons {
+  display: flex;
+  gap: 12px;
+}
+.download-summary {
+  background: #fff;
+  color: #4a90e2;
+  border: 1px solid #4a90e2;
+  border-radius: 8px;
+  padding: 6px 12px;
+  cursor: pointer;
+  transition: background 0.3s, color 0.3s;
+}
+.download-summary:hover {
+  background: #4a90e2;
+  color: #fff;
+}
+.close-summary {
+  background: none;
+  border: none;
+  color: #fff;
+  font-size: 1.8em;
+  cursor: pointer;
+  line-height: 1;
+}
+.summary-content {
+  padding: 20px;
+  overflow-y: auto; /* Scrollbar appears when content exceeds available height */
+  flex: 1;
+  font-size: 1em;
+  color: #333;
+  background: #fff;
+}
+/* Redesigned Settings Overlay */
+#settingsOverlay {
+  position: fixed;
+  bottom: 0;
+  left: 50%;
+  transform: translateX(-50%) translateY(100%);
+  width: 90%;
+  max-width: 500px;
+  background: linear-gradient(135deg, #ffffff, #f7f7f7);
+  border-top-left-radius: 20px;
+  border-top-right-radius: 20px;
+  box-shadow: 0 -4px 20px rgba(0, 0, 0, 0.1);
+  transition: transform 0.3s ease;
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  padding-bottom: 50px;
+}
+#settingsOverlay.active {
+  transform: translateX(-50%) translateY(0);
+}
+.settings-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 16px 20px;
+  background: linear-gradient(135deg, #4a90e2, #4178c0);
+  color: #fff;
+  font-size: 1.5em;
+  border-top-left-radius: 20px;
+  border-top-right-radius: 20px;
+  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+.settings-header span {
+  font-weight: 500;
+}
+.close-settings {
+  background: none;
+  border: none;
+  color: #fff;
+  font-size: 1.8em;
+  cursor: pointer;
+  line-height: 1;
+}
+.settings-content {
+  padding: 20px;
+  flex: 1;
+  overflow-y: auto;
+  font-size: 1em;
+  color: #333;
+  background: #fff;
+}
+.settings-group {
+  display: flex;
+  flex-direction: column;
+  margin-bottom: 20px;
+}
+.settings-group label {
+  margin-bottom: 8px;
+  font-weight: 500;
+}
+.settings-group input[type="range"],
+.settings-group input[type="number"],
+.settings-group select {
+  padding: 10px;
+  border: 1px solid #ccc;
+  border-radius: 8px;
+  outline: none;
+  width: 100%;
+  font-size: 1em;
+  background: #fefefe;
+  transition: border 0.3s;
+}
+.settings-group input[type="range"]:focus,
+.settings-group input[type="number"]:focus,
+.settings-group select:focus {
+  border-color: #4a90e2;
+}
+.save-settings {
+  background: linear-gradient(135deg, #4a90e2, #4178c0);
+  color: #fff;
+  border: none;
+  border-radius: 8px;
+  padding: 12px;
+  width: 100%;
+  font-size: 1em;
+  cursor: pointer;
+  transition: background 0.3s;
+}
+.save-settings:hover {
+  background: linear-gradient(135deg, #4178c0, #4a90e2);
+}
   @media (max-width: 600px) {
     .nav-bar {
       display: none;
 /* Markdown */
 .markdown-body {
+  font-size: 1em;
+  line-height: 1.5;
+  white-space: normal; /* Ensure paragraphs and lists break onto new lines */
+}
+.markdown-body p {
+  margin: 0.75em 0; /* Add vertical space between paragraphs */
+}
+.markdown-body ul,
+.markdown-body ol {
+  margin: 0.75em 0;
+  padding-left: 1.5em; /* Indent bullets/numbers */
+}
+.markdown-body li {
+  margin: 0.3em 0;
+}
+.markdown-body h1,
+.markdown-body h2,
+.markdown-body h3,
+.markdown-body h4,
+.markdown-body h5,
+.markdown-body h6 {
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+  font-weight: bold;
+}
+.blinking-cursor {
+  display: inline-block;
+  width: 10px;
+  height: 1em;
+  background-color: currentColor;
+  margin-left: 2px;
+  animation: blink 1s steps(2, start) infinite;
+}
+@keyframes blink {
+  50% { opacity: 0; }
+  100% { opacity: 1; }
+}