fix: model in agents via api

* feat: context compression

* fix: ruff

.github/dependabot.yml

@@ -13,7 +13,11 @@ updates:
     directory: "/frontend" # Location of package manifests
     schedule:
       interval: "daily"
+  - package-ecosystem: "npm"
+    directory: "/extensions/react-widget"
+    schedule:
+      interval: "daily"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "daily"
+      interval: "daily"

.github/styles/DocsGPT/Spelling.yml

@@ -0,0 +1,11 @@
+extends: spelling
+level: warning
+message: "Did you really mean '%s'?"
+ignore:
+  - "**/node_modules/**"
+  - "**/dist/**"
+  - "**/build/**"
+  - "**/coverage/**"
+  - "**/public/**"
+  - "**/static/**"
+vocab: DocsGPT

.github/styles/config/vocabularies/DocsGPT/accept.txt

@@ -0,0 +1,46 @@
+Ollama
+Qdrant
+Milvus
+Chatwoot
+Nextra
+VSCode
+npm
+LLMs
+APIs
+Groq
+SGLang
+LMDeploy
+OAuth
+Vite
+LLM
+JSONPath
+UIs
+configs
+uncomment
+qdrant
+vectorstore
+docsgpt
+llm
+GPUs
+kubectl
+Lightsail
+enqueues
+chatbot
+VSCode's
+Shareability
+feedbacks
+automations
+Premade
+Signup
+Repo
+repo
+env
+URl
+agentic
+llama_cpp
+parsable
+SDKs
+boolean
+bool
+hardcode
+EOL

.github/workflows/pytest.yml

@@ -16,15 +16,15 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install pytest pytest-cov
           cd application
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+          cd ../tests
+          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
       - name: Test with pytest and generate coverage report
         run: |
-          python -m pytest --cov=application --cov-report=xml
+          python -m pytest --cov=application --cov-report=xml --cov-report=term-missing
       - name: Upload coverage reports to Codecov
         if: github.event_name == 'pull_request' && matrix.python-version == '3.12'
         uses: codecov/codecov-action@v5
         env:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-

.github/workflows/vale.yml

@@ -0,0 +1,26 @@
+name: Vale Documentation Linter
+
+on:
+  pull_request:
+    paths:
+      - 'docs/**/*.md'
+      - 'docs/**/*.mdx'
+      - '**/*.md'
+      - '.vale.ini'
+      - '.github/styles/**'
+
+jobs:
+  vale:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Vale linter
+        uses: errata-ai/vale-action@v2
+        with:
+          files: docs
+          fail_on_error: false
+          version: 3.0.5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -2,7 +2,9 @@
 __pycache__/
 *.py[cod]
 *$py.class
+experiments/
 
+experiments
 # C extensions
 *.so
 *.next

.vale.ini

@@ -0,0 +1,5 @@
+MinAlertLevel = warning
+StylesPath = .github/styles
+
+[*.{md,mdx}]
+BasedOnStyles = DocsGPT

CONTRIBUTING.md

@@ -147,5 +147,5 @@ Here's a step-by-step guide on how to contribute to DocsGPT:
 Thank you for considering contributing to DocsGPT! 🙏
 
 ## Questions/collaboration
-Feel free to join our [Discord](https://discord.gg/n5BX8dh8rU). We're very friendly and welcoming to new contributors, so don't hesitate to reach out.
+Feel free to join our [Discord](https://discord.gg/vN7YFfdMpj). We're very friendly and welcoming to new contributors, so don't hesitate to reach out.
 # Thank you so much for considering to contributing DocsGPT!🙏

HACKTOBERFEST.md

@@ -3,6 +3,7 @@
 Welcome, contributors! We're excited to announce that DocsGPT is participating in Hacktoberfest. Get involved by submitting meaningful pull requests.
 
 All Meaningful contributors with accepted PRs that were created for issues with the `hacktoberfest` label (set by our maintainer team: dartpain, siiddhantt, pabik, ManishMadan2882) will receive a cool T-shirt! 🤩.
+<img width="1331" height="678" alt="hacktoberfest-mocks-preview" src="https://github.com/user-attachments/assets/633f6377-38db-48f5-b519-a8b3855a9eb4" />
 
 Fill in [this form](https://forms.gle/Npaba4n9Epfyx56S8
 ) after your PR was merged please 
@@ -31,7 +32,7 @@ Non-Code Contributions:
 - Before contributing check existing [issues](https://github.com/arc53/DocsGPT/issues) or [create](https://github.com/arc53/DocsGPT/issues/new/choose) an issue and wait to get assigned.
 - Once you are finished with your contribution, please fill in this [form](https://forms.gle/Npaba4n9Epfyx56S8).
 - Refer to the [Documentation](https://docs.docsgpt.cloud/).
-- Feel free to join our [Discord](https://discord.gg/n5BX8dh8rU) server. We're here to help newcomers, so don't hesitate to jump in! Join us [here](https://discord.gg/n5BX8dh8rU).
+- Feel free to join our [Discord](https://discord.gg/vN7YFfdMpj) server. We're here to help newcomers, so don't hesitate to jump in! Join us [here](https://discord.gg/vN7YFfdMpj).
   
 Thank you very much for considering contributing to DocsGPT during Hacktoberfest! 🙏 Your contributions (not just simple typos) could earn you a stylish new t-shirt.
 

README.md

@@ -16,23 +16,16 @@
   <a href="https://github.com/arc53/DocsGPT">![link to main GitHub showing Forks number](https://img.shields.io/github/forks/arc53/docsgpt?style=social)</a>
   <a href="https://github.com/arc53/DocsGPT/blob/main/LICENSE">![link to license file](https://img.shields.io/github/license/arc53/docsgpt)</a>
   <a href="https://www.bestpractices.dev/projects/9907"><img src="https://www.bestpractices.dev/projects/9907/badge"></a>
-  <a href="https://discord.gg/n5BX8dh8rU">![link to discord](https://img.shields.io/discord/1070046503302877216)</a>
+  <a href="https://discord.gg/vN7YFfdMpj">![link to discord](https://img.shields.io/discord/1070046503302877216)</a>
   <a href="https://x.com/docsgptai">![X (formerly Twitter) URL](https://img.shields.io/twitter/follow/docsgptai)</a>
 
-<a href="https://docs.docsgpt.cloud/quickstart">⚡️ Quickstart</a> • <a href="https://app.docsgpt.cloud/">☁️ Cloud Version</a> • <a href="https://discord.gg/n5BX8dh8rU">💬 Discord</a>
+<a href="https://docs.docsgpt.cloud/quickstart">⚡️ Quickstart</a> • <a href="https://app.docsgpt.cloud/">☁️ Cloud Version</a> • <a href="https://discord.gg/vN7YFfdMpj">💬 Discord</a>
 <br>
 <a href="https://docs.docsgpt.cloud/">📖 Documentation</a> • <a href="https://github.com/arc53/DocsGPT/blob/main/CONTRIBUTING.md">👫 Contribute</a> • <a href="https://blog.docsgpt.cloud/">🗞 Blog</a>
 <br>
 
 </div>
 
-<div align="center">
-  <br>
-🎃 <a href="https://github.com/arc53/DocsGPT/blob/main/HACKTOBERFEST.md"> Hacktoberfest Prizes, Rules & Q&A </a> 🎃
-  <br>
-  <br>
-</div>
-
 
 <div align="center">
   <br>
@@ -68,7 +61,7 @@
 - [x] MCP support (August 2025)
 - [x] Google Drive integration (September 2025)
 - [x] Add OAuth 2.0 authentication for MCP (September 2025)
-- [ ] Sharepoint integration (October 2025)
+- [ ] SharePoint integration (October 2025)
 - [ ] Deep Agents (October 2025)
 - [ ] Agent scheduling
 
@@ -118,7 +111,7 @@ A more detailed [Quickstart](https://docs.docsgpt.cloud/quickstart) is available
    PowerShell -ExecutionPolicy Bypass -File .\setup.ps1
    ```
 
-Either script will guide you through setting up DocsGPT. Four options available: using the public API, running locally, connecting to a local inference engine, or using a cloud API provider. Scripts will automatically configure your `.env` file and handle necessary downloads and installations based on your chosen option.
+Either script will guide you through setting up DocsGPT. Five options available: using the public API, running locally, connecting to a local inference engine, using a cloud API provider, or build the docker image locally. Scripts will automatically configure your `.env` file and handle necessary downloads and installations based on your chosen option.
 
 **Navigate to http://localhost:5173/**
 

application/agents/agent_creator.py

@@ -1,5 +1,8 @@
 from application.agents.classic_agent import ClassicAgent
 from application.agents.react_agent import ReActAgent
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class AgentCreator:
@@ -13,4 +16,5 @@ class AgentCreator:
         agent_class = cls.agents.get(type.lower())
         if not agent_class:
             raise ValueError(f"No agent class found for type {type}")
+        
         return agent_class(*args, **kwargs)

application/agents/base.py

@@ -12,7 +12,6 @@ from application.core.settings import settings
 from application.llm.handlers.handler_creator import LLMHandlerCreator
 from application.llm.llm_creator import LLMCreator
 from application.logging import build_stack_data, log_activity, LogContext
-from application.retriever.base import BaseRetriever
 
 logger = logging.getLogger(__name__)
 
@@ -22,23 +21,29 @@ class BaseAgent(ABC):
         self,
         endpoint: str,
         llm_name: str,
-        gpt_model: str,
+        model_id: str,
         api_key: str,
         user_api_key: Optional[str] = None,
         prompt: str = "",
         chat_history: Optional[List[Dict]] = None,
+        retrieved_docs: Optional[List[Dict]] = None,
         decoded_token: Optional[Dict] = None,
         attachments: Optional[List[Dict]] = None,
         json_schema: Optional[Dict] = None,
+        limited_token_mode: Optional[bool] = False,
+        token_limit: Optional[int] = settings.DEFAULT_AGENT_LIMITS["token_limit"],
+        limited_request_mode: Optional[bool] = False,
+        request_limit: Optional[int] = settings.DEFAULT_AGENT_LIMITS["request_limit"],
+        compressed_summary: Optional[str] = None,
     ):
         self.endpoint = endpoint
         self.llm_name = llm_name
-        self.gpt_model = gpt_model
+        self.model_id = model_id
         self.api_key = api_key
         self.user_api_key = user_api_key
         self.prompt = prompt
         self.decoded_token = decoded_token or {}
-        self.user: str = decoded_token.get("sub")
+        self.user: str = self.decoded_token.get("sub")
         self.tool_config: Dict = {}
         self.tools: List[Dict] = []
         self.tool_calls: List[Dict] = []
@@ -48,22 +53,31 @@ class BaseAgent(ABC):
             api_key=api_key,
             user_api_key=user_api_key,
             decoded_token=decoded_token,
+            model_id=model_id,
         )
+        self.retrieved_docs = retrieved_docs or []
         self.llm_handler = LLMHandlerCreator.create_handler(
             llm_name if llm_name else "default"
         )
         self.attachments = attachments or []
         self.json_schema = json_schema
+        self.limited_token_mode = limited_token_mode
+        self.token_limit = token_limit
+        self.limited_request_mode = limited_request_mode
+        self.request_limit = request_limit
+        self.compressed_summary = compressed_summary
+        self.current_token_count = 0
+        self.context_limit_reached = False
 
     @log_activity()
     def gen(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext = None
+        self, query: str, log_context: LogContext = None
     ) -> Generator[Dict, None, None]:
-        yield from self._gen_inner(query, retriever, log_context)
+        yield from self._gen_inner(query, log_context)
 
     @abstractmethod
     def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
+        self, query: str, log_context: LogContext
     ) -> Generator[Dict, None, None]:
         pass
 
@@ -142,6 +156,7 @@ class BaseAgent(ABC):
         call_id = getattr(call, "id", None) or str(uuid.uuid4())
 
         # Check if parsing failed
+
         if tool_id is None or action_name is None:
             error_message = f"Error: Failed to parse LLM tool call. Tool name: {getattr(call, 'name', 'unknown')}"
             logger.error(error_message)
@@ -156,13 +171,14 @@ class BaseAgent(ABC):
             yield {"type": "tool_call", "data": {**tool_call_data, "status": "error"}}
             self.tool_calls.append(tool_call_data)
             return "Failed to parse tool call.", call_id
-
         # Check if tool_id exists in available tools
+
         if tool_id not in tools_dict:
             error_message = f"Error: Tool ID '{tool_id}' extracted from LLM call not found in available tools_dict. Available IDs: {list(tools_dict.keys())}"
             logger.error(error_message)
 
             # Return error result
+
             tool_call_data = {
                 "tool_name": "unknown",
                 "call_id": call_id,
@@ -173,7 +189,6 @@ class BaseAgent(ABC):
             yield {"type": "tool_call", "data": {**tool_call_data, "status": "error"}}
             self.tool_calls.append(tool_call_data)
             return f"Tool with ID {tool_id} not found.", call_id
-
         tool_call_data = {
             "tool_name": tools_dict[tool_id]["name"],
             "call_id": call_id,
@@ -215,6 +230,7 @@ class BaseAgent(ABC):
         tm = ToolManager(config={})
 
         # Prepare tool_config and add tool_id for memory tools
+
         if tool_data["name"] == "api_tool":
             tool_config = {
                 "url": tool_data["config"]["actions"][action_name]["url"],
@@ -226,8 +242,8 @@ class BaseAgent(ABC):
             tool_config = tool_data["config"].copy() if tool_data["config"] else {}
             # Add tool_id from MongoDB _id for tools that need instance isolation (like memory tool)
             # Use MongoDB _id if available, otherwise fall back to enumerated tool_id
-            tool_config["tool_id"] = str(tool_data.get("_id", tool_id))
 
+            tool_config["tool_id"] = str(tool_data.get("_id", tool_id))
         tool = tm.load_tool(
             tool_data["name"],
             tool_config=tool_config,
@@ -264,28 +280,83 @@ class BaseAgent(ABC):
             for tool_call in self.tool_calls
         ]
 
+    def _calculate_current_context_tokens(self, messages: List[Dict]) -> int:
+        """
+        Calculate total tokens in current context (messages).
+
+        Args:
+            messages: List of message dicts
+
+        Returns:
+            Total token count
+        """
+        from application.api.answer.services.compression.token_counter import (
+            TokenCounter,
+        )
+
+        return TokenCounter.count_message_tokens(messages)
+
+    def _check_context_limit(self, messages: List[Dict]) -> bool:
+        """
+        Check if we're approaching context limit (80%).
+
+        Args:
+            messages: Current message list
+
+        Returns:
+            True if at or above 80% of context limit
+        """
+        from application.core.model_utils import get_token_limit
+        from application.core.settings import settings
+
+        try:
+            # Calculate current tokens
+            current_tokens = self._calculate_current_context_tokens(messages)
+            self.current_token_count = current_tokens
+
+            # Get context limit for model
+            context_limit = get_token_limit(self.model_id)
+
+            # Calculate threshold (80%)
+            threshold = int(context_limit * settings.COMPRESSION_THRESHOLD_PERCENTAGE)
+
+            # Check if we've reached the limit
+            if current_tokens >= threshold:
+                logger.warning(
+                    f"Context limit approaching: {current_tokens}/{context_limit} tokens "
+                    f"({(current_tokens/context_limit)*100:.1f}%)"
+                )
+                return True
+
+            return False
+
+        except Exception as e:
+            logger.error(f"Error checking context limit: {str(e)}", exc_info=True)
+            return False
+
     def _build_messages(
         self,
         system_prompt: str,
         query: str,
-        retrieved_data: List[Dict],
     ) -> List[Dict]:
-        docs_with_filenames = []
-        for doc in retrieved_data:
-            filename = doc.get("filename") or doc.get("title") or doc.get("source")
-            if filename:
-                chunk_header = str(filename)
-                docs_with_filenames.append(f"{chunk_header}\n{doc['text']}")
-            else:
-                docs_with_filenames.append(doc["text"])
-        docs_together = "\n\n".join(docs_with_filenames)
-        p_chat_combine = system_prompt.replace("{summaries}", docs_together)
-        messages_combine = [{"role": "system", "content": p_chat_combine}]
+        """Build messages using pre-rendered system prompt"""
+        # Append compression summary to system prompt if present
+        if self.compressed_summary:
+            compression_context = (
+                "\n\n---\n\n"
+                "This session is being continued from a previous conversation that "
+                "has been compressed to fit within context limits. "
+                "The conversation is summarized below:\n\n"
+                f"{self.compressed_summary}"
+            )
+            system_prompt = system_prompt + compression_context
+
+        messages = [{"role": "system", "content": system_prompt}]
 
         for i in self.chat_history:
             if "prompt" in i and "response" in i:
-                messages_combine.append({"role": "user", "content": i["prompt"]})
-                messages_combine.append({"role": "assistant", "content": i["response"]})
+                messages.append({"role": "user", "content": i["prompt"]})
+                messages.append({"role": "assistant", "content": i["response"]})
             if "tool_calls" in i:
                 for tool_call in i["tool_calls"]:
                     call_id = tool_call.get("call_id") or str(uuid.uuid4())
@@ -305,29 +376,17 @@ class BaseAgent(ABC):
                         }
                     }
 
-                    messages_combine.append(
+                    messages.append(
                         {"role": "assistant", "content": [function_call_dict]}
                     )
-                    messages_combine.append(
+                    messages.append(
                         {"role": "tool", "content": [function_response_dict]}
                     )
-        messages_combine.append({"role": "user", "content": query})
-        return messages_combine
-
-    def _retriever_search(
-        self,
-        retriever: BaseRetriever,
-        query: str,
-        log_context: Optional[LogContext] = None,
-    ) -> List[Dict]:
-        retrieved_data = retriever.search(query)
-        if log_context:
-            data = build_stack_data(retriever, exclude_attributes=["llm"])
-            log_context.stacks.append({"component": "retriever", "data": data})
-        return retrieved_data
+        messages.append({"role": "user", "content": query})
+        return messages
 
     def _llm_gen(self, messages: List[Dict], log_context: Optional[LogContext] = None):
-        gen_kwargs = {"model": self.gpt_model, "messages": messages}
+        gen_kwargs = {"model": self.model_id, "messages": messages}
 
         if (
             hasattr(self.llm, "_supports_tools")
@@ -335,7 +394,6 @@ class BaseAgent(ABC):
             and self.tools
         ):
             gen_kwargs["tools"] = self.tools
-
         if (
             self.json_schema
             and hasattr(self.llm, "_supports_structured_output")
@@ -349,7 +407,6 @@ class BaseAgent(ABC):
                     gen_kwargs["response_format"] = structured_format
                 elif self.llm_name == "google":
                     gen_kwargs["response_schema"] = structured_format
-
         resp = self.llm.gen_stream(**gen_kwargs)
 
         if log_context:

application/agents/classic_agent.py

@@ -1,32 +1,20 @@
+import logging
 from typing import Dict, Generator
+
 from application.agents.base import BaseAgent
 from application.logging import LogContext
-from application.retriever.base import BaseRetriever
-import logging
 
 logger = logging.getLogger(__name__)
 
 
 class ClassicAgent(BaseAgent):
-    """A simplified agent with clear execution flow.
-
-    Usage:
-    1. Processes a query through retrieval
-    2. Sets up available tools
-    3. Generates responses using LLM
-    4. Handles tool interactions if needed
-    5. Returns standardized outputs
-
-    Easy to extend by overriding specific steps.
-    """
+    """A simplified agent with clear execution flow"""
 
     def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
+        self, query: str, log_context: LogContext
     ) -> Generator[Dict, None, None]:
-        # Step 1: Retrieve relevant data
-        retrieved_data = self._retriever_search(retriever, query, log_context)
+        """Core generator function for ClassicAgent execution flow"""
 
-        # Step 2: Prepare tools
         tools_dict = (
             self._get_user_tools(self.user)
             if not self.user_api_key
@@ -34,20 +22,16 @@ class ClassicAgent(BaseAgent):
         )
         self._prepare_tools(tools_dict)
 
-        # Step 3: Build and process messages
-        messages = self._build_messages(self.prompt, query, retrieved_data)
+        messages = self._build_messages(self.prompt, query)
         llm_response = self._llm_gen(messages, log_context)
 
-        # Step 4: Handle the response
         yield from self._handle_response(
             llm_response, tools_dict, messages, log_context
         )
 
-        # Step 5: Return metadata
-        yield {"sources": retrieved_data}
+        yield {"sources": self.retrieved_docs}
         yield {"tool_calls": self._get_truncated_tool_calls()}
 
-        # Log tool calls for debugging
         log_context.stacks.append(
             {"component": "agent", "data": {"tool_calls": self.tool_calls.copy()}}
         )

application/agents/react_agent.py

@@ -1,229 +1,238 @@
-import os
-from typing import Dict, Generator, List, Any
 import logging
+import os
+from typing import Any, Dict, Generator, List
 
 from application.agents.base import BaseAgent
 from application.logging import build_stack_data, LogContext
-from application.retriever.base import BaseRetriever
 
 logger = logging.getLogger(__name__)
 
+MAX_ITERATIONS_REASONING = 10
+
 current_dir = os.path.dirname(
     os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 )
 with open(
     os.path.join(current_dir, "application/prompts", "react_planning_prompt.txt"), "r"
 ) as f:
-    planning_prompt_template = f.read()
+    PLANNING_PROMPT_TEMPLATE = f.read()
 with open(
-    os.path.join(current_dir, "application/prompts", "react_final_prompt.txt"),
-    "r",
+    os.path.join(current_dir, "application/prompts", "react_final_prompt.txt"), "r"
 ) as f:
-    final_prompt_template = f.read()
-    
-MAX_ITERATIONS_REASONING = 10
+    FINAL_PROMPT_TEMPLATE = f.read()
+
 
 class ReActAgent(BaseAgent):
+    """
+    Research and Action (ReAct) Agent - Advanced reasoning agent with iterative planning.
+
+    Implements a think-act-observe loop for complex problem-solving:
+    1. Creates a strategic plan based on the query
+    2. Executes tools and gathers observations
+    3. Iteratively refines approach until satisfied
+    4. Synthesizes final answer from all observations
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.plan: str = ""
         self.observations: List[str] = []
 
-    def _extract_content_from_llm_response(self, resp: Any) -> str:
-        """
-        Helper to extract string content from various LLM response types.
-        Handles strings, message objects (OpenAI-like), and streams.
-        Adapt stream handling for your specific LLM client if not OpenAI.
-        """
-        collected_content = []
-        if isinstance(resp, str):
-            collected_content.append(resp)
-        elif ( # OpenAI non-streaming or Anthropic non-streaming (older SDK style)
-            hasattr(resp, "message")
-            and hasattr(resp.message, "content")
-            and resp.message.content is not None
-        ):
-            collected_content.append(resp.message.content)
-        elif ( # OpenAI non-streaming (Pydantic model), Anthropic new SDK non-streaming
-            hasattr(resp, "choices") and resp.choices and
-            hasattr(resp.choices[0], "message") and
-            hasattr(resp.choices[0].message, "content") and
-            resp.choices[0].message.content is not None
-        ):
-            collected_content.append(resp.choices[0].message.content) # OpenAI
-        elif ( # Anthropic new SDK non-streaming content block
-             hasattr(resp, "content") and isinstance(resp.content, list) and resp.content and
-             hasattr(resp.content[0], "text")
-        ):
-            collected_content.append(resp.content[0].text) # Anthropic
-        else:
-            # Assume resp is a stream if not a recognized object
-            try:
-                for chunk in resp: # This will fail if resp is not iterable (e.g. a non-streaming response object)
-                    content_piece = ""
-                    # OpenAI-like stream
-                    if hasattr(chunk, 'choices') and len(chunk.choices) > 0 and \
-                       hasattr(chunk.choices[0], 'delta') and \
-                       hasattr(chunk.choices[0].delta, 'content') and \
-                       chunk.choices[0].delta.content is not None:
-                        content_piece = chunk.choices[0].delta.content
-                    # Anthropic-like stream (ContentBlockDelta)
-                    elif hasattr(chunk, 'type') and chunk.type == 'content_block_delta' and \
-                         hasattr(chunk, 'delta') and hasattr(chunk.delta, 'text'):
-                        content_piece = chunk.delta.text
-                    elif isinstance(chunk, str): # Simplest case: stream of strings
-                        content_piece = chunk
-
-                    if content_piece:
-                        collected_content.append(content_piece)
-            except TypeError: # If resp is not iterable (e.g. a final response object that wasn't caught above)
-                logger.debug(f"Response type {type(resp)} could not be iterated as a stream. It might be a non-streaming object not handled by specific checks.")
-            except Exception as e:
-                logger.error(f"Error processing potential stream chunk: {e}, chunk was: {getattr(chunk, '__dict__', chunk)}")
-
-
-        return "".join(collected_content)
-
     def _gen_inner(
-        self, query: str, retriever: BaseRetriever, log_context: LogContext
+        self, query: str, log_context: LogContext
     ) -> Generator[Dict, None, None]:
-        # Reset state for this generation call
-        self.plan = ""
-        self.observations = []
-        retrieved_data = self._retriever_search(retriever, query, log_context)
+        """Execute ReAct reasoning loop with planning, action, and observation cycles"""
 
-        if self.user_api_key:
-            tools_dict = self._get_tools(self.user_api_key)
-        else:
-            tools_dict = self._get_user_tools(self.user)
+        self._reset_state()
+
+        tools_dict = (
+            self._get_tools(self.user_api_key)
+            if self.user_api_key
+            else self._get_user_tools(self.user)
+        )
         self._prepare_tools(tools_dict)
 
-        docs_together = "\n".join([doc["text"] for doc in retrieved_data])
-        iterating_reasoning = 0
-        while iterating_reasoning < MAX_ITERATIONS_REASONING:
-            iterating_reasoning += 1
-            # 1. Create Plan
-            logger.info("ReActAgent: Creating plan...")
-            plan_stream = self._create_plan(query, docs_together, log_context)
-            current_plan_parts = []
-            yield {"thought": f"Reasoning... (iteration {iterating_reasoning})\n\n"}
-            for line_chunk in plan_stream:
-                current_plan_parts.append(line_chunk)
-                yield {"thought": line_chunk}
-            self.plan = "".join(current_plan_parts)
-            if self.plan:
-                self.observations.append(f"Plan: {self.plan} Iteration: {iterating_reasoning}")
+        for iteration in range(1, MAX_ITERATIONS_REASONING + 1):
+            yield {"thought": f"Reasoning... (iteration {iteration})\n\n"}
 
+            yield from self._planning_phase(query, log_context)
 
-            max_obs_len = 20000
-            obs_str = "\n".join(self.observations)
-            if len(obs_str) > max_obs_len:
-                obs_str = obs_str[:max_obs_len] + "\n...[observations truncated]"
-            execution_prompt_str = (
-                (self.prompt or "")
-                + f"\n\nFollow this plan:\n{self.plan}"
-                + f"\n\nObservations:\n{obs_str}"
-                + f"\n\nIf there is enough data to complete user query '{query}', Respond with 'SATISFIED' only. Otherwise, continue. Dont Menstion 'SATISFIED' in your response if you are not ready. "
-            )
-            
-            messages = self._build_messages(execution_prompt_str, query, retrieved_data)
-
-            resp_from_llm_gen = self._llm_gen(messages, log_context)
-
-            initial_llm_thought_content = self._extract_content_from_llm_response(resp_from_llm_gen)
-            if initial_llm_thought_content:
-                self.observations.append(f"Initial thought/response: {initial_llm_thought_content}")
-            else:
-                logger.info("ReActAgent: Initial LLM response (before handler) had no textual content (might be only tool calls).")
-            resp_after_handler = self._llm_handler(resp_from_llm_gen, tools_dict, messages, log_context)
-            
-            for tool_call_info in self.tool_calls: # Iterate over self.tool_calls populated by _llm_handler
-                observation_string = (
-                    f"Executed Action: Tool '{tool_call_info.get('tool_name', 'N/A')}' "
-                    f"with arguments '{tool_call_info.get('arguments', '{}')}'. Result: '{str(tool_call_info.get('result', ''))[:200]}...'"
+            if not self.plan:
+                logger.warning(
+                    f"ReActAgent: No plan generated in iteration {iteration}"
                 )
-                self.observations.append(observation_string)
-
-            content_after_handler = self._extract_content_from_llm_response(resp_after_handler)
-            if content_after_handler:
-                self.observations.append(f"Response after tool execution: {content_after_handler}")
-            else:
-                logger.info("ReActAgent: LLM response after handler had no textual content.")
-
-            if log_context:
-                log_context.stacks.append(
-                    {"component": "agent_tool_calls", "data": {"tool_calls": self.tool_calls.copy()}}
-                )
-
-            yield {"sources": retrieved_data}
-
-            display_tool_calls = []
-            for tc in self.tool_calls:
-                cleaned_tc = tc.copy()
-                if len(str(cleaned_tc.get("result", ""))) > 50:
-                    cleaned_tc["result"] = str(cleaned_tc["result"])[:50] + "..."
-                display_tool_calls.append(cleaned_tc)
-            if display_tool_calls:
-                yield {"tool_calls": display_tool_calls}
-            
-            if "SATISFIED" in content_after_handler:
-                logger.info("ReActAgent: LLM satisfied with the plan and data. Stopping reasoning.")
                 break
+            self.observations.append(f"Plan (iteration {iteration}): {self.plan}")
 
-        # 3. Create Final Answer based on all observations
-        final_answer_stream = self._create_final_answer(query, self.observations, log_context)
-        for answer_chunk in final_answer_stream:
-            yield {"answer": answer_chunk}
-        logger.info("ReActAgent: Finished generating final answer.")
+            satisfied = yield from self._execution_phase(query, tools_dict, log_context)
 
-    def _create_plan(
-        self, query: str, docs_data: str, log_context: LogContext = None
-    ) -> Generator[str, None, None]:
-        plan_prompt_filled = planning_prompt_template.replace("{query}", query)
-        if "{summaries}" in plan_prompt_filled:
-            summaries = docs_data if docs_data else "No documents retrieved."
-            plan_prompt_filled = plan_prompt_filled.replace("{summaries}", summaries)
-        plan_prompt_filled = plan_prompt_filled.replace("{prompt}", self.prompt or "")
-        plan_prompt_filled = plan_prompt_filled.replace("{observations}", "\n".join(self.observations))
+            if satisfied:
+                logger.info("ReActAgent: Goal satisfied, stopping reasoning loop")
+                break
+        yield from self._synthesis_phase(query, log_context)
 
-        messages = [{"role": "user", "content": plan_prompt_filled}]
+    def _reset_state(self):
+        """Reset agent state for new query"""
+        self.plan = ""
+        self.observations = []
 
-        plan_stream_from_llm = self.llm.gen_stream(
-            model=self.gpt_model, messages=messages, tools=getattr(self, 'tools', None) # Use self.tools
+    def _planning_phase(
+        self, query: str, log_context: LogContext
+    ) -> Generator[Dict, None, None]:
+        """Generate strategic plan for query"""
+        logger.info("ReActAgent: Creating plan...")
+
+        plan_prompt = self._build_planning_prompt(query)
+        messages = [{"role": "user", "content": plan_prompt}]
+
+        plan_stream = self.llm.gen_stream(
+            model=self.model_id,
+            messages=messages,
+            tools=self.tools if self.tools else None,
         )
+
         if log_context:
-            data = build_stack_data(self.llm)
-            log_context.stacks.append({"component": "planning_llm", "data": data})
+            log_context.stacks.append(
+                {"component": "planning_llm", "data": build_stack_data(self.llm)}
+            )
+        plan_parts = []
+        for chunk in plan_stream:
+            content = self._extract_content(chunk)
+            if content:
+                plan_parts.append(content)
+                yield {"thought": content}
+        self.plan = "".join(plan_parts)
 
-        for chunk in plan_stream_from_llm:
-            content_piece = self._extract_content_from_llm_response(chunk)
-            if content_piece:
-                yield content_piece
+    def _execution_phase(
+        self, query: str, tools_dict: Dict, log_context: LogContext
+    ) -> Generator[bool, None, None]:
+        """Execute plan with tool calls and observations"""
+        execution_prompt = self._build_execution_prompt(query)
+        messages = self._build_messages(execution_prompt, query)
 
-    def _create_final_answer(
-        self, query: str, observations: List[str], log_context: LogContext = None
-    ) -> Generator[str, None, None]:
-        observation_string = "\n".join(observations)
-        max_obs_len = 10000
-        if len(observation_string) > max_obs_len:
-            observation_string = observation_string[:max_obs_len] + "\n...[observations truncated]"
-            logger.warning("ReActAgent: Truncated observations for final answer prompt due to length.")
+        llm_response = self._llm_gen(messages, log_context)
+        initial_content = self._extract_content(llm_response)
 
-        final_answer_prompt_filled = final_prompt_template.format(
-            query=query, observations=observation_string
+        if initial_content:
+            self.observations.append(f"Initial response: {initial_content}")
+        processed_response = self._llm_handler(
+            llm_response, tools_dict, messages, log_context
         )
 
-        messages = [{"role": "user", "content": final_answer_prompt_filled}]
-
-        # Final answer should synthesize, not call tools.
-        final_answer_stream_from_llm = self.llm.gen_stream(
-            model=self.gpt_model, messages=messages, tools=None
-        )
+        for tool_call in self.tool_calls:
+            observation = (
+                f"Executed: {tool_call.get('tool_name', 'Unknown')} "
+                f"with args {tool_call.get('arguments', {})}. "
+                f"Result: {str(tool_call.get('result', ''))[:200]}"
+            )
+            self.observations.append(observation)
+        final_content = self._extract_content(processed_response)
+        if final_content:
+            self.observations.append(f"Response after tools: {final_content}")
         if log_context:
-            data = build_stack_data(self.llm)
-            log_context.stacks.append({"component": "final_answer_llm", "data": data})
+            log_context.stacks.append(
+                {
+                    "component": "agent_tool_calls",
+                    "data": {"tool_calls": self.tool_calls.copy()},
+                }
+            )
+        yield {"sources": self.retrieved_docs}
+        yield {"tool_calls": self._get_truncated_tool_calls()}
 
-        for chunk in final_answer_stream_from_llm:
-            content_piece = self._extract_content_from_llm_response(chunk)
-            if content_piece:
-                yield content_piece
+        return "SATISFIED" in (final_content or "")
+
+    def _synthesis_phase(
+        self, query: str, log_context: LogContext
+    ) -> Generator[Dict, None, None]:
+        """Synthesize final answer from all observations"""
+        logger.info("ReActAgent: Generating final answer...")
+
+        final_prompt = self._build_final_answer_prompt(query)
+        messages = [{"role": "user", "content": final_prompt}]
+
+        final_stream = self.llm.gen_stream(
+            model=self.model_id, messages=messages, tools=None
+        )
+
+        if log_context:
+            log_context.stacks.append(
+                {"component": "final_answer_llm", "data": build_stack_data(self.llm)}
+            )
+        for chunk in final_stream:
+            content = self._extract_content(chunk)
+            if content:
+                yield {"answer": content}
+
+    def _build_planning_prompt(self, query: str) -> str:
+        """Build planning phase prompt"""
+        prompt = PLANNING_PROMPT_TEMPLATE.replace("{query}", query)
+        prompt = prompt.replace("{prompt}", self.prompt or "")
+        prompt = prompt.replace("{summaries}", "")
+        prompt = prompt.replace("{observations}", "\n".join(self.observations))
+        return prompt
+
+    def _build_execution_prompt(self, query: str) -> str:
+        """Build execution phase prompt with plan and observations"""
+        observations_str = "\n".join(self.observations)
+
+        if len(observations_str) > 20000:
+            observations_str = observations_str[:20000] + "\n...[truncated]"
+        return (
+            f"{self.prompt or ''}\n\n"
+            f"Follow this plan:\n{self.plan}\n\n"
+            f"Observations:\n{observations_str}\n\n"
+            f"If sufficient data exists to answer '{query}', respond with 'SATISFIED'. "
+            f"Otherwise, continue executing the plan."
+        )
+
+    def _build_final_answer_prompt(self, query: str) -> str:
+        """Build final synthesis prompt"""
+        observations_str = "\n".join(self.observations)
+
+        if len(observations_str) > 10000:
+            observations_str = observations_str[:10000] + "\n...[truncated]"
+            logger.warning("ReActAgent: Observations truncated for final answer")
+        return FINAL_PROMPT_TEMPLATE.format(query=query, observations=observations_str)
+
+    def _extract_content(self, response: Any) -> str:
+        """Extract text content from various LLM response formats"""
+        if not response:
+            return ""
+        collected = []
+
+        if isinstance(response, str):
+            return response
+        if hasattr(response, "message") and hasattr(response.message, "content"):
+            if response.message.content:
+                return response.message.content
+        if hasattr(response, "choices") and response.choices:
+            if hasattr(response.choices[0], "message"):
+                content = response.choices[0].message.content
+                if content:
+                    return content
+        if hasattr(response, "content") and isinstance(response.content, list):
+            if response.content and hasattr(response.content[0], "text"):
+                return response.content[0].text
+        try:
+            for chunk in response:
+                content_piece = ""
+
+                if hasattr(chunk, "choices") and chunk.choices:
+                    if hasattr(chunk.choices[0], "delta"):
+                        delta_content = chunk.choices[0].delta.content
+                        if delta_content:
+                            content_piece = delta_content
+                elif hasattr(chunk, "type") and chunk.type == "content_block_delta":
+                    if hasattr(chunk, "delta") and hasattr(chunk.delta, "text"):
+                        content_piece = chunk.delta.text
+                elif isinstance(chunk, str):
+                    content_piece = chunk
+                if content_piece:
+                    collected.append(content_piece)
+        except (TypeError, AttributeError):
+            logger.debug(
+                f"Response not iterable or unexpected format: {type(response)}"
+            )
+        except Exception as e:
+            logger.error(f"Error extracting content: {e}")
+        return "".join(collected)

application/agents/tools/todo_list.py

@@ -0,0 +1,321 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+import uuid
+
+from .base import Tool
+from application.core.mongo_db import MongoDB
+from application.core.settings import settings
+
+
+class TodoListTool(Tool):
+    """Todo List
+
+    Manages todo items for users. Supports creating, viewing, updating, and deleting todos.
+    """
+
+    def __init__(self, tool_config: Optional[Dict[str, Any]] = None, user_id: Optional[str] = None) -> None:
+        """Initialize the tool.
+
+        Args:
+            tool_config: Optional tool configuration. Should include:
+                - tool_id: Unique identifier for this todo list tool instance (from user_tools._id)
+                           This ensures each user's tool configuration has isolated todos
+            user_id: The authenticated user's id (should come from decoded_token["sub"]).
+        """
+        self.user_id: Optional[str] = user_id
+
+        # Get tool_id from configuration (passed from user_tools._id in production)
+        # In production, tool_id is the MongoDB ObjectId string from user_tools collection
+        if tool_config and "tool_id" in tool_config:
+            self.tool_id = tool_config["tool_id"]
+        elif user_id:
+            # Fallback for backward compatibility or testing
+            self.tool_id = f"default_{user_id}"
+        else:
+            # Last resort fallback (shouldn't happen in normal use)
+            self.tool_id = str(uuid.uuid4())
+
+        db = MongoDB.get_client()[settings.MONGO_DB_NAME]
+        self.collection = db["todos"]
+
+    # -----------------------------
+    # Action implementations
+    # -----------------------------
+    def execute_action(self, action_name: str, **kwargs: Any) -> str:
+        """Execute an action by name.
+
+        Args:
+            action_name: One of list, create, get, update, complete, delete.
+            **kwargs: Parameters for the action.
+
+        Returns:
+            A human-readable string result.
+        """
+        if not self.user_id:
+            return "Error: TodoListTool requires a valid user_id."
+
+        if action_name == "list":
+            return self._list()
+
+        if action_name == "create":
+            return self._create(kwargs.get("title", ""))
+
+        if action_name == "get":
+            return self._get(kwargs.get("todo_id"))
+
+        if action_name == "update":
+            return self._update(
+                kwargs.get("todo_id"),
+                kwargs.get("title", "")
+            )
+
+        if action_name == "complete":
+            return self._complete(kwargs.get("todo_id"))
+
+        if action_name == "delete":
+            return self._delete(kwargs.get("todo_id"))
+
+        return f"Unknown action: {action_name}"
+
+    def get_actions_metadata(self) -> List[Dict[str, Any]]:
+        """Return JSON metadata describing supported actions for tool schemas."""
+        return [
+            {
+                "name": "list",
+                "description": "List all todos for the user.",
+                "parameters": {"type": "object", "properties": {}},
+            },
+            {
+                "name": "create",
+                "description": "Create a new todo item.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "title": {
+                            "type": "string",
+                            "description": "Title of the todo item."
+                        }
+                    },
+                    "required": ["title"],
+                },
+            },
+            {
+                "name": "get",
+                "description": "Get a specific todo by ID.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "todo_id": {
+                            "type": "integer",
+                            "description": "The ID of the todo to retrieve."
+                        }
+                    },
+                    "required": ["todo_id"],
+                },
+            },
+            {
+                "name": "update",
+                "description": "Update a todo's title by ID.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "todo_id": {
+                            "type": "integer",
+                            "description": "The ID of the todo to update."
+                        },
+                        "title": {
+                            "type": "string",
+                            "description": "The new title for the todo."
+                        }
+                    },
+                    "required": ["todo_id", "title"],
+                },
+            },
+            {
+                "name": "complete",
+                "description": "Mark a todo as completed.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "todo_id": {
+                            "type": "integer",
+                            "description": "The ID of the todo to mark as completed."
+                        }
+                    },
+                    "required": ["todo_id"],
+                },
+            },
+            {
+                "name": "delete",
+                "description": "Delete a specific todo by ID.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "todo_id": {
+                            "type": "integer",
+                            "description": "The ID of the todo to delete."
+                        }
+                    },
+                    "required": ["todo_id"],
+                },
+            },
+        ]
+
+    def get_config_requirements(self) -> Dict[str, Any]:
+        """Return configuration requirements."""
+        return {}
+
+    # -----------------------------
+    # Internal helpers
+    # -----------------------------
+    def _coerce_todo_id(self, value: Optional[Any]) -> Optional[int]:
+        """Convert todo identifiers to sequential integers."""
+        if value is None:
+            return None
+
+        if isinstance(value, int):
+            return value if value > 0 else None
+
+        if isinstance(value, str):
+            stripped = value.strip()
+            if stripped.isdigit():
+                numeric_value = int(stripped)
+                return numeric_value if numeric_value > 0 else None
+
+        return None
+
+    def _get_next_todo_id(self) -> int:
+        """Get the next sequential todo_id for this user and tool.
+
+        Returns a simple integer (1, 2, 3, ...) scoped to this user/tool.
+        With 5-10 todos max, scanning is negligible.
+        """
+        # Find all todos for this user/tool and get their IDs
+        todos = list(self.collection.find(
+            {"user_id": self.user_id, "tool_id": self.tool_id},
+            {"todo_id": 1}
+        ))
+
+        # Find the maximum todo_id
+        max_id = 0
+        for todo in todos:
+            todo_id = self._coerce_todo_id(todo.get("todo_id"))
+            if todo_id is not None:
+                max_id = max(max_id, todo_id)
+
+        return max_id + 1
+
+    def _list(self) -> str:
+        """List all todos for the user."""
+        cursor = self.collection.find({"user_id": self.user_id, "tool_id": self.tool_id})
+        todos = list(cursor)
+
+        if not todos:
+            return "No todos found."
+
+        result_lines = ["Todos:"]
+        for doc in todos:
+            todo_id = doc.get("todo_id")
+            title = doc.get("title", "Untitled")
+            status = doc.get("status", "open")
+
+            line = f"[{todo_id}] {title} ({status})"
+            result_lines.append(line)
+
+        return "\n".join(result_lines)
+
+    def _create(self, title: str) -> str:
+        """Create a new todo item."""
+        title = (title or "").strip()
+        if not title:
+            return "Error: Title is required."
+
+        now = datetime.now()
+        todo_id = self._get_next_todo_id()
+
+        doc = {
+            "todo_id": todo_id,
+            "user_id": self.user_id,
+            "tool_id": self.tool_id,
+            "title": title,
+            "status": "open",
+            "created_at": now,
+            "updated_at": now,
+        }
+        self.collection.insert_one(doc)
+        return f"Todo created with ID {todo_id}: {title}"
+
+    def _get(self, todo_id: Optional[Any]) -> str:
+        """Get a specific todo by ID."""
+        parsed_todo_id = self._coerce_todo_id(todo_id)
+        if parsed_todo_id is None:
+            return "Error: todo_id must be a positive integer."
+
+        doc = self.collection.find_one({
+            "user_id": self.user_id,
+            "tool_id": self.tool_id,
+            "todo_id": parsed_todo_id
+        })
+
+        if not doc:
+            return f"Error: Todo with ID {parsed_todo_id} not found."
+
+        title = doc.get("title", "Untitled")
+        status = doc.get("status", "open")
+
+        result = f"Todo [{parsed_todo_id}]:\nTitle: {title}\nStatus: {status}"
+
+        return result
+
+    def _update(self, todo_id: Optional[Any], title: str) -> str:
+        """Update a todo's title by ID."""
+        parsed_todo_id = self._coerce_todo_id(todo_id)
+        if parsed_todo_id is None:
+            return "Error: todo_id must be a positive integer."
+
+        title = (title or "").strip()
+        if not title:
+            return "Error: Title is required."
+
+        result = self.collection.update_one(
+            {"user_id": self.user_id, "tool_id": self.tool_id, "todo_id": parsed_todo_id},
+            {"$set": {"title": title, "updated_at": datetime.now()}}
+        )
+
+        if result.matched_count == 0:
+            return f"Error: Todo with ID {parsed_todo_id} not found."
+
+        return f"Todo {parsed_todo_id} updated to: {title}"
+
+    def _complete(self, todo_id: Optional[Any]) -> str:
+        """Mark a todo as completed."""
+        parsed_todo_id = self._coerce_todo_id(todo_id)
+        if parsed_todo_id is None:
+            return "Error: todo_id must be a positive integer."
+
+        result = self.collection.update_one(
+            {"user_id": self.user_id, "tool_id": self.tool_id, "todo_id": parsed_todo_id},
+            {"$set": {"status": "completed", "updated_at": datetime.now()}}
+        )
+
+        if result.matched_count == 0:
+            return f"Error: Todo with ID {parsed_todo_id} not found."
+
+        return f"Todo {parsed_todo_id} marked as completed."
+
+    def _delete(self, todo_id: Optional[Any]) -> str:
+        """Delete a specific todo by ID."""
+        parsed_todo_id = self._coerce_todo_id(todo_id)
+        if parsed_todo_id is None:
+            return "Error: todo_id must be a positive integer."
+
+        result = self.collection.delete_one({
+            "user_id": self.user_id,
+            "tool_id": self.tool_id,
+            "todo_id": parsed_todo_id
+        })
+
+        if result.deleted_count == 0:
+            return f"Error: Todo with ID {parsed_todo_id} not found."
+
+        return f"Todo {parsed_todo_id} deleted."

application/agents/tools/tool_action_parser.py

@@ -20,20 +20,24 @@ class ToolActionParser:
         try:
             call_args = json.loads(call.arguments)
             tool_parts = call.name.split("_")
-            
+
             # If the tool name doesn't contain an underscore, it's likely a hallucinated tool
             if len(tool_parts) < 2:
-                logger.warning(f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id")
+                logger.warning(
+                    f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id"
+                )
                 return None, None, None
-                
+
             tool_id = tool_parts[-1]
             action_name = "_".join(tool_parts[:-1])
-            
+
             # Validate that tool_id looks like a numerical ID
             if not tool_id.isdigit():
-                logger.warning(f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call.")
-                
-        except (AttributeError, TypeError) as e:
+                logger.warning(
+                    f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call."
+                )
+
+        except (AttributeError, TypeError, json.JSONDecodeError) as e:
             logger.error(f"Error parsing OpenAI LLM call: {e}")
             return None, None, None
         return tool_id, action_name, call_args
@@ -42,19 +46,23 @@ class ToolActionParser:
         try:
             call_args = call.arguments
             tool_parts = call.name.split("_")
-            
+
             # If the tool name doesn't contain an underscore, it's likely a hallucinated tool
             if len(tool_parts) < 2:
-                logger.warning(f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id")
+                logger.warning(
+                    f"Invalid tool name format: {call.name}. Expected format: action_name_tool_id"
+                )
                 return None, None, None
-                
+
             tool_id = tool_parts[-1]
             action_name = "_".join(tool_parts[:-1])
-            
+
             # Validate that tool_id looks like a numerical ID
             if not tool_id.isdigit():
-                logger.warning(f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call.")
-                
+                logger.warning(
+                    f"Tool ID '{tool_id}' is not numerical. This might be a hallucinated tool call."
+                )
+
         except (AttributeError, TypeError) as e:
             logger.error(f"Error parsing Google LLM call: {e}")
             return None, None, None

application/agents/tools/tool_manager.py

@@ -28,7 +28,7 @@ class ToolManager:
         module = importlib.import_module(f"application.agents.tools.{tool_name}")
         for member_name, obj in inspect.getmembers(module, inspect.isclass):
             if issubclass(obj, Tool) and obj is not Tool:
-                if tool_name in {"mcp_tool", "notes", "memory"} and user_id:
+                if tool_name in {"mcp_tool", "notes", "memory", "todo_list"} and user_id:
                     return obj(tool_config, user_id)
                 else:
                     return obj(tool_config)
@@ -36,7 +36,7 @@ class ToolManager:
     def execute_action(self, tool_name, action_name, user_id=None, **kwargs):
         if tool_name not in self.tools:
             raise ValueError(f"Tool '{tool_name}' not loaded")
-        if tool_name in {"mcp_tool", "memory"} and user_id:
+        if tool_name in {"mcp_tool", "memory", "todo_list"} and user_id:
             tool_config = self.config.get(tool_name, {})
             tool = self.load_tool(tool_name, tool_config, user_id)
             return tool.execute_action(action_name, **kwargs)

application/api/answer/routes/answer.py

@@ -54,6 +54,14 @@ class AnswerResource(Resource, BaseAnswerResource):
                 default=True,
                 description="Whether to save the conversation",
             ),
+            "model_id": fields.String(
+                required=False,
+                description="Model ID to use for this request",
+            ),
+            "passthrough": fields.Raw(
+                required=False,
+                description="Dynamic parameters to inject into prompt template",
+            ),
         },
     )
 
@@ -69,19 +77,31 @@ class AnswerResource(Resource, BaseAnswerResource):
             processor.initialize()
             if not processor.decoded_token:
                 return make_response({"error": "Unauthorized"}, 401)
-            agent = processor.create_agent()
-            retriever = processor.create_retriever()
+
+            docs_together, docs_list = processor.pre_fetch_docs(
+                data.get("question", "")
+            )
+            tools_data = processor.pre_fetch_tools()
+
+            agent = processor.create_agent(
+                docs_together=docs_together,
+                docs=docs_list,
+                tools_data=tools_data,
+            )
+
+            if error := self.check_usage(processor.agent_config):
+                return error
 
             stream = self.complete_stream(
                 question=data["question"],
                 agent=agent,
-                retriever=retriever,
                 conversation_id=processor.conversation_id,
                 user_api_key=processor.agent_config.get("user_api_key"),
                 decoded_token=processor.decoded_token,
                 isNoneDoc=data.get("isNoneDoc"),
                 index=None,
                 should_save_conversation=data.get("save_conversation", True),
+                model_id=processor.model_id,
             )
             stream_result = self.process_response_stream(stream)
 

application/api/answer/routes/base.py

@@ -3,15 +3,20 @@ import json
 import logging
 from typing import Any, Dict, Generator, List, Optional
 
-from flask import Response
+from flask import jsonify, make_response, Response
 from flask_restx import Namespace
 
 from application.api.answer.services.conversation_service import ConversationService
+from application.core.model_utils import (
+    get_api_key_for_provider,
+    get_default_model_id,
+    get_provider_from_model_id,
+)
 
 from application.core.mongo_db import MongoDB
 from application.core.settings import settings
 from application.llm.llm_creator import LLMCreator
-from application.utils import check_required_fields, get_gpt_model
+from application.utils import check_required_fields
 
 logger = logging.getLogger(__name__)
 
@@ -25,8 +30,9 @@ class BaseAnswerResource:
     def __init__(self):
         mongo = MongoDB.get_client()
         db = mongo[settings.MONGO_DB_NAME]
+        self.db = db
         self.user_logs_collection = db["user_logs"]
-        self.gpt_model = get_gpt_model()
+        self.default_model_id = get_default_model_id()
         self.conversation_service = ConversationService()
 
     def validate_request(
@@ -40,11 +46,104 @@ class BaseAnswerResource:
             return missing_fields
         return None
 
+    def check_usage(self, agent_config: Dict) -> Optional[Response]:
+        """Check if there is a usage limit and if it is exceeded
+
+        Args:
+            agent_config: The config dict of agent instance
+
+        Returns:
+            None or Response if either of limits exceeded.
+
+        """
+        api_key = agent_config.get("user_api_key")
+        if not api_key:
+            return None
+        agents_collection = self.db["agents"]
+        agent = agents_collection.find_one({"key": api_key})
+
+        if not agent:
+            return make_response(
+                jsonify({"success": False, "message": "Invalid API key."}), 401
+            )
+        limited_token_mode_raw = agent.get("limited_token_mode", False)
+        limited_request_mode_raw = agent.get("limited_request_mode", False)
+
+        limited_token_mode = (
+            limited_token_mode_raw
+            if isinstance(limited_token_mode_raw, bool)
+            else limited_token_mode_raw == "True"
+        )
+        limited_request_mode = (
+            limited_request_mode_raw
+            if isinstance(limited_request_mode_raw, bool)
+            else limited_request_mode_raw == "True"
+        )
+
+        token_limit = int(
+            agent.get("token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"])
+        )
+        request_limit = int(
+            agent.get("request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"])
+        )
+
+        token_usage_collection = self.db["token_usage"]
+
+        end_date = datetime.datetime.now()
+        start_date = end_date - datetime.timedelta(hours=24)
+
+        match_query = {
+            "timestamp": {"$gte": start_date, "$lte": end_date},
+            "api_key": api_key,
+        }
+
+        if limited_token_mode:
+            token_pipeline = [
+                {"$match": match_query},
+                {
+                    "$group": {
+                        "_id": None,
+                        "total_tokens": {
+                            "$sum": {"$add": ["$prompt_tokens", "$generated_tokens"]}
+                        },
+                    }
+                },
+            ]
+            token_result = list(token_usage_collection.aggregate(token_pipeline))
+            daily_token_usage = token_result[0]["total_tokens"] if token_result else 0
+        else:
+            daily_token_usage = 0
+        if limited_request_mode:
+            daily_request_usage = token_usage_collection.count_documents(match_query)
+        else:
+            daily_request_usage = 0
+        if not limited_token_mode and not limited_request_mode:
+            return None
+        token_exceeded = (
+            limited_token_mode and token_limit > 0 and daily_token_usage >= token_limit
+        )
+        request_exceeded = (
+            limited_request_mode
+            and request_limit > 0
+            and daily_request_usage >= request_limit
+        )
+
+        if token_exceeded or request_exceeded:
+            return make_response(
+                jsonify(
+                    {
+                        "success": False,
+                        "message": "Exceeding usage limit, please try again later.",
+                    }
+                ),
+                429,
+            )
+        return None
+
     def complete_stream(
         self,
         question: str,
         agent: Any,
-        retriever: Any,
         conversation_id: Optional[str],
         user_api_key: Optional[str],
         decoded_token: Dict[str, Any],
@@ -55,6 +154,7 @@ class BaseAnswerResource:
         agent_id: Optional[str] = None,
         is_shared_usage: bool = False,
         shared_token: Optional[str] = None,
+        model_id: Optional[str] = None,
     ) -> Generator[str, None, None]:
         """
         Generator function that streams the complete conversation response.
@@ -73,6 +173,8 @@ class BaseAnswerResource:
             agent_id: ID of agent used
             is_shared_usage: Flag for shared agent usage
             shared_token: Token for shared agent
+            model_id: Model ID used for the request
+            retrieved_docs: Pre-fetched documents for sources (optional)
 
         Yields:
             Server-sent event strings
@@ -83,7 +185,7 @@ class BaseAnswerResource:
             schema_info = None
             structured_chunks = []
 
-            for line in agent.gen(query=question, retriever=retriever):
+            for line in agent.gen(query=question):
                 if "answer" in line:
                     response_full += str(line["answer"])
                     if line.get("structured"):
@@ -119,7 +221,6 @@ class BaseAnswerResource:
                 elif "type" in line:
                     data = json.dumps(line)
                     yield f"data: {data}\n\n"
-
             if is_structured and structured_chunks:
                 structured_data = {
                     "type": "structured_answer",
@@ -129,15 +230,22 @@ class BaseAnswerResource:
                 }
                 data = json.dumps(structured_data)
                 yield f"data: {data}\n\n"
-
             if isNoneDoc:
                 for doc in source_log_docs:
                     doc["source"] = "None"
+            provider = (
+                get_provider_from_model_id(model_id)
+                if model_id
+                else settings.LLM_PROVIDER
+            )
+            system_api_key = get_api_key_for_provider(provider or settings.LLM_PROVIDER)
+
             llm = LLMCreator.create_llm(
-                settings.LLM_PROVIDER,
-                api_key=settings.API_KEY,
+                provider or settings.LLM_PROVIDER,
+                api_key=system_api_key,
                 user_api_key=user_api_key,
                 decoded_token=decoded_token,
+                model_id=model_id,
             )
 
             if should_save_conversation:
@@ -149,7 +257,7 @@ class BaseAnswerResource:
                     source_log_docs,
                     tool_calls,
                     llm,
-                    self.gpt_model,
+                    model_id or self.default_model_id,
                     decoded_token,
                     index=index,
                     api_key=user_api_key,
@@ -158,13 +266,32 @@ class BaseAnswerResource:
                     shared_token=shared_token,
                     attachment_ids=attachment_ids,
                 )
+                # Persist compression metadata/summary if it exists and wasn't saved mid-execution
+                compression_meta = getattr(agent, "compression_metadata", None)
+                compression_saved = getattr(agent, "compression_saved", False)
+                if conversation_id and compression_meta and not compression_saved:
+                    try:
+                        self.conversation_service.update_compression_metadata(
+                            conversation_id, compression_meta
+                        )
+                        self.conversation_service.append_compression_message(
+                            conversation_id, compression_meta
+                        )
+                        agent.compression_saved = True
+                        logger.info(
+                            f"Persisted compression metadata for conversation {conversation_id}"
+                        )
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to persist compression metadata: {str(e)}",
+                            exc_info=True,
+                        )
             else:
                 conversation_id = None
             id_data = {"type": "id", "id": str(conversation_id)}
             data = json.dumps(id_data)
             yield f"data: {data}\n\n"
 
-            retriever_params = retriever.get_params()
             log_data = {
                 "action": "stream_answer",
                 "level": "info",
@@ -173,7 +300,6 @@ class BaseAnswerResource:
                 "question": question,
                 "response": response_full,
                 "sources": source_log_docs,
-                "retriever_params": retriever_params,
                 "attachments": attachment_ids,
                 "timestamp": datetime.datetime.now(datetime.timezone.utc),
             }
@@ -181,18 +307,71 @@ class BaseAnswerResource:
                 log_data["structured_output"] = True
                 if schema_info:
                     log_data["schema"] = schema_info
-  
-            # clean up text fields to be no longer than 10000 characters
+            # Clean up text fields to be no longer than 10000 characters
+
             for key, value in log_data.items():
                 if isinstance(value, str) and len(value) > 10000:
                     log_data[key] = value[:10000]
-            
             self.user_logs_collection.insert_one(log_data)
 
-            # End of stream
-
             data = json.dumps({"type": "end"})
             yield f"data: {data}\n\n"
+        except GeneratorExit:
+            logger.info(f"Stream aborted by client for question: {question[:50]}... ")
+            # Save partial response
+
+            if should_save_conversation and response_full:
+                try:
+                    if isNoneDoc:
+                        for doc in source_log_docs:
+                            doc["source"] = "None"
+                    llm = LLMCreator.create_llm(
+                        settings.LLM_PROVIDER,
+                        api_key=settings.API_KEY,
+                        user_api_key=user_api_key,
+                        decoded_token=decoded_token,
+                    )
+                    self.conversation_service.save_conversation(
+                        conversation_id,
+                        question,
+                        response_full,
+                        thought,
+                        source_log_docs,
+                        tool_calls,
+                        llm,
+                        model_id or self.default_model_id,
+                        decoded_token,
+                        index=index,
+                        api_key=user_api_key,
+                        agent_id=agent_id,
+                        is_shared_usage=is_shared_usage,
+                        shared_token=shared_token,
+                        attachment_ids=attachment_ids,
+                    )
+                    compression_meta = getattr(agent, "compression_metadata", None)
+                    compression_saved = getattr(agent, "compression_saved", False)
+                    if conversation_id and compression_meta and not compression_saved:
+                        try:
+                            self.conversation_service.update_compression_metadata(
+                                conversation_id, compression_meta
+                            )
+                            self.conversation_service.append_compression_message(
+                                conversation_id, compression_meta
+                            )
+                            agent.compression_saved = True
+                            logger.info(
+                                f"Persisted compression metadata for conversation {conversation_id} (partial stream)"
+                            )
+                        except Exception as e:
+                            logger.error(
+                                f"Failed to persist compression metadata (partial stream): {str(e)}",
+                                exc_info=True,
+                            )
+                except Exception as e:
+                    logger.error(
+                        f"Error saving partial response: {str(e)}", exc_info=True
+                    )
+            raise
         except Exception as e:
             logger.error(f"Error in stream: {str(e)}", exc_info=True)
             data = json.dumps(
@@ -236,7 +415,7 @@ class BaseAnswerResource:
                     thought = event["thought"]
                 elif event["type"] == "error":
                     logger.error(f"Error from stream: {event['error']}")
-                    return None, None, None, None, event["error"]
+                    return None, None, None, None, event["error"], None
                 elif event["type"] == "end":
                     stream_ended = True
             except (json.JSONDecodeError, KeyError) as e:
@@ -244,8 +423,7 @@ class BaseAnswerResource:
                 continue
         if not stream_ended:
             logger.error("Stream ended unexpectedly without an 'end' event.")
-            return None, None, None, None, "Stream ended unexpectedly"
-
+            return None, None, None, None, "Stream ended unexpectedly", None
         result = (
             conversation_id,
             response_full,
@@ -257,7 +435,6 @@ class BaseAnswerResource:
 
         if is_structured:
             result = result + ({"structured": True, "schema": schema_info},)
-
         return result
 
     def error_stream_generate(self, err_response):

application/api/answer/routes/stream.py

@@ -57,9 +57,17 @@ class StreamResource(Resource, BaseAnswerResource):
                 default=True,
                 description="Whether to save the conversation",
             ),
+            "model_id": fields.String(
+                required=False,
+                description="Model ID to use for this request",
+            ),
             "attachments": fields.List(
                 fields.String, required=False, description="List of attachment IDs"
             ),
+            "passthrough": fields.Raw(
+                required=False,
+                description="Dynamic parameters to inject into prompt template",
+            ),
         },
     )
 
@@ -73,14 +81,20 @@ class StreamResource(Resource, BaseAnswerResource):
         processor = StreamProcessor(data, decoded_token)
         try:
             processor.initialize()
-            agent = processor.create_agent()
-            retriever = processor.create_retriever()
 
+            docs_together, docs_list = processor.pre_fetch_docs(data["question"])
+            tools_data = processor.pre_fetch_tools()
+
+            agent = processor.create_agent(
+                docs_together=docs_together, docs=docs_list, tools_data=tools_data
+            )
+
+            if error := self.check_usage(processor.agent_config):
+                return error
             return Response(
                 self.complete_stream(
                     question=data["question"],
                     agent=agent,
-                    retriever=retriever,
                     conversation_id=processor.conversation_id,
                     user_api_key=processor.agent_config.get("user_api_key"),
                     decoded_token=processor.decoded_token,
@@ -91,6 +105,7 @@ class StreamResource(Resource, BaseAnswerResource):
                     agent_id=data.get("agent_id"),
                     is_shared_usage=processor.is_shared_usage,
                     shared_token=processor.shared_token,
+                    model_id=processor.model_id,
                 ),
                 mimetype="text/event-stream",
             )

application/api/answer/services/compression/__init__.py

@@ -0,0 +1,20 @@
+"""
+Compression module for managing conversation context compression.
+
+"""
+
+from application.api.answer.services.compression.orchestrator import (
+    CompressionOrchestrator,
+)
+from application.api.answer.services.compression.service import CompressionService
+from application.api.answer.services.compression.types import (
+    CompressionResult,
+    CompressionMetadata,
+)
+
+__all__ = [
+    "CompressionOrchestrator",
+    "CompressionService",
+    "CompressionResult",
+    "CompressionMetadata",
+]

application/api/answer/services/compression/message_builder.py

@@ -0,0 +1,234 @@
+"""Message reconstruction utilities for compression."""
+
+import logging
+import uuid
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class MessageBuilder:
+    """Builds message arrays from compressed context."""
+
+    @staticmethod
+    def build_from_compressed_context(
+        system_prompt: str,
+        compressed_summary: Optional[str],
+        recent_queries: List[Dict],
+        include_tool_calls: bool = False,
+        context_type: str = "pre_request",
+    ) -> List[Dict]:
+        """
+        Build messages from compressed context.
+
+        Args:
+            system_prompt: Original system prompt
+            compressed_summary: Compressed summary (if any)
+            recent_queries: Recent uncompressed queries
+            include_tool_calls: Whether to include tool calls from history
+            context_type: Type of context ('pre_request' or 'mid_execution')
+
+        Returns:
+            List of message dicts ready for LLM
+        """
+        # Append compression summary to system prompt if present
+        if compressed_summary:
+            system_prompt = MessageBuilder._append_compression_context(
+                system_prompt, compressed_summary, context_type
+            )
+
+        messages = [{"role": "system", "content": system_prompt}]
+
+        # Add recent history
+        for query in recent_queries:
+            if "prompt" in query and "response" in query:
+                messages.append({"role": "user", "content": query["prompt"]})
+                messages.append({"role": "assistant", "content": query["response"]})
+
+            # Add tool calls from history if present
+            if include_tool_calls and "tool_calls" in query:
+                for tool_call in query["tool_calls"]:
+                    call_id = tool_call.get("call_id") or str(uuid.uuid4())
+
+                    function_call_dict = {
+                        "function_call": {
+                            "name": tool_call.get("action_name"),
+                            "args": tool_call.get("arguments"),
+                            "call_id": call_id,
+                        }
+                    }
+                    function_response_dict = {
+                        "function_response": {
+                            "name": tool_call.get("action_name"),
+                            "response": {"result": tool_call.get("result")},
+                            "call_id": call_id,
+                        }
+                    }
+
+                    messages.append(
+                        {"role": "assistant", "content": [function_call_dict]}
+                    )
+                    messages.append(
+                        {"role": "tool", "content": [function_response_dict]}
+                    )
+
+        # If no recent queries (everything was compressed), add a continuation user message
+        if len(recent_queries) == 0 and compressed_summary:
+            messages.append({
+                "role": "user",
+                "content": "Please continue with the remaining tasks based on the context above."
+            })
+            logger.info("Added continuation user message to maintain proper turn-taking after full compression")
+
+        return messages
+
+    @staticmethod
+    def _append_compression_context(
+        system_prompt: str, compressed_summary: str, context_type: str = "pre_request"
+    ) -> str:
+        """
+        Append compression context to system prompt.
+
+        Args:
+            system_prompt: Original system prompt
+            compressed_summary: Summary to append
+            context_type: Type of compression context
+
+        Returns:
+            Updated system prompt
+        """
+        # Remove existing compression context if present
+        if "This session is being continued" in system_prompt or "Context window limit reached" in system_prompt:
+            parts = system_prompt.split("\n\n---\n\n")
+            system_prompt = parts[0]
+
+        # Build appropriate context message based on type
+        if context_type == "mid_execution":
+            context_message = (
+                "\n\n---\n\n"
+                "Context window limit reached during execution. "
+                "Previous conversation has been compressed to fit within limits. "
+                "The conversation is summarized below:\n\n"
+                f"{compressed_summary}"
+            )
+        else:  # pre_request
+            context_message = (
+                "\n\n---\n\n"
+                "This session is being continued from a previous conversation that "
+                "has been compressed to fit within context limits. "
+                "The conversation is summarized below:\n\n"
+                f"{compressed_summary}"
+            )
+
+        return system_prompt + context_message
+
+    @staticmethod
+    def rebuild_messages_after_compression(
+        messages: List[Dict],
+        compressed_summary: Optional[str],
+        recent_queries: List[Dict],
+        include_current_execution: bool = False,
+        include_tool_calls: bool = False,
+    ) -> Optional[List[Dict]]:
+        """
+        Rebuild the message list after compression so tool execution can continue.
+
+        Args:
+            messages: Original message list
+            compressed_summary: Compressed summary
+            recent_queries: Recent uncompressed queries
+            include_current_execution: Whether to preserve current execution messages
+            include_tool_calls: Whether to include tool calls from history
+
+        Returns:
+            Rebuilt message list or None if failed
+        """
+        # Find the system message
+        system_message = next(
+            (msg for msg in messages if msg.get("role") == "system"), None
+        )
+        if not system_message:
+            logger.warning("No system message found in messages list")
+            return None
+
+        # Update system message with compressed summary
+        if compressed_summary:
+            content = system_message.get("content", "")
+            system_message["content"] = MessageBuilder._append_compression_context(
+                content, compressed_summary, "mid_execution"
+            )
+            logger.info(
+                "Appended compression summary to system prompt (truncated): %s",
+                (
+                    compressed_summary[:500] + "..."
+                    if len(compressed_summary) > 500
+                    else compressed_summary
+                ),
+            )
+
+        rebuilt_messages = [system_message]
+
+        # Add recent history from compressed context
+        for query in recent_queries:
+            if "prompt" in query and "response" in query:
+                rebuilt_messages.append({"role": "user", "content": query["prompt"]})
+                rebuilt_messages.append(
+                    {"role": "assistant", "content": query["response"]}
+                )
+
+            # Add tool calls from history if present
+            if include_tool_calls and "tool_calls" in query:
+                for tool_call in query["tool_calls"]:
+                    call_id = tool_call.get("call_id") or str(uuid.uuid4())
+
+                    function_call_dict = {
+                        "function_call": {
+                            "name": tool_call.get("action_name"),
+                            "args": tool_call.get("arguments"),
+                            "call_id": call_id,
+                        }
+                    }
+                    function_response_dict = {
+                        "function_response": {
+                            "name": tool_call.get("action_name"),
+                            "response": {"result": tool_call.get("result")},
+                            "call_id": call_id,
+                        }
+                    }
+
+                    rebuilt_messages.append(
+                        {"role": "assistant", "content": [function_call_dict]}
+                    )
+                    rebuilt_messages.append(
+                        {"role": "tool", "content": [function_response_dict]}
+                    )
+
+        # If no recent queries (everything was compressed), add a continuation user message
+        if len(recent_queries) == 0 and compressed_summary:
+            rebuilt_messages.append({
+                "role": "user",
+                "content": "Please continue with the remaining tasks based on the context above."
+            })
+            logger.info("Added continuation user message to maintain proper turn-taking after full compression")
+
+        if include_current_execution:
+            # Preserve any messages that were added during the current execution cycle
+            recent_msg_count = 1  # system message
+            for query in recent_queries:
+                if "prompt" in query and "response" in query:
+                    recent_msg_count += 2
+                if "tool_calls" in query:
+                    recent_msg_count += len(query["tool_calls"]) * 2
+
+            if len(messages) > recent_msg_count:
+                current_execution_messages = messages[recent_msg_count:]
+                rebuilt_messages.extend(current_execution_messages)
+                logger.info(
+                    f"Preserved {len(current_execution_messages)} messages from current execution cycle"
+                )
+
+        logger.info(
+            f"Messages rebuilt: {len(messages)} → {len(rebuilt_messages)} messages. "
+            f"Ready to continue tool execution."
+        )
+        return rebuilt_messages

application/api/answer/services/compression/orchestrator.py

@@ -0,0 +1,232 @@
+"""High-level compression orchestration."""
+
+import logging
+from typing import Any, Dict, Optional
+
+from application.api.answer.services.compression.service import CompressionService
+from application.api.answer.services.compression.threshold_checker import (
+    CompressionThresholdChecker,
+)
+from application.api.answer.services.compression.types import CompressionResult
+from application.api.answer.services.conversation_service import ConversationService
+from application.core.model_utils import (
+    get_api_key_for_provider,
+    get_provider_from_model_id,
+)
+from application.core.settings import settings
+from application.llm.llm_creator import LLMCreator
+
+logger = logging.getLogger(__name__)
+
+
+class CompressionOrchestrator:
+    """
+    Facade for compression operations.
+
+    Coordinates between all compression components and provides
+    a simple interface for callers.
+    """
+
+    def __init__(
+        self,
+        conversation_service: ConversationService,
+        threshold_checker: Optional[CompressionThresholdChecker] = None,
+    ):
+        """
+        Initialize orchestrator.
+
+        Args:
+            conversation_service: Service for DB operations
+            threshold_checker: Custom threshold checker (optional)
+        """
+        self.conversation_service = conversation_service
+        self.threshold_checker = threshold_checker or CompressionThresholdChecker()
+
+    def compress_if_needed(
+        self,
+        conversation_id: str,
+        user_id: str,
+        model_id: str,
+        decoded_token: Dict[str, Any],
+        current_query_tokens: int = 500,
+    ) -> CompressionResult:
+        """
+        Check if compression is needed and perform it if so.
+
+        This is the main entry point for compression operations.
+
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID
+            model_id: Model being used for conversation
+            decoded_token: User's decoded JWT token
+            current_query_tokens: Estimated tokens for current query
+
+        Returns:
+            CompressionResult with summary and recent queries
+        """
+        try:
+            # Load conversation
+            conversation = self.conversation_service.get_conversation(
+                conversation_id, user_id
+            )
+
+            if not conversation:
+                logger.warning(
+                    f"Conversation {conversation_id} not found for user {user_id}"
+                )
+                return CompressionResult.failure("Conversation not found")
+
+            # Check if compression is needed
+            if not self.threshold_checker.should_compress(
+                conversation, model_id, current_query_tokens
+            ):
+                # No compression needed, return full history
+                queries = conversation.get("queries", [])
+                return CompressionResult.success_no_compression(queries)
+
+            # Perform compression
+            return self._perform_compression(
+                conversation_id, conversation, model_id, decoded_token
+            )
+
+        except Exception as e:
+            logger.error(
+                f"Error in compress_if_needed: {str(e)}", exc_info=True
+            )
+            return CompressionResult.failure(str(e))
+
+    def _perform_compression(
+        self,
+        conversation_id: str,
+        conversation: Dict[str, Any],
+        model_id: str,
+        decoded_token: Dict[str, Any],
+    ) -> CompressionResult:
+        """
+        Perform the actual compression operation.
+
+        Args:
+            conversation_id: Conversation ID
+            conversation: Conversation document
+            model_id: Model ID for conversation
+            decoded_token: User token
+
+        Returns:
+            CompressionResult
+        """
+        try:
+            # Determine which model to use for compression
+            compression_model = (
+                settings.COMPRESSION_MODEL_OVERRIDE
+                if settings.COMPRESSION_MODEL_OVERRIDE
+                else model_id
+            )
+
+            # Get provider and API key for compression model
+            provider = get_provider_from_model_id(compression_model)
+            api_key = get_api_key_for_provider(provider)
+
+            # Create compression LLM
+            compression_llm = LLMCreator.create_llm(
+                provider,
+                api_key=api_key,
+                user_api_key=None,
+                decoded_token=decoded_token,
+                model_id=compression_model,
+            )
+
+            # Create compression service with DB update capability
+            compression_service = CompressionService(
+                llm=compression_llm,
+                model_id=compression_model,
+                conversation_service=self.conversation_service,
+            )
+
+            # Compress all queries up to the latest
+            queries_count = len(conversation.get("queries", []))
+            compress_up_to = queries_count - 1
+
+            if compress_up_to < 0:
+                logger.warning("No queries to compress")
+                return CompressionResult.success_no_compression([])
+
+            logger.info(
+                f"Initiating compression for conversation {conversation_id}: "
+                f"compressing all {queries_count} queries (0-{compress_up_to})"
+            )
+
+            # Perform compression and save to DB
+            metadata = compression_service.compress_and_save(
+                conversation_id, conversation, compress_up_to
+            )
+
+            logger.info(
+                f"Compression successful - ratio: {metadata.compression_ratio:.1f}x, "
+                f"saved {metadata.original_token_count - metadata.compressed_token_count} tokens"
+            )
+
+            # Reload conversation with updated metadata
+            conversation = self.conversation_service.get_conversation(
+                conversation_id, user_id=decoded_token.get("sub")
+            )
+
+            # Get compressed context
+            compressed_summary, recent_queries = (
+                compression_service.get_compressed_context(conversation)
+            )
+
+            return CompressionResult.success_with_compression(
+                compressed_summary, recent_queries, metadata
+            )
+
+        except Exception as e:
+            logger.error(f"Error performing compression: {str(e)}", exc_info=True)
+            return CompressionResult.failure(str(e))
+
+    def compress_mid_execution(
+        self,
+        conversation_id: str,
+        user_id: str,
+        model_id: str,
+        decoded_token: Dict[str, Any],
+        current_conversation: Optional[Dict[str, Any]] = None,
+    ) -> CompressionResult:
+        """
+        Perform compression during tool execution.
+
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID
+            model_id: Model ID
+            decoded_token: User token
+            current_conversation: Pre-loaded conversation (optional)
+
+        Returns:
+            CompressionResult
+        """
+        try:
+            # Load conversation if not provided
+            if current_conversation:
+                conversation = current_conversation
+            else:
+                conversation = self.conversation_service.get_conversation(
+                    conversation_id, user_id
+                )
+
+            if not conversation:
+                logger.warning(
+                    f"Could not load conversation {conversation_id} for mid-execution compression"
+                )
+                return CompressionResult.failure("Conversation not found")
+
+            # Perform compression
+            return self._perform_compression(
+                conversation_id, conversation, model_id, decoded_token
+            )
+
+        except Exception as e:
+            logger.error(
+                f"Error in mid-execution compression: {str(e)}", exc_info=True
+            )
+            return CompressionResult.failure(str(e))

application/api/answer/services/compression/prompt_builder.py

@@ -0,0 +1,149 @@
+"""Compression prompt building logic."""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class CompressionPromptBuilder:
+    """Builds prompts for LLM compression calls."""
+
+    def __init__(self, version: str = "v1.0"):
+        """
+        Initialize prompt builder.
+
+        Args:
+            version: Prompt template version to use
+        """
+        self.version = version
+        self.system_prompt = self._load_prompt(version)
+
+    def _load_prompt(self, version: str) -> str:
+        """
+        Load prompt template from file.
+
+        Args:
+            version: Version string (e.g., 'v1.0')
+
+        Returns:
+            Prompt template content
+
+        Raises:
+            FileNotFoundError: If prompt template file doesn't exist
+        """
+        current_dir = Path(__file__).resolve().parents[4]
+        prompt_path = current_dir / "prompts" / "compression" / f"{version}.txt"
+
+        try:
+            with open(prompt_path, "r") as f:
+                return f.read()
+        except FileNotFoundError:
+            logger.error(f"Compression prompt template not found: {prompt_path}")
+            raise FileNotFoundError(
+                f"Compression prompt template '{version}' not found at {prompt_path}. "
+                f"Please ensure the template file exists."
+            )
+
+    def build_prompt(
+        self,
+        queries: List[Dict[str, Any]],
+        existing_compressions: Optional[List[Dict[str, Any]]] = None,
+    ) -> List[Dict[str, str]]:
+        """
+        Build messages for compression LLM call.
+
+        Args:
+            queries: List of query objects to compress
+            existing_compressions: List of previous compression points
+
+        Returns:
+            List of message dicts for LLM
+        """
+        # Build conversation text
+        conversation_text = self._format_conversation(queries)
+
+        # Add existing compression context if present
+        existing_compression_context = ""
+        if existing_compressions and len(existing_compressions) > 0:
+            existing_compression_context = (
+                "\n\nIMPORTANT: This conversation has been compressed before. "
+                "Previous compression summaries:\n\n"
+            )
+            for i, comp in enumerate(existing_compressions):
+                existing_compression_context += (
+                    f"--- Compression {i + 1} (up to message {comp.get('query_index', 'unknown')}) ---\n"
+                    f"{comp.get('compressed_summary', '')}\n\n"
+                )
+            existing_compression_context += (
+                "Your task is to create a NEW summary that incorporates the context from "
+                "previous compressions AND the new messages below. The final summary should "
+                "be comprehensive and include all important information from both previous "
+                "compressions and new messages.\n\n"
+            )
+
+        user_prompt = (
+            f"{existing_compression_context}"
+            f"Here is the conversation to summarize:\n\n"
+            f"{conversation_text}"
+        )
+
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+
+        return messages
+
+    def _format_conversation(self, queries: List[Dict[str, Any]]) -> str:
+        """
+        Format conversation queries into readable text for compression.
+
+        Args:
+            queries: List of query objects
+
+        Returns:
+            Formatted conversation text
+        """
+        conversation_lines = []
+
+        for i, query in enumerate(queries):
+            conversation_lines.append(f"--- Message {i + 1} ---")
+            conversation_lines.append(f"User: {query.get('prompt', '')}")
+
+            # Add tool calls if present
+            tool_calls = query.get("tool_calls", [])
+            if tool_calls:
+                conversation_lines.append("\nTool Calls:")
+                for tc in tool_calls:
+                    tool_name = tc.get("tool_name", "unknown")
+                    action_name = tc.get("action_name", "unknown")
+                    arguments = tc.get("arguments", {})
+                    result = tc.get("result", "")
+                    if result is None:
+                        result = ""
+                    status = tc.get("status", "unknown")
+
+                    # Include full tool result for complete compression context
+                    conversation_lines.append(
+                        f"  - {tool_name}.{action_name}({arguments}) "
+                        f"[{status}] → {result}"
+                    )
+
+            # Add agent thought if present
+            thought = query.get("thought", "")
+            if thought:
+                conversation_lines.append(f"\nAgent Thought: {thought}")
+
+            # Add assistant response
+            conversation_lines.append(f"\nAssistant: {query.get('response', '')}")
+
+            # Add sources if present
+            sources = query.get("sources", [])
+            if sources:
+                conversation_lines.append(f"\nSources Used: {len(sources)} documents")
+
+            conversation_lines.append("")  # Empty line between messages
+
+        return "\n".join(conversation_lines)

application/api/answer/services/compression/service.py

@@ -0,0 +1,306 @@
+"""Core compression service with simplified responsibilities."""
+
+import logging
+import re
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from application.api.answer.services.compression.prompt_builder import (
+    CompressionPromptBuilder,
+)
+from application.api.answer.services.compression.token_counter import TokenCounter
+from application.api.answer.services.compression.types import (
+    CompressionMetadata,
+)
+from application.core.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+class CompressionService:
+    """
+    Service for compressing conversation history.
+
+    Handles DB updates.
+    """
+
+    def __init__(
+        self,
+        llm,
+        model_id: str,
+        conversation_service=None,
+        prompt_builder: Optional[CompressionPromptBuilder] = None,
+    ):
+        """
+        Initialize compression service.
+
+        Args:
+            llm: LLM instance to use for compression
+            model_id: Model ID for compression
+            conversation_service: Service for DB operations (optional, for DB updates)
+            prompt_builder: Custom prompt builder (optional)
+        """
+        self.llm = llm
+        self.model_id = model_id
+        self.conversation_service = conversation_service
+        self.prompt_builder = prompt_builder or CompressionPromptBuilder(
+            version=settings.COMPRESSION_PROMPT_VERSION
+        )
+
+    def compress_conversation(
+        self,
+        conversation: Dict[str, Any],
+        compress_up_to_index: int,
+    ) -> CompressionMetadata:
+        """
+        Compress conversation history up to specified index.
+
+        Args:
+            conversation: Full conversation document
+            compress_up_to_index: Last query index to include in compression
+
+        Returns:
+            CompressionMetadata with compression details
+
+        Raises:
+            ValueError: If compress_up_to_index is invalid
+        """
+        try:
+            queries = conversation.get("queries", [])
+
+            if compress_up_to_index < 0 or compress_up_to_index >= len(queries):
+                raise ValueError(
+                    f"Invalid compress_up_to_index: {compress_up_to_index} "
+                    f"(conversation has {len(queries)} queries)"
+                )
+
+            # Get queries to compress
+            queries_to_compress = queries[: compress_up_to_index + 1]
+
+            # Check if there are existing compressions
+            existing_compressions = conversation.get("compression_metadata", {}).get(
+                "compression_points", []
+            )
+
+            if existing_compressions:
+                logger.info(
+                    f"Found {len(existing_compressions)} previous compression(s) - "
+                    f"will incorporate into new summary"
+                )
+
+            # Calculate original token count
+            original_tokens = TokenCounter.count_query_tokens(queries_to_compress)
+
+            # Log tool call stats
+            self._log_tool_call_stats(queries_to_compress)
+
+            # Build compression prompt
+            messages = self.prompt_builder.build_prompt(
+                queries_to_compress, existing_compressions
+            )
+
+            # Call LLM to generate compression
+            logger.info(
+                f"Starting compression: {len(queries_to_compress)} queries "
+                f"(messages 0-{compress_up_to_index}, {original_tokens} tokens) "
+                f"using model {self.model_id}"
+            )
+
+            response = self.llm.gen(
+                model=self.model_id, messages=messages, max_tokens=4000
+            )
+
+            # Extract summary from response
+            compressed_summary = self._extract_summary(response)
+
+            # Calculate compressed token count
+            compressed_tokens = TokenCounter.count_message_tokens(
+                [{"content": compressed_summary}]
+            )
+
+            # Calculate compression ratio
+            compression_ratio = (
+                original_tokens / compressed_tokens if compressed_tokens > 0 else 0
+            )
+
+            logger.info(
+                f"Compression complete: {original_tokens} → {compressed_tokens} tokens "
+                f"({compression_ratio:.1f}x compression)"
+            )
+
+            # Build compression metadata
+            compression_metadata = CompressionMetadata(
+                timestamp=datetime.now(timezone.utc),
+                query_index=compress_up_to_index,
+                compressed_summary=compressed_summary,
+                original_token_count=original_tokens,
+                compressed_token_count=compressed_tokens,
+                compression_ratio=compression_ratio,
+                model_used=self.model_id,
+                compression_prompt_version=self.prompt_builder.version,
+            )
+
+            return compression_metadata
+
+        except Exception as e:
+            logger.error(f"Error compressing conversation: {str(e)}", exc_info=True)
+            raise
+
+    def compress_and_save(
+        self,
+        conversation_id: str,
+        conversation: Dict[str, Any],
+        compress_up_to_index: int,
+    ) -> CompressionMetadata:
+        """
+        Compress conversation and save to database.
+
+        Args:
+            conversation_id: Conversation ID
+            conversation: Full conversation document
+            compress_up_to_index: Last query index to include
+
+        Returns:
+            CompressionMetadata
+
+        Raises:
+            ValueError: If conversation_service not provided or invalid index
+        """
+        if not self.conversation_service:
+            raise ValueError(
+                "conversation_service required for compress_and_save operation"
+            )
+
+        # Perform compression
+        metadata = self.compress_conversation(conversation, compress_up_to_index)
+
+        # Save to database
+        self.conversation_service.update_compression_metadata(
+            conversation_id, metadata.to_dict()
+        )
+
+        logger.info(f"Compression metadata saved to database for {conversation_id}")
+
+        return metadata
+
+    def get_compressed_context(
+        self, conversation: Dict[str, Any]
+    ) -> tuple[Optional[str], List[Dict[str, Any]]]:
+        """
+        Get compressed summary + recent uncompressed messages.
+
+        Args:
+            conversation: Full conversation document
+
+        Returns:
+            (compressed_summary, recent_messages)
+        """
+        try:
+            compression_metadata = conversation.get("compression_metadata", {})
+
+            if not compression_metadata.get("is_compressed"):
+                logger.debug("No compression metadata found - using full history")
+                queries = conversation.get("queries", [])
+                if queries is None:
+                    logger.error("Conversation queries is None - returning empty list")
+                    return None, []
+                return None, queries
+
+            compression_points = compression_metadata.get("compression_points", [])
+
+            if not compression_points:
+                logger.debug("No compression points found - using full history")
+                queries = conversation.get("queries", [])
+                if queries is None:
+                    logger.error("Conversation queries is None - returning empty list")
+                    return None, []
+                return None, queries
+
+            # Get the most recent compression point
+            latest_compression = compression_points[-1]
+            compressed_summary = latest_compression.get("compressed_summary")
+            last_compressed_index = latest_compression.get("query_index")
+            compressed_tokens = latest_compression.get("compressed_token_count", 0)
+            original_tokens = latest_compression.get("original_token_count", 0)
+
+            # Get only messages after compression point
+            queries = conversation.get("queries", [])
+            total_queries = len(queries)
+            recent_queries = queries[last_compressed_index + 1 :]
+
+            logger.info(
+                f"Using compressed context: summary ({compressed_tokens} tokens, "
+                f"compressed from {original_tokens}) + {len(recent_queries)} recent messages "
+                f"(messages {last_compressed_index + 1}-{total_queries - 1})"
+            )
+
+            return compressed_summary, recent_queries
+
+        except Exception as e:
+            logger.error(
+                f"Error getting compressed context: {str(e)}", exc_info=True
+            )
+            queries = conversation.get("queries", [])
+            if queries is None:
+                return None, []
+            return None, queries
+
+    def _extract_summary(self, llm_response: str) -> str:
+        """
+        Extract clean summary from LLM response.
+
+        Args:
+            llm_response: Raw LLM response
+
+        Returns:
+            Cleaned summary text
+        """
+        try:
+            # Try to extract content within <summary> tags
+            summary_match = re.search(
+                r"<summary>(.*?)</summary>", llm_response, re.DOTALL
+            )
+
+            if summary_match:
+                summary = summary_match.group(1).strip()
+            else:
+                # If no summary tags, remove analysis tags and use the rest
+                summary = re.sub(
+                    r"<analysis>.*?</analysis>", "", llm_response, flags=re.DOTALL
+                ).strip()
+
+            return summary
+
+        except Exception as e:
+            logger.warning(f"Error extracting summary: {str(e)}, using full response")
+            return llm_response
+
+    def _log_tool_call_stats(self, queries: List[Dict[str, Any]]) -> None:
+        """Log statistics about tool calls in queries."""
+        total_tool_calls = 0
+        total_tool_result_chars = 0
+        tool_call_breakdown = {}
+
+        for q in queries:
+            for tc in q.get("tool_calls", []):
+                total_tool_calls += 1
+                tool_name = tc.get("tool_name", "unknown")
+                action_name = tc.get("action_name", "unknown")
+                key = f"{tool_name}.{action_name}"
+                tool_call_breakdown[key] = tool_call_breakdown.get(key, 0) + 1
+
+                # Track total tool result size
+                result = tc.get("result", "")
+                if result:
+                    total_tool_result_chars += len(str(result))
+
+        if total_tool_calls > 0:
+            tool_breakdown_str = ", ".join(
+                f"{tool}({count})"
+                for tool, count in sorted(tool_call_breakdown.items())
+            )
+            tool_result_kb = total_tool_result_chars / 1024
+            logger.info(
+                f"Tool call breakdown: {tool_breakdown_str} "
+                f"(total result size: {tool_result_kb:.1f} KB, {total_tool_result_chars:,} chars)"
+            )

application/api/answer/services/compression/threshold_checker.py

@@ -0,0 +1,103 @@
+"""Compression threshold checking logic."""
+
+import logging
+from typing import Any, Dict
+
+from application.core.model_utils import get_token_limit
+from application.core.settings import settings
+from application.api.answer.services.compression.token_counter import TokenCounter
+
+logger = logging.getLogger(__name__)
+
+
+class CompressionThresholdChecker:
+    """Determines if compression is needed based on token thresholds."""
+
+    def __init__(self, threshold_percentage: float = None):
+        """
+        Initialize threshold checker.
+
+        Args:
+            threshold_percentage: Percentage of context to use as threshold
+                                 (defaults to settings.COMPRESSION_THRESHOLD_PERCENTAGE)
+        """
+        self.threshold_percentage = (
+            threshold_percentage or settings.COMPRESSION_THRESHOLD_PERCENTAGE
+        )
+
+    def should_compress(
+        self,
+        conversation: Dict[str, Any],
+        model_id: str,
+        current_query_tokens: int = 500,
+    ) -> bool:
+        """
+        Determine if compression is needed.
+
+        Args:
+            conversation: Full conversation document
+            model_id: Target model for this request
+            current_query_tokens: Estimated tokens for current query
+
+        Returns:
+            True if tokens >= threshold% of context window
+        """
+        try:
+            # Calculate total tokens in conversation
+            total_tokens = TokenCounter.count_conversation_tokens(conversation)
+            total_tokens += current_query_tokens
+
+            # Get context window limit for model
+            context_limit = get_token_limit(model_id)
+
+            # Calculate threshold
+            threshold = int(context_limit * self.threshold_percentage)
+
+            compression_needed = total_tokens >= threshold
+            percentage_used = (total_tokens / context_limit) * 100
+
+            if compression_needed:
+                logger.warning(
+                    f"COMPRESSION TRIGGERED: {total_tokens} tokens / {context_limit} limit "
+                    f"({percentage_used:.1f}% used, threshold: {self.threshold_percentage * 100:.0f}%)"
+                )
+            else:
+                logger.info(
+                    f"Compression check: {total_tokens}/{context_limit} tokens "
+                    f"({percentage_used:.1f}% used, threshold: {self.threshold_percentage * 100:.0f}%) - No compression needed"
+                )
+
+            return compression_needed
+
+        except Exception as e:
+            logger.error(f"Error checking compression need: {str(e)}", exc_info=True)
+            return False
+
+    def check_message_tokens(self, messages: list, model_id: str) -> bool:
+        """
+        Check if message list exceeds threshold.
+
+        Args:
+            messages: List of message dicts
+            model_id: Target model
+
+        Returns:
+            True if at or above threshold
+        """
+        try:
+            current_tokens = TokenCounter.count_message_tokens(messages)
+            context_limit = get_token_limit(model_id)
+            threshold = int(context_limit * self.threshold_percentage)
+
+            if current_tokens >= threshold:
+                logger.warning(
+                    f"Message context limit approaching: {current_tokens}/{context_limit} tokens "
+                    f"({(current_tokens/context_limit)*100:.1f}%)"
+                )
+                return True
+
+            return False
+
+        except Exception as e:
+            logger.error(f"Error checking message tokens: {str(e)}", exc_info=True)
+            return False

application/api/answer/services/compression/token_counter.py

@@ -0,0 +1,103 @@
+"""Token counting utilities for compression."""
+
+import logging
+from typing import Any, Dict, List
+
+from application.utils import num_tokens_from_string
+from application.core.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+class TokenCounter:
+    """Centralized token counting for conversations and messages."""
+
+    @staticmethod
+    def count_message_tokens(messages: List[Dict]) -> int:
+        """
+        Calculate total tokens in a list of messages.
+
+        Args:
+            messages: List of message dicts with 'content' field
+
+        Returns:
+            Total token count
+        """
+        total_tokens = 0
+        for message in messages:
+            content = message.get("content", "")
+            if isinstance(content, str):
+                total_tokens += num_tokens_from_string(content)
+            elif isinstance(content, list):
+                # Handle structured content (tool calls, etc.)
+                for item in content:
+                    if isinstance(item, dict):
+                        total_tokens += num_tokens_from_string(str(item))
+        return total_tokens
+
+    @staticmethod
+    def count_query_tokens(
+        queries: List[Dict[str, Any]], include_tool_calls: bool = True
+    ) -> int:
+        """
+        Count tokens across multiple query objects.
+
+        Args:
+            queries: List of query objects from conversation
+            include_tool_calls: Whether to count tool call tokens
+
+        Returns:
+            Total token count
+        """
+        total_tokens = 0
+
+        for query in queries:
+            # Count prompt and response tokens
+            if "prompt" in query:
+                total_tokens += num_tokens_from_string(query["prompt"])
+            if "response" in query:
+                total_tokens += num_tokens_from_string(query["response"])
+            if "thought" in query:
+                total_tokens += num_tokens_from_string(query.get("thought", ""))
+
+            # Count tool call tokens
+            if include_tool_calls and "tool_calls" in query:
+                for tool_call in query["tool_calls"]:
+                    tool_call_string = (
+                        f"Tool: {tool_call.get('tool_name')} | "
+                        f"Action: {tool_call.get('action_name')} | "
+                        f"Args: {tool_call.get('arguments')} | "
+                        f"Response: {tool_call.get('result')}"
+                    )
+                    total_tokens += num_tokens_from_string(tool_call_string)
+
+        return total_tokens
+
+    @staticmethod
+    def count_conversation_tokens(
+        conversation: Dict[str, Any], include_system_prompt: bool = False
+    ) -> int:
+        """
+        Calculate total tokens in a conversation.
+
+        Args:
+            conversation: Conversation document
+            include_system_prompt: Whether to include system prompt in count
+
+        Returns:
+            Total token count
+        """
+        try:
+            queries = conversation.get("queries", [])
+            total_tokens = TokenCounter.count_query_tokens(queries)
+
+            # Add system prompt tokens if requested
+            if include_system_prompt:
+                # Rough estimate for system prompt
+                total_tokens += settings.RESERVED_TOKENS.get("system_prompt", 500)
+
+            return total_tokens
+
+        except Exception as e:
+            logger.error(f"Error calculating conversation tokens: {str(e)}")
+            return 0

application/api/answer/services/compression/types.py

@@ -0,0 +1,83 @@
+"""Type definitions for compression module."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class CompressionMetadata:
+    """Metadata about a compression operation."""
+
+    timestamp: datetime
+    query_index: int
+    compressed_summary: str
+    original_token_count: int
+    compressed_token_count: int
+    compression_ratio: float
+    model_used: str
+    compression_prompt_version: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for DB storage."""
+        return {
+            "timestamp": self.timestamp,
+            "query_index": self.query_index,
+            "compressed_summary": self.compressed_summary,
+            "original_token_count": self.original_token_count,
+            "compressed_token_count": self.compressed_token_count,
+            "compression_ratio": self.compression_ratio,
+            "model_used": self.model_used,
+            "compression_prompt_version": self.compression_prompt_version,
+        }
+
+
+@dataclass
+class CompressionResult:
+    """Result of a compression operation."""
+
+    success: bool
+    compressed_summary: Optional[str] = None
+    recent_queries: List[Dict[str, Any]] = field(default_factory=list)
+    metadata: Optional[CompressionMetadata] = None
+    error: Optional[str] = None
+    compression_performed: bool = False
+
+    @classmethod
+    def success_with_compression(
+        cls, summary: str, queries: List[Dict], metadata: CompressionMetadata
+    ) -> "CompressionResult":
+        """Create a successful result with compression."""
+        return cls(
+            success=True,
+            compressed_summary=summary,
+            recent_queries=queries,
+            metadata=metadata,
+            compression_performed=True,
+        )
+
+    @classmethod
+    def success_no_compression(cls, queries: List[Dict]) -> "CompressionResult":
+        """Create a successful result without compression needed."""
+        return cls(
+            success=True,
+            recent_queries=queries,
+            compression_performed=False,
+        )
+
+    @classmethod
+    def failure(cls, error: str) -> "CompressionResult":
+        """Create a failure result."""
+        return cls(success=False, error=error, compression_performed=False)
+
+    def as_history(self) -> List[Dict[str, str]]:
+        """
+        Convert recent queries to history format.
+
+        Returns:
+            List of prompt/response dicts
+        """
+        return [
+            {"prompt": q["prompt"], "response": q["response"]}
+            for q in self.recent_queries
+        ]

application/api/answer/services/conversation_service.py

@@ -52,7 +52,7 @@ class ConversationService:
         sources: List[Dict[str, Any]],
         tool_calls: List[Dict[str, Any]],
         llm: Any,
-        gpt_model: str,
+        model_id: str,
         decoded_token: Dict[str, Any],
         index: Optional[int] = None,
         api_key: Optional[str] = None,
@@ -66,7 +66,7 @@ class ConversationService:
         if not user_id:
             raise ValueError("User ID not found in token")
         current_time = datetime.now(timezone.utc)
-        
+
         # clean up in sources array such that we save max 1k characters for text part
         for source in sources:
             if "text" in source and isinstance(source["text"], str):
@@ -90,6 +90,7 @@ class ConversationService:
                         f"queries.{index}.tool_calls": tool_calls,
                         f"queries.{index}.timestamp": current_time,
                         f"queries.{index}.attachments": attachment_ids,
+                        f"queries.{index}.model_id": model_id,
                     }
                 },
             )
@@ -120,6 +121,7 @@ class ConversationService:
                             "tool_calls": tool_calls,
                             "timestamp": current_time,
                             "attachments": attachment_ids,
+                            "model_id": model_id,
                         }
                     }
                 },
@@ -133,10 +135,9 @@ class ConversationService:
 
             messages_summary = [
                 {
-                    "role": "assistant",
-                    "content": "Summarise following conversation in no more than 3 "
-                    "words, respond ONLY with the summary, use the same "
-                    "language as the user query",
+                    "role": "system",
+                    "content": "You are a helpful assistant that creates concise conversation titles. "
+                    "Summarize conversations in 3 words or less using the same language as the user.",
                 },
                 {
                     "role": "user",
@@ -147,7 +148,7 @@ class ConversationService:
             ]
 
             completion = llm.gen(
-                model=gpt_model, messages=messages_summary, max_tokens=30
+                model=model_id, messages=messages_summary, max_tokens=30
             )
 
             conversation_data = {
@@ -163,6 +164,7 @@ class ConversationService:
                         "tool_calls": tool_calls,
                         "timestamp": current_time,
                         "attachments": attachment_ids,
+                        "model_id": model_id,
                     }
                 ],
             }
@@ -178,3 +180,103 @@ class ConversationService:
                     conversation_data["api_key"] = agent["key"]
             result = self.conversations_collection.insert_one(conversation_data)
             return str(result.inserted_id)
+
+    def update_compression_metadata(
+        self, conversation_id: str, compression_metadata: Dict[str, Any]
+    ) -> None:
+        """
+        Update conversation with compression metadata.
+
+        Uses $push with $slice to keep only the most recent compression points,
+        preventing unbounded array growth. Since each compression incorporates
+        previous compressions, older points become redundant.
+
+        Args:
+            conversation_id: Conversation ID
+            compression_metadata: Compression point data
+        """
+        try:
+            self.conversations_collection.update_one(
+                {"_id": ObjectId(conversation_id)},
+                {
+                    "$set": {
+                        "compression_metadata.is_compressed": True,
+                        "compression_metadata.last_compression_at": compression_metadata.get(
+                            "timestamp"
+                        ),
+                    },
+                    "$push": {
+                        "compression_metadata.compression_points": {
+                            "$each": [compression_metadata],
+                            "$slice": -settings.COMPRESSION_MAX_HISTORY_POINTS,
+                        }
+                    },
+                },
+            )
+            logger.info(
+                f"Updated compression metadata for conversation {conversation_id}"
+            )
+        except Exception as e:
+            logger.error(
+                f"Error updating compression metadata: {str(e)}", exc_info=True
+            )
+            raise
+
+    def append_compression_message(
+        self, conversation_id: str, compression_metadata: Dict[str, Any]
+    ) -> None:
+        """
+        Append a synthetic compression summary entry into the conversation history.
+        This makes the summary visible in the DB alongside normal queries.
+        """
+        try:
+            summary = compression_metadata.get("compressed_summary", "")
+            if not summary:
+                return
+            timestamp = compression_metadata.get("timestamp", datetime.now(timezone.utc))
+
+            self.conversations_collection.update_one(
+                {"_id": ObjectId(conversation_id)},
+                {
+                    "$push": {
+                        "queries": {
+                            "prompt": "[Context Compression Summary]",
+                            "response": summary,
+                            "thought": "",
+                            "sources": [],
+                            "tool_calls": [],
+                            "timestamp": timestamp,
+                            "attachments": [],
+                            "model_id": compression_metadata.get("model_used"),
+                        }
+                    }
+                },
+            )
+            logger.info(f"Appended compression summary to conversation {conversation_id}")
+        except Exception as e:
+            logger.error(
+                f"Error appending compression summary: {str(e)}", exc_info=True
+            )
+
+    def get_compression_metadata(
+        self, conversation_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get compression metadata for a conversation.
+
+        Args:
+            conversation_id: Conversation ID
+
+        Returns:
+            Compression metadata dict or None
+        """
+        try:
+            conversation = self.conversations_collection.find_one(
+                {"_id": ObjectId(conversation_id)}, {"compression_metadata": 1}
+            )
+            return conversation.get("compression_metadata") if conversation else None
+        except Exception as e:
+            logger.error(
+                f"Error getting compression metadata: {str(e)}", exc_info=True
+            )
+            return None

application/api/answer/services/prompt_renderer.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Any, Dict, Optional
+
+from application.templates.namespaces import NamespaceManager
+
+from application.templates.template_engine import TemplateEngine, TemplateRenderError
+
+logger = logging.getLogger(__name__)
+
+
+class PromptRenderer:
+    """Service for rendering prompts with dynamic context using namespaces"""
+
+    def __init__(self):
+        self.template_engine = TemplateEngine()
+        self.namespace_manager = NamespaceManager()
+
+    def render_prompt(
+        self,
+        prompt_content: str,
+        user_id: Optional[str] = None,
+        request_id: Optional[str] = None,
+        passthrough_data: Optional[Dict[str, Any]] = None,
+        docs: Optional[list] = None,
+        docs_together: Optional[str] = None,
+        tools_data: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> str:
+        """
+        Render prompt with full context from all namespaces.
+
+        Args:
+            prompt_content: Raw prompt template string
+            user_id: Current user identifier
+            request_id: Unique request identifier
+            passthrough_data: Parameters from web request
+            docs: RAG retrieved documents
+            docs_together: Concatenated document content
+            tools_data: Pre-fetched tool results organized by tool name
+            **kwargs: Additional parameters for namespace builders
+
+        Returns:
+            Rendered prompt string with all variables substituted
+
+        Raises:
+            TemplateRenderError: If template rendering fails
+        """
+        if not prompt_content:
+            return ""
+
+        uses_template = self._uses_template_syntax(prompt_content)
+
+        if not uses_template:
+            return self._apply_legacy_substitutions(prompt_content, docs_together)
+
+        try:
+            context = self.namespace_manager.build_context(
+                user_id=user_id,
+                request_id=request_id,
+                passthrough_data=passthrough_data,
+                docs=docs,
+                docs_together=docs_together,
+                tools_data=tools_data,
+                **kwargs,
+            )
+
+            return self.template_engine.render(prompt_content, context)
+        except TemplateRenderError:
+            raise
+        except Exception as e:
+            error_msg = f"Prompt rendering failed: {str(e)}"
+            logger.error(error_msg)
+            raise TemplateRenderError(error_msg) from e
+
+    def _uses_template_syntax(self, prompt_content: str) -> bool:
+        """Check if prompt uses Jinja2 template syntax"""
+        return "{{" in prompt_content and "}}" in prompt_content
+
+    def _apply_legacy_substitutions(
+        self, prompt_content: str, docs_together: Optional[str] = None
+    ) -> str:
+        """
+        Apply backward-compatible substitutions for old prompt format.
+
+        Handles legacy {summaries} and {query} placeholders during transition period.
+        """
+        if docs_together:
+            prompt_content = prompt_content.replace("{summaries}", docs_together)
+        return prompt_content
+
+    def validate_template(self, prompt_content: str) -> bool:
+        """Validate prompt template syntax"""
+        return self.template_engine.validate_template(prompt_content)
+
+    def extract_variables(self, prompt_content: str) -> set[str]:
+        """Extract all variable names from prompt template"""
+        return self.template_engine.extract_variables(prompt_content)

application/api/answer/services/stream_processor.py

@@ -3,18 +3,30 @@ import json
 import logging
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Set
 
 from bson.dbref import DBRef
 
 from bson.objectid import ObjectId
 
 from application.agents.agent_creator import AgentCreator
+from application.api.answer.services.compression import CompressionOrchestrator
+from application.api.answer.services.compression.token_counter import TokenCounter
 from application.api.answer.services.conversation_service import ConversationService
+from application.api.answer.services.prompt_renderer import PromptRenderer
+from application.core.model_utils import (
+    get_api_key_for_provider,
+    get_default_model_id,
+    get_provider_from_model_id,
+    validate_model_id,
+)
 from application.core.mongo_db import MongoDB
 from application.core.settings import settings
 from application.retriever.retriever_creator import RetrieverCreator
-from application.utils import get_gpt_model, limit_chat_history
+from application.utils import (
+    calculate_doc_token_budget,
+    limit_chat_history,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -73,19 +85,28 @@ class StreamProcessor:
         self.all_sources = []
         self.attachments = []
         self.history = []
+        self.retrieved_docs = []
         self.agent_config = {}
         self.retriever_config = {}
         self.is_shared_usage = False
         self.shared_token = None
-        self.gpt_model = get_gpt_model()
+        self.model_id: Optional[str] = None
         self.conversation_service = ConversationService()
+        self.compression_orchestrator = CompressionOrchestrator(
+            self.conversation_service
+        )
+        self.prompt_renderer = PromptRenderer()
+        self._prompt_content: Optional[str] = None
+        self._required_tool_actions: Optional[Dict[str, Set[Optional[str]]]] = None
+        self.compressed_summary: Optional[str] = None
+        self.compressed_summary_tokens: int = 0
 
     def initialize(self):
         """Initialize all required components for processing"""
         self._configure_agent()
+        self._validate_and_set_model()
         self._configure_source()
         self._configure_retriever()
-        self._configure_agent()
         self._load_conversation_history()
         self._process_attachments()
 
@@ -97,14 +118,71 @@ class StreamProcessor:
             )
             if not conversation:
                 raise ValueError("Conversation not found or unauthorized")
+
+            # Check if compression is enabled and needed
+            if settings.ENABLE_CONVERSATION_COMPRESSION:
+                self._handle_compression(conversation)
+            else:
+                # Original behavior - load all history
+                self.history = [
+                    {"prompt": query["prompt"], "response": query["response"]}
+                    for query in conversation.get("queries", [])
+                ]
+        else:
+            self.history = limit_chat_history(
+                json.loads(self.data.get("history", "[]")), model_id=self.model_id
+            )
+
+    def _handle_compression(self, conversation: Dict[str, Any]):
+        """
+        Handle conversation compression logic using orchestrator.
+
+        Args:
+            conversation: Full conversation document
+        """
+        try:
+            # Use orchestrator to handle all compression logic
+            result = self.compression_orchestrator.compress_if_needed(
+                conversation_id=self.conversation_id,
+                user_id=self.initial_user_id,
+                model_id=self.model_id,
+                decoded_token=self.decoded_token,
+            )
+
+            if not result.success:
+                logger.error(
+                    f"Compression failed: {result.error}, using full history"
+                )
+                self.history = [
+                    {"prompt": query["prompt"], "response": query["response"]}
+                    for query in conversation.get("queries", [])
+                ]
+                return
+
+            # Set compressed summary if compression was performed
+            if result.compression_performed and result.compressed_summary:
+                self.compressed_summary = result.compressed_summary
+                self.compressed_summary_tokens = TokenCounter.count_message_tokens(
+                    [{"content": result.compressed_summary}]
+                )
+                logger.info(
+                    f"Using compressed summary ({self.compressed_summary_tokens} tokens) "
+                    f"+ {len(result.recent_queries)} recent messages"
+                )
+
+            # Build history from recent queries
+            self.history = result.as_history()
+
+        except Exception as e:
+            logger.error(
+                f"Error handling compression, falling back to standard history: {str(e)}",
+                exc_info=True,
+            )
+            # Fallback to original behavior
             self.history = [
                 {"prompt": query["prompt"], "response": query["response"]}
                 for query in conversation.get("queries", [])
             ]
-        else:
-            self.history = limit_chat_history(
-                json.loads(self.data.get("history", "[]")), gpt_model=self.gpt_model
-            )
 
     def _process_attachments(self):
         """Process any attachments in the request"""
@@ -134,6 +212,30 @@ class StreamProcessor:
                 )
         return attachments
 
+    def _validate_and_set_model(self):
+        """Validate and set model_id from request"""
+        from application.core.model_settings import ModelRegistry
+
+        requested_model = self.data.get("model_id")
+
+        if requested_model:
+            if not validate_model_id(requested_model):
+                registry = ModelRegistry.get_instance()
+                available_models = [m.id for m in registry.get_enabled_models()]
+                raise ValueError(
+                    f"Invalid model_id '{requested_model}'. "
+                    f"Available models: {', '.join(available_models[:5])}"
+                    + (f" and {len(available_models) - 5} more" if len(available_models) > 5 else "")
+                )
+            self.model_id = requested_model
+        else:
+            # Check if agent has a default model configured
+            agent_default_model = self.agent_config.get("default_model_id", "")
+            if agent_default_model and validate_model_id(agent_default_model):
+                self.model_id = agent_default_model
+            else:
+                self.model_id = get_default_model_id()
+
     def _get_agent_key(self, agent_id: Optional[str], user_id: Optional[str]) -> tuple:
         """Get API key for agent with access control"""
         if not agent_id:
@@ -205,6 +307,10 @@ class StreamProcessor:
             data["sources"] = sources_list
         else:
             data["sources"] = []
+
+        # Preserve model configuration from agent
+        data["default_model_id"] = data.get("default_model_id", "")
+
         return data
 
     def _configure_source(self):
@@ -257,6 +363,7 @@ class StreamProcessor:
                     "agent_type": data_key.get("agent_type", settings.AGENT_NAME),
                     "user_api_key": api_key,
                     "json_schema": data_key.get("json_schema"),
+                    "default_model_id": data_key.get("default_model_id", ""),
                 }
             )
             self.initial_user_id = data_key.get("user")
@@ -281,6 +388,7 @@ class StreamProcessor:
                     "agent_type": data_key.get("agent_type", settings.AGENT_NAME),
                     "user_api_key": self.agent_key,
                     "json_schema": data_key.get("json_schema"),
+                    "default_model_id": data_key.get("default_model_id", ""),
                 }
             )
             self.decoded_token = (
@@ -307,47 +415,341 @@ class StreamProcessor:
                     "agent_type": settings.AGENT_NAME,
                     "user_api_key": None,
                     "json_schema": None,
+                    "default_model_id": "",
                 }
             )
 
     def _configure_retriever(self):
-        """Configure the retriever based on request data"""
+        history_token_limit = int(self.data.get("token_limit", 2000))
+        doc_token_limit = calculate_doc_token_budget(
+            model_id=self.model_id, history_token_limit=history_token_limit
+        )
+
         self.retriever_config = {
             "retriever_name": self.data.get("retriever", "classic"),
             "chunks": int(self.data.get("chunks", 2)),
-            "token_limit": self.data.get("token_limit", settings.DEFAULT_MAX_HISTORY),
+            "doc_token_limit": doc_token_limit,
+            "history_token_limit": history_token_limit,
         }
 
         api_key = self.data.get("api_key") or self.agent_key
         if not api_key and "isNoneDoc" in self.data and self.data["isNoneDoc"]:
             self.retriever_config["chunks"] = 0
 
-    def create_agent(self):
-        """Create and return the configured agent"""
-        return AgentCreator.create_agent(
-            self.agent_config["agent_type"],
-            endpoint="stream",
-            llm_name=settings.LLM_PROVIDER,
-            gpt_model=self.gpt_model,
-            api_key=settings.API_KEY,
-            user_api_key=self.agent_config["user_api_key"],
-            prompt=get_prompt(self.agent_config["prompt_id"], self.prompts_collection),
-            chat_history=self.history,
-            decoded_token=self.decoded_token,
-            attachments=self.attachments,
-            json_schema=self.agent_config.get("json_schema"),
-        )
-
     def create_retriever(self):
-        """Create and return the configured retriever"""
         return RetrieverCreator.create_retriever(
             self.retriever_config["retriever_name"],
             source=self.source,
             chat_history=self.history,
             prompt=get_prompt(self.agent_config["prompt_id"], self.prompts_collection),
             chunks=self.retriever_config["chunks"],
-            token_limit=self.retriever_config["token_limit"],
-            gpt_model=self.gpt_model,
+            doc_token_limit=self.retriever_config.get("doc_token_limit", 50000),
+            model_id=self.model_id,
             user_api_key=self.agent_config["user_api_key"],
             decoded_token=self.decoded_token,
         )
+
+    def pre_fetch_docs(self, question: str) -> tuple[Optional[str], Optional[list]]:
+        """Pre-fetch documents for template rendering before agent creation"""
+        if self.data.get("isNoneDoc", False):
+            logger.info("Pre-fetch skipped: isNoneDoc=True")
+            return None, None
+        try:
+            retriever = self.create_retriever()
+            logger.info(
+                f"Pre-fetching docs with chunks={retriever.chunks}, doc_token_limit={retriever.doc_token_limit}"
+            )
+            docs = retriever.search(question)
+            logger.info(f"Pre-fetch retrieved {len(docs) if docs else 0} documents")
+
+            if not docs:
+                logger.info("Pre-fetch: No documents returned from search")
+                return None, None
+            self.retrieved_docs = docs
+
+            docs_with_filenames = []
+            for doc in docs:
+                filename = doc.get("filename") or doc.get("title") or doc.get("source")
+                if filename:
+                    chunk_header = str(filename)
+                    docs_with_filenames.append(f"{chunk_header}\n{doc['text']}")
+                else:
+                    docs_with_filenames.append(doc["text"])
+            docs_together = "\n\n".join(docs_with_filenames)
+
+            logger.info(f"Pre-fetch docs_together size: {len(docs_together)} chars")
+
+            return docs_together, docs
+        except Exception as e:
+            logger.error(f"Failed to pre-fetch docs: {str(e)}", exc_info=True)
+            return None, None
+
+    def pre_fetch_tools(self) -> Optional[Dict[str, Any]]:
+        """Pre-fetch tool data for template rendering before agent creation
+
+        Can be controlled via:
+        1. Global setting: ENABLE_TOOL_PREFETCH in .env
+        2. Per-request: disable_tool_prefetch in request data
+        """
+        if not settings.ENABLE_TOOL_PREFETCH:
+            logger.info(
+                "Tool pre-fetching disabled globally via ENABLE_TOOL_PREFETCH setting"
+            )
+            return None
+
+        if self.data.get("disable_tool_prefetch", False):
+            logger.info("Tool pre-fetching disabled for this request")
+            return None
+
+        required_tool_actions = self._get_required_tool_actions()
+        filtering_enabled = required_tool_actions is not None
+
+        try:
+            user_tools_collection = self.db["user_tools"]
+            user_id = self.initial_user_id or "local"
+
+            user_tools = list(
+                user_tools_collection.find({"user": user_id, "status": True})
+            )
+
+            if not user_tools:
+                return None
+
+            tools_data = {}
+
+            for tool_doc in user_tools:
+                tool_name = tool_doc.get("name")
+                tool_id = str(tool_doc.get("_id"))
+
+                if filtering_enabled:
+                    required_actions_by_name = required_tool_actions.get(
+                        tool_name, set()
+                    )
+                    required_actions_by_id = required_tool_actions.get(tool_id, set())
+
+                    required_actions = required_actions_by_name | required_actions_by_id
+
+                    if not required_actions:
+                        continue
+                else:
+                    required_actions = None
+
+                tool_data = self._fetch_tool_data(tool_doc, required_actions)
+                if tool_data:
+                    tools_data[tool_name] = tool_data
+                    tools_data[tool_id] = tool_data
+
+            return tools_data if tools_data else None
+        except Exception as e:
+            logger.warning(f"Failed to pre-fetch tools: {type(e).__name__}")
+            return None
+
+    def _fetch_tool_data(
+        self,
+        tool_doc: Dict[str, Any],
+        required_actions: Optional[Set[Optional[str]]],
+    ) -> Optional[Dict[str, Any]]:
+        """Fetch and execute tool actions with saved parameters"""
+        try:
+            from application.agents.tools.tool_manager import ToolManager
+
+            tool_name = tool_doc.get("name")
+            tool_config = tool_doc.get("config", {}).copy()
+            tool_config["tool_id"] = str(tool_doc["_id"])
+
+            tool_manager = ToolManager(config={tool_name: tool_config})
+            user_id = self.initial_user_id or "local"
+            tool = tool_manager.load_tool(tool_name, tool_config, user_id=user_id)
+
+            if not tool:
+                logger.debug(f"Tool '{tool_name}' failed to load")
+                return None
+
+            tool_actions = tool.get_actions_metadata()
+            if not tool_actions:
+                logger.debug(f"Tool '{tool_name}' has no actions")
+                return None
+
+            saved_actions = tool_doc.get("actions", [])
+
+            include_all_actions = required_actions is None or (
+                required_actions and None in required_actions
+            )
+            allowed_actions: Set[str] = (
+                {action for action in required_actions if isinstance(action, str)}
+                if required_actions
+                else set()
+            )
+
+            action_results = {}
+            for action_meta in tool_actions:
+                action_name = action_meta.get("name")
+                if action_name is None:
+                    continue
+                if (
+                    not include_all_actions
+                    and allowed_actions
+                    and action_name not in allowed_actions
+                ):
+                    continue
+
+                try:
+                    saved_action = None
+                    for sa in saved_actions:
+                        if sa.get("name") == action_name:
+                            saved_action = sa
+                            break
+
+                    action_params = action_meta.get("parameters", {})
+                    properties = action_params.get("properties", {})
+
+                    kwargs = {}
+                    for param_name, param_spec in properties.items():
+                        if saved_action:
+                            saved_props = saved_action.get("parameters", {}).get(
+                                "properties", {}
+                            )
+                            if param_name in saved_props:
+                                param_value = saved_props[param_name].get("value")
+                                if param_value is not None:
+                                    kwargs[param_name] = param_value
+                                    continue
+
+                        if param_name in tool_config:
+                            kwargs[param_name] = tool_config[param_name]
+                        elif "default" in param_spec:
+                            kwargs[param_name] = param_spec["default"]
+
+                    result = tool.execute_action(action_name, **kwargs)
+                    action_results[action_name] = result
+                except Exception as e:
+                    logger.debug(
+                        f"Action '{action_name}' execution failed: {type(e).__name__}"
+                    )
+                    continue
+
+            return action_results if action_results else None
+
+        except Exception as e:
+            logger.debug(f"Tool pre-fetch failed for '{tool_name}': {type(e).__name__}")
+            return None
+
+    def _get_prompt_content(self) -> Optional[str]:
+        """Retrieve and cache the raw prompt content for the current agent configuration."""
+        if self._prompt_content is not None:
+            return self._prompt_content
+        prompt_id = (
+            self.agent_config.get("prompt_id")
+            if isinstance(self.agent_config, dict)
+            else None
+        )
+        if not prompt_id:
+            return None
+        try:
+            self._prompt_content = get_prompt(prompt_id, self.prompts_collection)
+        except ValueError as e:
+            logger.debug(f"Invalid prompt ID '{prompt_id}': {str(e)}")
+            self._prompt_content = None
+        except Exception as e:
+            logger.debug(f"Failed to fetch prompt '{prompt_id}': {type(e).__name__}")
+            self._prompt_content = None
+        return self._prompt_content
+
+    def _get_required_tool_actions(self) -> Optional[Dict[str, Set[Optional[str]]]]:
+        """Determine which tool actions are referenced in the prompt template"""
+        if self._required_tool_actions is not None:
+            return self._required_tool_actions
+
+        prompt_content = self._get_prompt_content()
+        if prompt_content is None:
+            return None
+
+        if "{{" not in prompt_content or "}}" not in prompt_content:
+            self._required_tool_actions = {}
+            return self._required_tool_actions
+
+        try:
+            from application.templates.template_engine import TemplateEngine
+
+            template_engine = TemplateEngine()
+            usages = template_engine.extract_tool_usages(prompt_content)
+            self._required_tool_actions = usages
+            return self._required_tool_actions
+        except Exception as e:
+            logger.debug(f"Failed to extract tool usages: {type(e).__name__}")
+            self._required_tool_actions = {}
+            return self._required_tool_actions
+
+    def _fetch_memory_tool_data(
+        self, tool_doc: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """Fetch memory tool data for pre-injection into prompt"""
+        try:
+            tool_config = tool_doc.get("config", {}).copy()
+            tool_config["tool_id"] = str(tool_doc["_id"])
+
+            from application.agents.tools.memory import MemoryTool
+
+            memory_tool = MemoryTool(tool_config, self.initial_user_id)
+
+            root_view = memory_tool.execute_action("view", path="/")
+
+            if "Error:" in root_view or not root_view.strip():
+                return None
+
+            return {"root": root_view, "available": True}
+        except Exception as e:
+            logger.warning(f"Failed to fetch memory tool data: {str(e)}")
+            return None
+
+    def create_agent(
+        self,
+        docs_together: Optional[str] = None,
+        docs: Optional[list] = None,
+        tools_data: Optional[Dict[str, Any]] = None,
+    ):
+        """Create and return the configured agent with rendered prompt"""
+        raw_prompt = self._get_prompt_content()
+        if raw_prompt is None:
+            raw_prompt = get_prompt(
+                self.agent_config["prompt_id"], self.prompts_collection
+            )
+            self._prompt_content = raw_prompt
+
+        rendered_prompt = self.prompt_renderer.render_prompt(
+            prompt_content=raw_prompt,
+            user_id=self.initial_user_id,
+            request_id=self.data.get("request_id"),
+            passthrough_data=self.data.get("passthrough"),
+            docs=docs,
+            docs_together=docs_together,
+            tools_data=tools_data,
+        )
+
+        provider = (
+            get_provider_from_model_id(self.model_id)
+            if self.model_id
+            else settings.LLM_PROVIDER
+        )
+        system_api_key = get_api_key_for_provider(provider or settings.LLM_PROVIDER)
+
+        agent = AgentCreator.create_agent(
+            self.agent_config["agent_type"],
+            endpoint="stream",
+            llm_name=provider or settings.LLM_PROVIDER,
+            model_id=self.model_id,
+            api_key=system_api_key,
+            user_api_key=self.agent_config["user_api_key"],
+            prompt=rendered_prompt,
+            chat_history=self.history,
+            retrieved_docs=self.retrieved_docs,
+            decoded_token=self.decoded_token,
+            attachments=self.attachments,
+            json_schema=self.agent_config.get("json_schema"),
+            compressed_summary=self.compressed_summary,
+        )
+
+        agent.conversation_id = self.conversation_id
+        agent.initial_user_id = self.initial_user_id
+
+        return agent

application/api/connector/routes.py

@@ -23,15 +23,9 @@ from application.core.settings import settings
 from application.api import api
 
 
-from application.utils import (
-    check_required_fields
-)
-
-
 from application.parser.connectors.connector_creator import ConnectorCreator
 
 
-
 mongo = MongoDB.get_client()
 db = mongo[settings.MONGO_DB_NAME]
 sources_collection = db["sources"]
@@ -43,185 +37,6 @@ api.add_namespace(connectors_ns)
 
 
 
-@connectors_ns.route("/api/connectors/upload")
-class UploadConnector(Resource):
-    @api.expect(
-        api.model(
-            "ConnectorUploadModel",
-            {
-                "user": fields.String(required=True, description="User ID"),
-                "source": fields.String(
-                    required=True, description="Source type (google_drive, github, etc.)"
-                ),
-                "name": fields.String(required=True, description="Job name"),
-                "data": fields.String(required=True, description="Configuration data"),
-                "repo_url": fields.String(description="GitHub repository URL"),
-            },
-        )
-    )
-    @api.doc(
-        description="Uploads connector source for vectorization",
-    )
-    def post(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        data = request.form
-        required_fields = ["user", "source", "name", "data"]
-        missing_fields = check_required_fields(data, required_fields)
-        if missing_fields:
-            return missing_fields
-        try:
-            config = json.loads(data["data"])
-            source_data = None
-            sync_frequency = config.get("sync_frequency", "never")
-
-            if data["source"] == "github":
-                source_data = config.get("repo_url")
-            elif data["source"] in ["crawler", "url"]:
-                source_data = config.get("url")
-            elif data["source"] == "reddit":
-                source_data = config
-            elif data["source"] in ConnectorCreator.get_supported_connectors():
-                session_token = config.get("session_token")
-                if not session_token:
-                    return make_response(jsonify({
-                        "success": False,
-                        "error": f"Missing session_token in {data['source']} configuration"
-                    }), 400)
-
-                file_ids = config.get("file_ids", [])
-                if isinstance(file_ids, str):
-                    file_ids = [id.strip() for id in file_ids.split(',') if id.strip()]
-                elif not isinstance(file_ids, list):
-                    file_ids = []
-
-                folder_ids = config.get("folder_ids", [])
-                if isinstance(folder_ids, str):
-                    folder_ids = [id.strip() for id in folder_ids.split(',') if id.strip()]
-                elif not isinstance(folder_ids, list):
-                    folder_ids = []
-
-                config["file_ids"] = file_ids
-                config["folder_ids"] = folder_ids
-
-                task = ingest_connector_task.delay(
-                    job_name=data["name"],
-                    user=decoded_token.get("sub"),
-                    source_type=data["source"],
-                    session_token=session_token,
-                    file_ids=file_ids,
-                    folder_ids=folder_ids,
-                    recursive=config.get("recursive", False),
-                    retriever=config.get("retriever", "classic"),
-                    sync_frequency=sync_frequency
-                )
-                return make_response(jsonify({"success": True, "task_id": task.id}), 200)
-            task = ingest_connector_task.delay(
-                source_data=source_data,
-                job_name=data["name"],
-                user=decoded_token.get("sub"),
-                loader=data["source"],
-                sync_frequency=sync_frequency
-            )
-        except Exception as err:
-            current_app.logger.error(
-                f"Error uploading connector source: {err}", exc_info=True
-            )
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"success": True, "task_id": task.id}), 200)
-
-
-@connectors_ns.route("/api/connectors/task_status")
-class ConnectorTaskStatus(Resource):
-    task_status_model = api.model(
-        "ConnectorTaskStatusModel",
-        {"task_id": fields.String(required=True, description="Task ID")},
-    )
-
-    @api.expect(task_status_model)
-    @api.doc(description="Get connector task status")
-    def get(self):
-        task_id = request.args.get("task_id")
-        if not task_id:
-            return make_response(
-                jsonify({"success": False, "message": "Task ID is required"}), 400
-            )
-        try:
-            from application.celery_init import celery
-
-            task = celery.AsyncResult(task_id)
-            task_meta = task.info
-            print(f"Task status: {task.status}")
-            if not isinstance(
-                task_meta, (dict, list, str, int, float, bool, type(None))
-            ):
-                task_meta = str(task_meta)
-        except Exception as err:
-            current_app.logger.error(f"Error getting task status: {err}", exc_info=True)
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"status": task.status, "result": task_meta}), 200)
-
-
-@connectors_ns.route("/api/connectors/sources")
-class ConnectorSources(Resource):
-    @api.doc(description="Get connector sources")
-    def get(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        user = decoded_token.get("sub")
-        try:
-            sources = sources_collection.find({"user": user, "type": "connector:file"}).sort("date", -1)
-            connector_sources = []
-            for source in sources:
-                connector_sources.append({
-                    "id": str(source["_id"]),
-                    "name": source.get("name"),
-                    "date": source.get("date"),
-                    "type": source.get("type"),
-                    "source": source.get("source"),
-                    "tokens": source.get("tokens", ""),
-                    "retriever": source.get("retriever", "classic"),
-                    "syncFrequency": source.get("sync_frequency", ""),
-                })
-        except Exception as err:
-            current_app.logger.error(f"Error retrieving connector sources: {err}", exc_info=True)
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify(connector_sources), 200)
-
-
-@connectors_ns.route("/api/connectors/delete")
-class DeleteConnectorSource(Resource):
-    @api.doc(
-        description="Delete a connector source",
-        params={"source_id": "The source ID to delete"},
-    )
-    def delete(self):
-        decoded_token = request.decoded_token
-        if not decoded_token:
-            return make_response(jsonify({"success": False}), 401)
-        source_id = request.args.get("source_id")
-        if not source_id:
-            return make_response(
-                jsonify({"success": False, "message": "source_id is required"}), 400
-            )
-        try:
-            result = sources_collection.delete_one(
-                {"_id": ObjectId(source_id), "user": decoded_token.get("sub")}
-            )
-            if result.deleted_count == 0:
-                return make_response(
-                    jsonify({"success": False, "message": "Source not found"}), 404
-                )
-        except Exception as err:
-            current_app.logger.error(
-                f"Error deleting connector source: {err}", exc_info=True
-            )
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"success": True}), 200)
-
-
 @connectors_ns.route("/api/connectors/auth")
 class ConnectorAuth(Resource):
     @api.doc(description="Get connector OAuth authorization URL", params={"provider": "Connector provider (e.g., google_drive)"})
@@ -337,27 +152,6 @@ class ConnectorsCallback(Resource):
             return redirect("/api/connectors/callback-status?status=error&message=Authentication+failed.+Please+try+again+and+make+sure+to+grant+all+requested+permissions.")
 
 
-@connectors_ns.route("/api/connectors/refresh")
-class ConnectorRefresh(Resource):
-    @api.expect(api.model("ConnectorRefreshModel", {"provider": fields.String(required=True), "refresh_token": fields.String(required=True)}))
-    @api.doc(description="Refresh connector access token")
-    def post(self):
-        try:
-            data = request.get_json()
-            provider = data.get('provider')
-            refresh_token = data.get('refresh_token')
-
-            if not provider or not refresh_token:
-                return make_response(jsonify({"success": False, "error": "provider and refresh_token are required"}), 400)
-
-            auth = ConnectorCreator.create_auth(provider)
-            token_info = auth.refresh_access_token(refresh_token)
-            return make_response(jsonify({"success": True, "token_info": token_info}), 200)
-        except Exception as e:
-            current_app.logger.error(f"Error refreshing token for connector: {e}")
-            return make_response(jsonify({"success": False, "error": str(e)}), 500)
-
-
 @connectors_ns.route("/api/connectors/files")
 class ConnectorFiles(Resource):
     @api.expect(api.model("ConnectorFilesModel", {

application/api/user/agents/routes.py

@@ -19,6 +19,7 @@ from application.api.user.base import (
     storage,
     users_collection,
 )
+from application.core.settings import settings
 from application.utils import (
     check_required_fields,
     generate_image_url,
@@ -74,6 +75,14 @@ class GetAgent(Resource):
                 "agent_type": agent.get("agent_type", ""),
                 "status": agent.get("status", ""),
                 "json_schema": agent.get("json_schema"),
+                "limited_token_mode": agent.get("limited_token_mode", False),
+                "token_limit": agent.get(
+                    "token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"]
+                ),
+                "limited_request_mode": agent.get("limited_request_mode", False),
+                "request_limit": agent.get(
+                    "request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"]
+                ),
                 "created_at": agent.get("createdAt", ""),
                 "updated_at": agent.get("updatedAt", ""),
                 "last_used_at": agent.get("lastUsedAt", ""),
@@ -86,6 +95,8 @@ class GetAgent(Resource):
                 "shared": agent.get("shared_publicly", False),
                 "shared_metadata": agent.get("shared_metadata", {}),
                 "shared_token": agent.get("shared_token", ""),
+                "models": agent.get("models", []),
+                "default_model_id": agent.get("default_model_id", ""),
             }
             return make_response(jsonify(data), 200)
         except Exception as e:
@@ -143,6 +154,14 @@ class GetAgents(Resource):
                     "agent_type": agent.get("agent_type", ""),
                     "status": agent.get("status", ""),
                     "json_schema": agent.get("json_schema"),
+                    "limited_token_mode": agent.get("limited_token_mode", False),
+                    "token_limit": agent.get(
+                        "token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"]
+                    ),
+                    "limited_request_mode": agent.get("limited_request_mode", False),
+                    "request_limit": agent.get(
+                        "request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"]
+                    ),
                     "created_at": agent.get("createdAt", ""),
                     "updated_at": agent.get("updatedAt", ""),
                     "last_used_at": agent.get("lastUsedAt", ""),
@@ -155,6 +174,8 @@ class GetAgents(Resource):
                     "shared": agent.get("shared_publicly", False),
                     "shared_metadata": agent.get("shared_metadata", {}),
                     "shared_token": agent.get("shared_token", ""),
+                    "models": agent.get("models", []),
+                    "default_model_id": agent.get("default_model_id", ""),
                 }
                 for agent in agents
                 if "source" in agent or "retriever" in agent
@@ -199,6 +220,28 @@ class CreateAgent(Resource):
                 required=False,
                 description="JSON schema for enforcing structured output format",
             ),
+            "limited_token_mode": fields.Boolean(
+                required=False, description="Whether the agent is in limited token mode"
+            ),
+            "token_limit": fields.Integer(
+                required=False, description="Token limit for the agent in limited mode"
+            ),
+            "limited_request_mode": fields.Boolean(
+                required=False,
+                description="Whether the agent is in limited request mode",
+            ),
+            "request_limit": fields.Integer(
+                required=False,
+                description="Request limit for the agent in limited mode",
+            ),
+            "models": fields.List(
+                fields.String,
+                required=False,
+                description="List of available model IDs for this agent",
+            ),
+            "default_model_id": fields.String(
+                required=False, description="Default model ID for this agent"
+            ),
         },
     )
 
@@ -227,6 +270,11 @@ class CreateAgent(Resource):
                     data["json_schema"] = json.loads(data["json_schema"])
                 except json.JSONDecodeError:
                     data["json_schema"] = None
+            if "models" in data:
+                try:
+                    data["models"] = json.loads(data["models"])
+                except json.JSONDecodeError:
+                    data["models"] = []
         print(f"Received data: {data}")
 
         # Validate JSON schema if provided
@@ -344,10 +392,32 @@ class CreateAgent(Resource):
                 "agent_type": data.get("agent_type", ""),
                 "status": data.get("status"),
                 "json_schema": data.get("json_schema"),
+                "limited_token_mode": (
+                    data.get("limited_token_mode") == "True"
+                    if isinstance(data.get("limited_token_mode"), str)
+                    else bool(data.get("limited_token_mode", False))
+                ),
+                "token_limit": int(
+                    data.get(
+                        "token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"]
+                    )
+                ),
+                "limited_request_mode": (
+                    data.get("limited_request_mode") == "True"
+                    if isinstance(data.get("limited_request_mode"), str)
+                    else bool(data.get("limited_request_mode", False))
+                ),
+                "request_limit": int(
+                    data.get(
+                        "request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"]
+                    )
+                ),
                 "createdAt": datetime.datetime.now(datetime.timezone.utc),
                 "updatedAt": datetime.datetime.now(datetime.timezone.utc),
                 "lastUsedAt": None,
                 "key": key,
+                "models": data.get("models", []),
+                "default_model_id": data.get("default_model_id", ""),
             }
             if new_agent["chunks"] == "":
                 new_agent["chunks"] = "2"
@@ -399,6 +469,28 @@ class UpdateAgent(Resource):
                 required=False,
                 description="JSON schema for enforcing structured output format",
             ),
+            "limited_token_mode": fields.Boolean(
+                required=False, description="Whether the agent is in limited token mode"
+            ),
+            "token_limit": fields.Integer(
+                required=False, description="Token limit for the agent in limited mode"
+            ),
+            "limited_request_mode": fields.Boolean(
+                require=False,
+                description="Whether the agent is in limited request mode",
+            ),
+            "request_limit": fields.Integer(
+                required=False,
+                description="Request limit for the agent in limited mode",
+            ),
+            "models": fields.List(
+                fields.String,
+                required=False,
+                description="List of available model IDs for this agent",
+            ),
+            "default_model_id": fields.String(
+                required=False, description="Default model ID for this agent"
+            ),
         },
     )
 
@@ -422,7 +514,7 @@ class UpdateAgent(Resource):
                 data = request.get_json()
             else:
                 data = request.form.to_dict()
-                json_fields = ["tools", "sources", "json_schema"]
+                json_fields = ["tools", "sources", "json_schema", "models"]
                 for field in json_fields:
                     if field in data and data[field]:
                         try:
@@ -486,6 +578,12 @@ class UpdateAgent(Resource):
             "agent_type",
             "status",
             "json_schema",
+            "limited_token_mode",
+            "token_limit",
+            "limited_request_mode",
+            "request_limit",
+            "models",
+            "default_model_id",
         ]
 
         for field in allowed_fields:
@@ -602,6 +700,74 @@ class UpdateAgent(Resource):
                     update_fields[field] = json_schema
                 else:
                     update_fields[field] = None
+            elif field == "limited_token_mode":
+                raw_value = data.get("limited_token_mode", False)
+                bool_value = (
+                    raw_value == "True"
+                    if isinstance(raw_value, str)
+                    else bool(raw_value)
+                )
+                update_fields[field] = bool_value
+
+                if bool_value and data.get("token_limit") is None:
+                    return make_response(
+                        jsonify(
+                            {
+                                "success": False,
+                                "message": "Token limit must be provided when limited token mode is enabled",
+                            }
+                        ),
+                        400,
+                    )
+            elif field == "limited_request_mode":
+                raw_value = data.get("limited_request_mode", False)
+                bool_value = (
+                    raw_value == "True"
+                    if isinstance(raw_value, str)
+                    else bool(raw_value)
+                )
+                update_fields[field] = bool_value
+
+                if bool_value and data.get("request_limit") is None:
+                    return make_response(
+                        jsonify(
+                            {
+                                "success": False,
+                                "message": "Request limit must be provided when limited request mode is enabled",
+                            }
+                        ),
+                        400,
+                    )
+            elif field == "token_limit":
+                token_limit = data.get("token_limit")
+                # Convert to int and store
+                update_fields[field] = int(token_limit) if token_limit else 0
+
+                # Validate consistency with mode
+                if update_fields[field] > 0 and not data.get("limited_token_mode"):
+                    return make_response(
+                        jsonify(
+                            {
+                                "success": False,
+                                "message": "Token limit cannot be set when limited token mode is disabled",
+                            }
+                        ),
+                        400,
+                    )
+            elif field == "request_limit":
+                request_limit = data.get("request_limit")
+                update_fields[field] = int(request_limit) if request_limit else 0
+
+                if update_fields[field] > 0 and not data.get("limited_request_mode"):
+                    return make_response(
+                        jsonify(
+                            {
+                                "success": False,
+                                "message": "Request limit cannot be set when limited request mode is disabled",
+                            }
+                        ),
+                        400,
+                    )
             else:
                 value = data[field]
                 if field in ["name", "description", "prompt_id", "agent_type"]:
@@ -822,6 +988,70 @@ class PinnedAgents(Resource):
         return make_response(jsonify(list_pinned_agents), 200)
 
 
+@agents_ns.route("/template_agents")
+class GetTemplateAgents(Resource):
+    @api.doc(description="Get template/premade agents")
+    def get(self):
+        try:
+            template_agents = agents_collection.find({"user": "system"})
+            template_agents = [
+                {
+                    "id": str(agent["_id"]),
+                    "name": agent["name"],
+                    "description": agent["description"],
+                    "image": agent.get("image", ""),
+                }
+                for agent in template_agents
+            ]
+            return make_response(jsonify(template_agents), 200)
+        except Exception as e:
+            current_app.logger.error(f"Template agents fetch error: {e}", exc_info=True)
+            return make_response(jsonify({"success": False}), 400)
+
+
+@agents_ns.route("/adopt_agent")
+class AdoptAgent(Resource):
+    @api.doc(params={"id": "Agent ID"}, description="Adopt an agent by ID")
+    def post(self):
+        if not (decoded_token := request.decoded_token):
+            return make_response(jsonify({"success": False}), 401)
+
+        if not (agent_id := request.args.get("id")):
+            return make_response(
+                jsonify({"success": False, "message": "ID required"}), 400
+            )
+
+        try:
+            agent = agents_collection.find_one(
+                {"_id": ObjectId(agent_id), "user": "system"}
+            )
+            if not agent:
+                return make_response(jsonify({"status": "Not found"}), 404)
+
+            new_agent = agent.copy()
+            new_agent.pop("_id", None)
+            new_agent["user"] = decoded_token["sub"]
+            new_agent["status"] = "published"
+            new_agent["lastUsedAt"] = datetime.datetime.now(datetime.timezone.utc)
+            new_agent["key"] = str(uuid.uuid4())
+            insert_result = agents_collection.insert_one(new_agent)
+
+            response_agent = new_agent.copy()
+            response_agent.pop("_id", None)
+            response_agent["id"] = str(insert_result.inserted_id)
+            response_agent["tool_details"] = resolve_tool_details(
+                response_agent.get("tools", [])
+            )
+            if isinstance(response_agent.get("source"), DBRef):
+                response_agent["source"] = str(response_agent["source"].id)
+            return make_response(
+                jsonify({"success": True, "agent": response_agent}), 200
+            )
+        except Exception as e:
+            current_app.logger.error(f"Agent adopt error: {e}", exc_info=True)
+            return make_response(jsonify({"success": False}), 400)
+
+
 @agents_ns.route("/pin_agent")
 class PinAgent(Resource):
     @api.doc(params={"id": "ID of the agent"}, description="Pin or unpin an agent")

application/api/user/agents/sharing.py

@@ -9,6 +9,7 @@ from flask import current_app, jsonify, make_response, request
 from flask_restx import fields, Namespace, Resource
 
 from application.api import api
+from application.core.settings import settings
 from application.api.user.base import (
     agents_collection,
     db,
@@ -75,6 +76,10 @@ class SharedAgent(Resource):
                 "agent_type": shared_agent.get("agent_type", ""),
                 "status": shared_agent.get("status", ""),
                 "json_schema": shared_agent.get("json_schema"),
+                "limited_token_mode": shared_agent.get("limited_token_mode", False),
+                "token_limit": shared_agent.get("token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"]),
+                "limited_request_mode": shared_agent.get("limited_request_mode", False),
+                "request_limit": shared_agent.get("request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"]),
                 "created_at": shared_agent.get("createdAt", ""),
                 "updated_at": shared_agent.get("updatedAt", ""),
                 "shared": shared_agent.get("shared_publicly", False),
@@ -149,6 +154,10 @@ class SharedAgents(Resource):
                     "agent_type": agent.get("agent_type", ""),
                     "status": agent.get("status", ""),
                     "json_schema": agent.get("json_schema"),
+                    "limited_token_mode": agent.get("limited_token_mode", False),
+                    "token_limit": agent.get("token_limit", settings.DEFAULT_AGENT_LIMITS["token_limit"]),
+                    "limited_request_mode": agent.get("limited_request_mode", False),
+                    "request_limit": agent.get("request_limit", settings.DEFAULT_AGENT_LIMITS["request_limit"]),
                     "created_at": agent.get("createdAt", ""),
                     "updated_at": agent.get("updatedAt", ""),
                     "pinned": str(agent["_id"]) in pinned_ids,

application/api/user/attachments/routes.py

@@ -10,7 +10,7 @@ from application.api import api
 from application.api.user.base import agents_collection, storage
 from application.api.user.tasks import store_attachment
 from application.core.settings import settings
-from application.tts.google_tts import GoogleTTS
+from application.tts.tts_creator import TTSCreator
 from application.utils import safe_filename
 
 
@@ -25,7 +25,7 @@ class StoreAttachment(Resource):
         api.model(
             "AttachmentModel",
             {
-                "file": fields.Raw(required=True, description="File to upload"),
+                "file": fields.Raw(required=True, description="File(s) to upload"),
                 "api_key": fields.String(
                     required=False, description="API key (optional)"
                 ),
@@ -33,18 +33,24 @@ class StoreAttachment(Resource):
         )
     )
     @api.doc(
-        description="Stores a single attachment without vectorization or training. Supports user or API key authentication."
+        description="Stores one or multiple attachments without vectorization or training. Supports user or API key authentication."
     )
     def post(self):
         decoded_token = getattr(request, "decoded_token", None)
         api_key = request.form.get("api_key") or request.args.get("api_key")
-        file = request.files.get("file")
-
-        if not file or file.filename == "":
+        
+        files = request.files.getlist("file")
+        if not files:
+            single_file = request.files.get("file")
+            if single_file:
+                files = [single_file]
+        
+        if not files or all(f.filename == "" for f in files):
             return make_response(
-                jsonify({"status": "error", "message": "Missing file"}),
+                jsonify({"status": "error", "message": "Missing file(s)"}),
                 400,
             )
+        
         user = None
         if decoded_token:
             user = safe_filename(decoded_token.get("sub"))
@@ -59,32 +65,74 @@ class StoreAttachment(Resource):
             return make_response(
                 jsonify({"success": False, "message": "Authentication required"}), 401
             )
+        
         try:
-            attachment_id = ObjectId()
-            original_filename = safe_filename(os.path.basename(file.filename))
-            relative_path = f"{settings.UPLOAD_FOLDER}/{user}/attachments/{str(attachment_id)}/{original_filename}"
+            tasks = []
+            errors = []
+            original_file_count = len(files)
+            
+            for idx, file in enumerate(files):
+                try:
+                    attachment_id = ObjectId()
+                    original_filename = safe_filename(os.path.basename(file.filename))
+                    relative_path = f"{settings.UPLOAD_FOLDER}/{user}/attachments/{str(attachment_id)}/{original_filename}"
 
-            metadata = storage.save_file(file, relative_path)
-
-            file_info = {
-                "filename": original_filename,
-                "attachment_id": str(attachment_id),
-                "path": relative_path,
-                "metadata": metadata,
-            }
-
-            task = store_attachment.delay(file_info, user)
-
-            return make_response(
-                jsonify(
-                    {
-                        "success": True,
-                        "task_id": task.id,
-                        "message": "File uploaded successfully. Processing started.",
+                    metadata = storage.save_file(file, relative_path)
+                    file_info = {
+                        "filename": original_filename,
+                        "attachment_id": str(attachment_id),
+                        "path": relative_path,
+                        "metadata": metadata,
                     }
-                ),
-                200,
-            )
+
+                    task = store_attachment.delay(file_info, user)
+                    tasks.append({
+                        "task_id": task.id,
+                        "filename": original_filename,
+                        "attachment_id": str(attachment_id),
+                    })
+                except Exception as file_err:
+                    current_app.logger.error(f"Error processing file {idx} ({file.filename}): {file_err}", exc_info=True)
+                    errors.append({
+                        "filename": file.filename,
+                        "error": str(file_err)
+                    })
+            
+            if not tasks:
+                error_msg = "No valid files to upload"
+                if errors:
+                    error_msg += f". Errors: {errors}"
+                return make_response(
+                    jsonify({"status": "error", "message": error_msg, "errors": errors}),
+                    400,
+                )
+            
+            if original_file_count == 1 and len(tasks) == 1:
+                current_app.logger.info("Returning single task_id response")
+                return make_response(
+                    jsonify(
+                        {
+                            "success": True,
+                            "task_id": tasks[0]["task_id"],
+                            "message": "File uploaded successfully. Processing started.",
+                        }
+                    ),
+                    200,
+                )
+            else:
+                response_data = {
+                    "success": True,
+                    "tasks": tasks,
+                    "message": f"{len(tasks)} file(s) uploaded successfully. Processing started.",
+                }
+                if errors:
+                    response_data["errors"] = errors
+                    response_data["message"] += f" {len(errors)} file(s) failed."
+                
+                return make_response(
+                    jsonify(response_data),
+                    200,
+                )
         except Exception as err:
             current_app.logger.error(f"Error storing attachment: {err}", exc_info=True)
             return make_response(jsonify({"success": False, "error": str(err)}), 400)
@@ -133,7 +181,7 @@ class TextToSpeech(Resource):
         data = request.get_json()
         text = data["text"]
         try:
-            tts_instance = GoogleTTS()
+            tts_instance = TTSCreator.create_tts(settings.TTS_PROVIDER)
             audio_base64, detected_language = tts_instance.text_to_speech(text)
             return make_response(
                 jsonify(

application/api/user/models/__init__.py

@@ -0,0 +1,3 @@
+from .routes import models_ns
+
+__all__ = ["models_ns"]

application/api/user/models/routes.py

@@ -0,0 +1,25 @@
+from flask import current_app, jsonify, make_response
+from flask_restx import Namespace, Resource
+
+from application.core.model_settings import ModelRegistry
+
+models_ns = Namespace("models", description="Available models", path="/api")
+
+
+@models_ns.route("/models")
+class ModelsListResource(Resource):
+    def get(self):
+        """Get list of available models with their capabilities."""
+        try:
+            registry = ModelRegistry.get_instance()
+            models = registry.get_enabled_models()
+
+            response = {
+                "models": [model.to_dict() for model in models],
+                "default_model_id": registry.default_model_id,
+                "count": len(models),
+            }
+        except Exception as err:
+            current_app.logger.error(f"Error fetching models: {err}", exc_info=True)
+            return make_response(jsonify({"success": False}), 500)
+        return make_response(jsonify(response), 200)

application/api/user/routes.py

@@ -10,6 +10,7 @@ from .agents import agents_ns, agents_sharing_ns, agents_webhooks_ns
 from .analytics import analytics_ns
 from .attachments import attachments_ns
 from .conversations import conversations_ns
+from .models import models_ns
 from .prompts import prompts_ns
 from .sharing import sharing_ns
 from .sources import sources_chunks_ns, sources_ns, sources_upload_ns
@@ -27,6 +28,9 @@ api.add_namespace(attachments_ns)
 # Conversations
 api.add_namespace(conversations_ns)
 
+# Models
+api.add_namespace(models_ns)
+
 # Agents (main, sharing, webhooks)
 api.add_namespace(agents_ns)
 api.add_namespace(agents_sharing_ns)

application/api/user/sharing/routes.py

@@ -13,7 +13,6 @@ from application.api.user.base import (
     agents_collection,
     attachments_collection,
     conversations_collection,
-    db,
     shared_conversations_collections,
 )
 from application.utils import check_required_fields
@@ -97,9 +96,7 @@ class ShareConversation(Resource):
                     api_uuid = pre_existing_api_document["key"]
                     pre_existing = shared_conversations_collections.find_one(
                         {
-                            "conversation_id": DBRef(
-                                "conversations", ObjectId(conversation_id)
-                            ),
+                            "conversation_id": ObjectId(conversation_id),
                             "isPromptable": is_promptable,
                             "first_n_queries": current_n_queries,
                             "user": user,
@@ -120,10 +117,7 @@ class ShareConversation(Resource):
                         shared_conversations_collections.insert_one(
                             {
                                 "uuid": explicit_binary,
-                                "conversation_id": {
-                                    "$ref": "conversations",
-                                    "$id": ObjectId(conversation_id),
-                                },
+                                "conversation_id": ObjectId(conversation_id),
                                 "isPromptable": is_promptable,
                                 "first_n_queries": current_n_queries,
                                 "user": user,
@@ -154,10 +148,7 @@ class ShareConversation(Resource):
                     shared_conversations_collections.insert_one(
                         {
                             "uuid": explicit_binary,
-                            "conversation_id": {
-                                "$ref": "conversations",
-                                "$id": ObjectId(conversation_id),
-                            },
+                            "conversation_id": ObjectId(conversation_id),
                             "isPromptable": is_promptable,
                             "first_n_queries": current_n_queries,
                             "user": user,
@@ -175,9 +166,7 @@ class ShareConversation(Resource):
                     )
             pre_existing = shared_conversations_collections.find_one(
                 {
-                    "conversation_id": DBRef(
-                        "conversations", ObjectId(conversation_id)
-                    ),
+                    "conversation_id": ObjectId(conversation_id),
                     "isPromptable": is_promptable,
                     "first_n_queries": current_n_queries,
                     "user": user,
@@ -197,10 +186,7 @@ class ShareConversation(Resource):
                 shared_conversations_collections.insert_one(
                     {
                         "uuid": explicit_binary,
-                        "conversation_id": {
-                            "$ref": "conversations",
-                            "$id": ObjectId(conversation_id),
-                        },
+                        "conversation_id": ObjectId(conversation_id),
                         "isPromptable": is_promptable,
                         "first_n_queries": current_n_queries,
                         "user": user,
@@ -233,10 +219,12 @@ class GetPubliclySharedConversations(Resource):
             if (
                 shared
                 and "conversation_id" in shared
-                and isinstance(shared["conversation_id"], DBRef)
             ):
-                conversation_ref = shared["conversation_id"]
-                conversation = db.dereference(conversation_ref)
+                # conversation_id is now stored as an ObjectId, not a DBRef
+                conversation_id = shared["conversation_id"]
+                conversation = conversations_collection.find_one(
+                    {"_id": conversation_id}
+                )
                 if conversation is None:
                     return make_response(
                         jsonify(

application/api/user/sources/routes.py

@@ -2,12 +2,10 @@
 
 import json
 import math
-import os
 
 from bson.objectid import ObjectId
 from flask import current_app, jsonify, make_response, redirect, request
 from flask_restx import fields, Namespace, Resource
-from werkzeug.utils import secure_filename
 
 from application.api import api
 from application.api.user.base import sources_collection
@@ -136,31 +134,6 @@ class PaginatedSources(Resource):
             return make_response(jsonify({"success": False}), 400)
 
 
-@sources_ns.route("/docs_check")
-class CheckDocs(Resource):
-    check_docs_model = api.model(
-        "CheckDocsModel",
-        {"docs": fields.String(required=True, description="Document name")},
-    )
-
-    @api.expect(check_docs_model)
-    @api.doc(description="Check if document exists")
-    def post(self):
-        data = request.get_json()
-        required_fields = ["docs"]
-        missing_fields = check_required_fields(data, required_fields)
-        if missing_fields:
-            return missing_fields
-        try:
-            vectorstore = "vectors/" + secure_filename(data["docs"])
-            if os.path.exists(vectorstore) or data["docs"] == "default":
-                return {"status": "exists"}, 200
-        except Exception as err:
-            current_app.logger.error(f"Error checking document: {err}", exc_info=True)
-            return make_response(jsonify({"success": False}), 400)
-        return make_response(jsonify({"status": "not found"}), 404)
-
-
 @sources_ns.route("/delete_by_ids")
 class DeleteByIds(Resource):
     @api.doc(

application/api/user/sources/upload.py

@@ -562,10 +562,21 @@ class TaskStatus(Resource):
             task = celery.AsyncResult(task_id)
             task_meta = task.info
             print(f"Task status: {task.status}")
+
+            if task.status == "PENDING":
+                inspect = celery.control.inspect()
+                active_workers = inspect.ping()
+                if not active_workers:
+                    raise ConnectionError("Service unavailable")
+
             if not isinstance(
                 task_meta, (dict, list, str, int, float, bool, type(None))
             ):
                 task_meta = str(task_meta)  # Convert to a string representation
+        except ConnectionError as err:
+            return make_response(
+                jsonify({"success": False, "message": str(err)}), 503
+            )
         except Exception as err:
             current_app.logger.error(f"Error getting task status: {err}", exc_info=True)
             return make_response(jsonify({"success": False}), 400)

application/api/user/tools/routes.py

@@ -56,9 +56,10 @@ class GetTools(Resource):
             tools = user_tools_collection.find({"user": user})
             user_tools = []
             for tool in tools:
-                tool["id"] = str(tool["_id"])
-                tool.pop("_id")
-                user_tools.append(tool)
+                tool_copy = {**tool}
+                tool_copy["id"] = str(tool["_id"])
+                tool_copy.pop("_id", None)
+                user_tools.append(tool_copy)
         except Exception as err:
             current_app.logger.error(f"Error getting user tools: {err}", exc_info=True)
             return make_response(jsonify({"success": False}), 400)

application/core/model_configs.py

@@ -0,0 +1,189 @@
+"""
+Model configurations for all supported LLM providers.
+"""
+
+from application.core.model_settings import (
+    AvailableModel,
+    ModelCapabilities,
+    ModelProvider,
+)
+
+OPENAI_ATTACHMENTS = [
+    "application/pdf",
+    "image/png",
+    "image/jpeg",
+    "image/jpg",
+    "image/webp",
+    "image/gif",
+]
+
+GOOGLE_ATTACHMENTS = [
+    "application/pdf",
+    "image/png",
+    "image/jpeg",
+    "image/jpg",
+    "image/webp",
+    "image/gif",
+]
+
+
+OPENAI_MODELS = [
+    AvailableModel(
+        id="gpt-5.1",
+        provider=ModelProvider.OPENAI,
+        display_name="GPT-5.1",
+        description="Flagship model with enhanced reasoning, coding, and agentic capabilities",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=OPENAI_ATTACHMENTS,
+            context_window=200000,
+        ),
+    ),
+    AvailableModel(
+        id="gpt-5-mini",
+        provider=ModelProvider.OPENAI,
+        display_name="GPT-5 Mini",
+        description="Faster, cost-effective variant of GPT-5.1",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=OPENAI_ATTACHMENTS,
+            context_window=200000,
+        ),
+    )
+]
+
+
+ANTHROPIC_MODELS = [
+    AvailableModel(
+        id="claude-3-5-sonnet-20241022",
+        provider=ModelProvider.ANTHROPIC,
+        display_name="Claude 3.5 Sonnet (Latest)",
+        description="Latest Claude 3.5 Sonnet with enhanced capabilities",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=200000,
+        ),
+    ),
+    AvailableModel(
+        id="claude-3-5-sonnet",
+        provider=ModelProvider.ANTHROPIC,
+        display_name="Claude 3.5 Sonnet",
+        description="Balanced performance and capability",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=200000,
+        ),
+    ),
+    AvailableModel(
+        id="claude-3-opus",
+        provider=ModelProvider.ANTHROPIC,
+        display_name="Claude 3 Opus",
+        description="Most capable Claude model",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=200000,
+        ),
+    ),
+    AvailableModel(
+        id="claude-3-haiku",
+        provider=ModelProvider.ANTHROPIC,
+        display_name="Claude 3 Haiku",
+        description="Fastest Claude model",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=200000,
+        ),
+    ),
+]
+
+
+GOOGLE_MODELS = [
+    AvailableModel(
+        id="gemini-flash-latest",
+        provider=ModelProvider.GOOGLE,
+        display_name="Gemini Flash (Latest)",
+        description="Latest experimental Gemini model",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=GOOGLE_ATTACHMENTS,
+            context_window=int(1e6),
+        ),
+    ),
+    AvailableModel(
+        id="gemini-flash-lite-latest",
+        provider=ModelProvider.GOOGLE,
+        display_name="Gemini Flash Lite (Latest)",
+        description="Fast with huge context window",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=GOOGLE_ATTACHMENTS,
+            context_window=int(1e6),
+        ),
+    ),
+    AvailableModel(
+        id="gemini-3-pro-preview",
+        provider=ModelProvider.GOOGLE,
+        display_name="Gemini 3 Pro",
+        description="Most capable Gemini model",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=GOOGLE_ATTACHMENTS,
+            context_window=2000000,
+        ),
+    ),
+]
+
+
+GROQ_MODELS = [
+    AvailableModel(
+        id="llama-3.3-70b-versatile",
+        provider=ModelProvider.GROQ,
+        display_name="Llama 3.3 70B",
+        description="Latest Llama model with high-speed inference",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=128000,
+        ),
+    ),
+    AvailableModel(
+        id="llama-3.1-8b-instant",
+        provider=ModelProvider.GROQ,
+        display_name="Llama 3.1 8B",
+        description="Ultra-fast inference",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=128000,
+        ),
+    ),
+    AvailableModel(
+        id="mixtral-8x7b-32768",
+        provider=ModelProvider.GROQ,
+        display_name="Mixtral 8x7B",
+        description="High-speed inference with tools",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            context_window=32768,
+        ),
+    ),
+]
+
+
+AZURE_OPENAI_MODELS = [
+    AvailableModel(
+        id="azure-gpt-4",
+        provider=ModelProvider.AZURE_OPENAI,
+        display_name="Azure OpenAI GPT-4",
+        description="Azure-hosted GPT model",
+        capabilities=ModelCapabilities(
+            supports_tools=True,
+            supports_structured_output=True,
+            supported_attachment_types=OPENAI_ATTACHMENTS,
+            context_window=8192,
+        ),
+    ),
+]

application/core/model_settings.py

@@ -0,0 +1,236 @@
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ModelProvider(str, Enum):
+    OPENAI = "openai"
+    AZURE_OPENAI = "azure_openai"
+    ANTHROPIC = "anthropic"
+    GROQ = "groq"
+    GOOGLE = "google"
+    HUGGINGFACE = "huggingface"
+    LLAMA_CPP = "llama.cpp"
+    DOCSGPT = "docsgpt"
+    PREMAI = "premai"
+    SAGEMAKER = "sagemaker"
+    NOVITA = "novita"
+
+
+@dataclass
+class ModelCapabilities:
+    supports_tools: bool = False
+    supports_structured_output: bool = False
+    supports_streaming: bool = True
+    supported_attachment_types: List[str] = field(default_factory=list)
+    context_window: int = 128000
+    input_cost_per_token: Optional[float] = None
+    output_cost_per_token: Optional[float] = None
+
+
+@dataclass
+class AvailableModel:
+    id: str
+    provider: ModelProvider
+    display_name: str
+    description: str = ""
+    capabilities: ModelCapabilities = field(default_factory=ModelCapabilities)
+    enabled: bool = True
+    base_url: Optional[str] = None
+
+    def to_dict(self) -> Dict:
+        result = {
+            "id": self.id,
+            "provider": self.provider.value,
+            "display_name": self.display_name,
+            "description": self.description,
+            "supported_attachment_types": self.capabilities.supported_attachment_types,
+            "supports_tools": self.capabilities.supports_tools,
+            "supports_structured_output": self.capabilities.supports_structured_output,
+            "supports_streaming": self.capabilities.supports_streaming,
+            "context_window": self.capabilities.context_window,
+            "enabled": self.enabled,
+        }
+        if self.base_url:
+            result["base_url"] = self.base_url
+        return result
+
+
+class ModelRegistry:
+    _instance = None
+    _initialized = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not ModelRegistry._initialized:
+            self.models: Dict[str, AvailableModel] = {}
+            self.default_model_id: Optional[str] = None
+            self._load_models()
+            ModelRegistry._initialized = True
+
+    @classmethod
+    def get_instance(cls) -> "ModelRegistry":
+        return cls()
+
+    def _load_models(self):
+        from application.core.settings import settings
+
+        self.models.clear()
+
+        self._add_docsgpt_models(settings)
+        if settings.OPENAI_API_KEY or (
+            settings.LLM_PROVIDER == "openai" and settings.API_KEY
+        ):
+            self._add_openai_models(settings)
+        if settings.OPENAI_API_BASE or (
+            settings.LLM_PROVIDER == "azure_openai" and settings.API_KEY
+        ):
+            self._add_azure_openai_models(settings)
+        if settings.ANTHROPIC_API_KEY or (
+            settings.LLM_PROVIDER == "anthropic" and settings.API_KEY
+        ):
+            self._add_anthropic_models(settings)
+        if settings.GOOGLE_API_KEY or (
+            settings.LLM_PROVIDER == "google" and settings.API_KEY
+        ):
+            self._add_google_models(settings)
+        if settings.GROQ_API_KEY or (
+            settings.LLM_PROVIDER == "groq" and settings.API_KEY
+        ):
+            self._add_groq_models(settings)
+        if settings.HUGGINGFACE_API_KEY or (
+            settings.LLM_PROVIDER == "huggingface" and settings.API_KEY
+        ):
+            self._add_huggingface_models(settings)
+        # Default model selection
+
+        if settings.LLM_NAME and settings.LLM_NAME in self.models:
+            self.default_model_id = settings.LLM_NAME
+        elif settings.LLM_PROVIDER and settings.API_KEY:
+            for model_id, model in self.models.items():
+                if model.provider.value == settings.LLM_PROVIDER:
+                    self.default_model_id = model_id
+                    break
+        else:
+            self.default_model_id = next(iter(self.models.keys()))
+        logger.info(
+            f"ModelRegistry loaded {len(self.models)} models, default: {self.default_model_id}"
+        )
+
+    def _add_openai_models(self, settings):
+        from application.core.model_configs import OPENAI_MODELS
+
+        if settings.OPENAI_API_KEY:
+            for model in OPENAI_MODELS:
+                self.models[model.id] = model
+            return
+        if settings.LLM_PROVIDER == "openai" and settings.LLM_NAME:
+            for model in OPENAI_MODELS:
+                if model.id == settings.LLM_NAME:
+                    self.models[model.id] = model
+                    return
+        for model in OPENAI_MODELS:
+            self.models[model.id] = model
+
+    def _add_azure_openai_models(self, settings):
+        from application.core.model_configs import AZURE_OPENAI_MODELS
+
+        if settings.LLM_PROVIDER == "azure_openai" and settings.LLM_NAME:
+            for model in AZURE_OPENAI_MODELS:
+                if model.id == settings.LLM_NAME:
+                    self.models[model.id] = model
+                    return
+        for model in AZURE_OPENAI_MODELS:
+            self.models[model.id] = model
+
+    def _add_anthropic_models(self, settings):
+        from application.core.model_configs import ANTHROPIC_MODELS
+
+        if settings.ANTHROPIC_API_KEY:
+            for model in ANTHROPIC_MODELS:
+                self.models[model.id] = model
+            return
+        if settings.LLM_PROVIDER == "anthropic" and settings.LLM_NAME:
+            for model in ANTHROPIC_MODELS:
+                if model.id == settings.LLM_NAME:
+                    self.models[model.id] = model
+                    return
+        for model in ANTHROPIC_MODELS:
+            self.models[model.id] = model
+
+    def _add_google_models(self, settings):
+        from application.core.model_configs import GOOGLE_MODELS
+
+        if settings.GOOGLE_API_KEY:
+            for model in GOOGLE_MODELS:
+                self.models[model.id] = model
+            return
+        if settings.LLM_PROVIDER == "google" and settings.LLM_NAME:
+            for model in GOOGLE_MODELS:
+                if model.id == settings.LLM_NAME:
+                    self.models[model.id] = model
+                    return
+        for model in GOOGLE_MODELS:
+            self.models[model.id] = model
+
+    def _add_groq_models(self, settings):
+        from application.core.model_configs import GROQ_MODELS
+
+        if settings.GROQ_API_KEY:
+            for model in GROQ_MODELS:
+                self.models[model.id] = model
+            return
+        if settings.LLM_PROVIDER == "groq" and settings.LLM_NAME:
+            for model in GROQ_MODELS:
+                if model.id == settings.LLM_NAME:
+                    self.models[model.id] = model
+                    return
+        for model in GROQ_MODELS:
+            self.models[model.id] = model
+
+    def _add_docsgpt_models(self, settings):
+        model_id = "docsgpt-local"
+        model = AvailableModel(
+            id=model_id,
+            provider=ModelProvider.DOCSGPT,
+            display_name="DocsGPT Model",
+            description="Local model",
+            capabilities=ModelCapabilities(
+                supports_tools=False,
+                supported_attachment_types=[],
+            ),
+        )
+        self.models[model_id] = model
+
+    def _add_huggingface_models(self, settings):
+        model_id = "huggingface-local"
+        model = AvailableModel(
+            id=model_id,
+            provider=ModelProvider.HUGGINGFACE,
+            display_name="Hugging Face Model",
+            description="Local Hugging Face model",
+            capabilities=ModelCapabilities(
+                supports_tools=False,
+                supported_attachment_types=[],
+            ),
+        )
+        self.models[model_id] = model
+
+    def get_model(self, model_id: str) -> Optional[AvailableModel]:
+        return self.models.get(model_id)
+
+    def get_all_models(self) -> List[AvailableModel]:
+        return list(self.models.values())
+
+    def get_enabled_models(self) -> List[AvailableModel]:
+        return [m for m in self.models.values() if m.enabled]
+
+    def model_exists(self, model_id: str) -> bool:
+        return model_id in self.models

application/core/model_utils.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict, Optional
+
+from application.core.model_settings import ModelRegistry
+
+
+def get_api_key_for_provider(provider: str) -> Optional[str]:
+    """Get the appropriate API key for a provider"""
+    from application.core.settings import settings
+
+    provider_key_map = {
+        "openai": settings.OPENAI_API_KEY,
+        "anthropic": settings.ANTHROPIC_API_KEY,
+        "google": settings.GOOGLE_API_KEY,
+        "groq": settings.GROQ_API_KEY,
+        "huggingface": settings.HUGGINGFACE_API_KEY,
+        "azure_openai": settings.API_KEY,
+        "docsgpt": None,
+        "llama.cpp": None,
+    }
+
+    provider_key = provider_key_map.get(provider)
+    if provider_key:
+        return provider_key
+    return settings.API_KEY
+
+
+def get_all_available_models() -> Dict[str, Dict[str, Any]]:
+    """Get all available models with metadata for API response"""
+    registry = ModelRegistry.get_instance()
+    return {model.id: model.to_dict() for model in registry.get_enabled_models()}
+
+
+def validate_model_id(model_id: str) -> bool:
+    """Check if a model ID exists in registry"""
+    registry = ModelRegistry.get_instance()
+    return registry.model_exists(model_id)
+
+
+def get_model_capabilities(model_id: str) -> Optional[Dict[str, Any]]:
+    """Get capabilities for a specific model"""
+    registry = ModelRegistry.get_instance()
+    model = registry.get_model(model_id)
+    if model:
+        return {
+            "supported_attachment_types": model.capabilities.supported_attachment_types,
+            "supports_tools": model.capabilities.supports_tools,
+            "supports_structured_output": model.capabilities.supports_structured_output,
+            "context_window": model.capabilities.context_window,
+        }
+    return None
+
+
+def get_default_model_id() -> str:
+    """Get the system default model ID"""
+    registry = ModelRegistry.get_instance()
+    return registry.default_model_id
+
+
+def get_provider_from_model_id(model_id: str) -> Optional[str]:
+    """Get the provider name for a given model_id"""
+    registry = ModelRegistry.get_instance()
+    model = registry.get_model(model_id)
+    if model:
+        return model.provider.value
+    return None
+
+
+def get_token_limit(model_id: str) -> int:
+    """
+    Get context window (token limit) for a model.
+    Returns model's context_window or default 128000 if model not found.
+    """
+    from application.core.settings import settings
+
+    registry = ModelRegistry.get_instance()
+    model = registry.get_model(model_id)
+    if model:
+        return model.capabilities.context_window
+    return settings.DEFAULT_LLM_TOKEN_LIMIT
+
+
+def get_base_url_for_model(model_id: str) -> Optional[str]:
+    """
+    Get the custom base_url for a specific model if configured.
+    Returns None if no custom base_url is set.
+    """
+    registry = ModelRegistry.get_instance()
+    model = registry.get_model(model_id)
+    if model:
+        return model.base_url
+    return None

application/core/settings.py

@@ -22,11 +22,15 @@ class Settings(BaseSettings):
     MONGO_DB_NAME: str = "docsgpt"
     LLM_PATH: str = os.path.join(current_dir, "models/docsgpt-7b-f16.gguf")
     DEFAULT_MAX_HISTORY: int = 150
-    LLM_TOKEN_LIMITS: dict = {
-        "gpt-4o-mini": 128000,
-        "gpt-3.5-turbo": 4096,
-        "claude-2": 1e5,
-        "gemini-2.5-flash": 1e6,
+    DEFAULT_LLM_TOKEN_LIMIT: int = 128000  # Fallback when model not found in registry
+    RESERVED_TOKENS: dict = {
+        "system_prompt": 500,
+        "current_query": 500,
+        "safety_buffer": 1000,
+    }
+    DEFAULT_AGENT_LIMITS: dict = {
+        "token_limit": 50000,
+        "request_limit": 500,
     }
     UPLOAD_FOLDER: str = "inputs"
     PARSE_PDF_AS_IMAGE: bool = False
@@ -51,12 +55,23 @@ class Settings(BaseSettings):
         "http://127.0.0.1:7091/api/connectors/callback"  ##add redirect url as it is to your provider's console(gcp)
     )
 
+    # GitHub source
+    GITHUB_ACCESS_TOKEN: Optional[str] = None  # PAT token with read repo access
+
     # LLM Cache
     CACHE_REDIS_URL: str = "redis://localhost:6379/2"
 
     API_URL: str = "http://localhost:7091"  # backend url for celery worker
 
-    API_KEY: Optional[str] = None  # LLM api key
+    API_KEY: Optional[str] = None  # LLM api key (used by LLM_PROVIDER)
+
+    # Provider-specific API keys (for multi-model support)
+    OPENAI_API_KEY: Optional[str] = None
+    ANTHROPIC_API_KEY: Optional[str] = None
+    GOOGLE_API_KEY: Optional[str] = None
+    GROQ_API_KEY: Optional[str] = None
+    HUGGINGFACE_API_KEY: Optional[str] = None
+
     EMBEDDINGS_KEY: Optional[str] = (
         None  # api key for embeddings (if using openai, just copy API_KEY)
     )
@@ -123,7 +138,19 @@ class Settings(BaseSettings):
     # Encryption settings
     ENCRYPTION_SECRET_KEY: str = "default-docsgpt-encryption-key"
 
+    TTS_PROVIDER: str = "google_tts"  # google_tts or elevenlabs
     ELEVENLABS_API_KEY: Optional[str] = None
 
+    # Tool pre-fetch settings
+    ENABLE_TOOL_PREFETCH: bool = True
+
+    # Conversation Compression Settings
+    ENABLE_CONVERSATION_COMPRESSION: bool = True
+    COMPRESSION_THRESHOLD_PERCENTAGE: float = 0.8  # Trigger at 80% of context
+    COMPRESSION_MODEL_OVERRIDE: Optional[str] = None  # Use different model for compression
+    COMPRESSION_PROMPT_VERSION: str = "v1.0"  # Track prompt iterations
+    COMPRESSION_MAX_HISTORY_POINTS: int = 3  # Keep only last N compression points to prevent DB bloat
+
+
 path = Path(__file__).parent.parent.absolute()
 settings = Settings(_env_file=path.joinpath(".env"), _env_file_encoding="utf-8")

application/llm/anthropic.py

@@ -1,30 +1,41 @@
-from application.llm.base import BaseLLM
+from anthropic import AI_PROMPT, Anthropic, HUMAN_PROMPT
+
 from application.core.settings import settings
+from application.llm.base import BaseLLM
 
 
 class AnthropicLLM(BaseLLM):
 
-    def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
-        from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
+    def __init__(self, api_key=None, user_api_key=None, base_url=None, *args, **kwargs):
 
         super().__init__(*args, **kwargs)
-        self.api_key = (
-            api_key or settings.ANTHROPIC_API_KEY
-        )  # If not provided, use a default from settings
+        self.api_key = api_key or settings.ANTHROPIC_API_KEY or settings.API_KEY
         self.user_api_key = user_api_key
-        self.anthropic = Anthropic(api_key=self.api_key)
+
+        # Use custom base_url if provided
+        if base_url:
+            self.anthropic = Anthropic(api_key=self.api_key, base_url=base_url)
+        else:
+            self.anthropic = Anthropic(api_key=self.api_key)
+
         self.HUMAN_PROMPT = HUMAN_PROMPT
         self.AI_PROMPT = AI_PROMPT
 
     def _raw_gen(
-        self, baseself, model, messages, stream=False, tools=None, max_tokens=300, **kwargs
+        self,
+        baseself,
+        model,
+        messages,
+        stream=False,
+        tools=None,
+        max_tokens=300,
+        **kwargs,
     ):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
         prompt = f"### Context \n {context} \n ### Question \n {user_question}"
         if stream:
             return self.gen_stream(model, prompt, stream, max_tokens, **kwargs)
-
         completion = self.anthropic.completions.create(
             model=model,
             max_tokens_to_sample=max_tokens,
@@ -34,7 +45,14 @@ class AnthropicLLM(BaseLLM):
         return completion.completion
 
     def _raw_gen_stream(
-        self, baseself, model, messages, stream=True, tools=None, max_tokens=300, **kwargs
+        self,
+        baseself,
+        model,
+        messages,
+        stream=True,
+        tools=None,
+        max_tokens=300,
+        **kwargs,
     ):
         context = messages[0]["content"]
         user_question = messages[-1]["content"]
@@ -46,5 +64,9 @@ class AnthropicLLM(BaseLLM):
             stream=True,
         )
 
-        for completion in stream_response:
-            yield completion.completion
+        try:
+            for completion in stream_response:
+                yield completion.completion
+        finally:
+            if hasattr(stream_response, "close"):
+                stream_response.close()

application/llm/base.py

@@ -13,30 +13,32 @@ class BaseLLM(ABC):
     def __init__(
         self,
         decoded_token=None,
+        model_id=None,
+        base_url=None,
     ):
         self.decoded_token = decoded_token
+        self.model_id = model_id
+        self.base_url = base_url
         self.token_usage = {"prompt_tokens": 0, "generated_tokens": 0}
-        self.fallback_provider = settings.FALLBACK_LLM_PROVIDER
-        self.fallback_model_name = settings.FALLBACK_LLM_NAME
-        self.fallback_llm_api_key = settings.FALLBACK_LLM_API_KEY
         self._fallback_llm = None
+        self._fallback_sequence_index = 0
 
     @property
     def fallback_llm(self):
-        """Lazy-loaded fallback LLM instance."""
-        if (
-            self._fallback_llm is None
-            and self.fallback_provider
-            and self.fallback_model_name
-        ):
+        """Lazy-loaded fallback LLM from FALLBACK_* settings."""
+        if self._fallback_llm is None and settings.FALLBACK_LLM_PROVIDER:
             try:
                 from application.llm.llm_creator import LLMCreator
 
                 self._fallback_llm = LLMCreator.create_llm(
-                    self.fallback_provider,
-                    self.fallback_llm_api_key,
-                    None,
-                    self.decoded_token,
+                    settings.FALLBACK_LLM_PROVIDER,
+                    api_key=settings.FALLBACK_LLM_API_KEY or settings.API_KEY,
+                    user_api_key=None,
+                    decoded_token=self.decoded_token,
+                    model_id=settings.FALLBACK_LLM_NAME,
+                )
+                logger.info(
+                    f"Fallback LLM initialized: {settings.FALLBACK_LLM_PROVIDER}/{settings.FALLBACK_LLM_NAME}"
                 )
             except Exception as e:
                 logger.error(
@@ -44,11 +46,17 @@ class BaseLLM(ABC):
                 )
         return self._fallback_llm
 
+    @staticmethod
+    def _remove_null_values(args_dict):
+        if not isinstance(args_dict, dict):
+            return args_dict
+        return {k: v for k, v in args_dict.items() if v is not None}
+
     def _execute_with_fallback(
         self, method_name: str, decorators: list, *args, **kwargs
     ):
         """
-        Unified method execution with fallback support.
+        Execute method with fallback support.
 
         Args:
             method_name: Name of the raw method ('_raw_gen' or '_raw_gen_stream')
@@ -67,10 +75,10 @@ class BaseLLM(ABC):
             return decorated_method()
         except Exception as e:
             if not self.fallback_llm:
-                logger.error(f"Primary LLM failed and no fallback available: {str(e)}")
+                logger.error(f"Primary LLM failed and no fallback configured: {str(e)}")
                 raise
             logger.warning(
-                f"Falling back to {self.fallback_provider}/{self.fallback_model_name}. Error: {str(e)}"
+                f"Primary LLM failed. Falling back to {settings.FALLBACK_LLM_PROVIDER}/{settings.FALLBACK_LLM_NAME}. Error: {str(e)}"
             )
 
             fallback_method = getattr(

application/llm/docsgpt_provider.py

@@ -1,5 +1,7 @@
 import json
 
+from openai import OpenAI
+
 from application.core.settings import settings
 from application.llm.base import BaseLLM
 
@@ -7,12 +9,11 @@ from application.llm.base import BaseLLM
 class DocsGPTAPILLM(BaseLLM):
 
     def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
-        from openai import OpenAI
 
         super().__init__(*args, **kwargs)
-        self.client = OpenAI(api_key="sk-docsgpt-public", base_url="https://oai.arc53.com")
+        self.api_key = "sk-docsgpt-public"
+        self.client = OpenAI(api_key=self.api_key, base_url="https://oai.arc53.com")
         self.user_api_key = user_api_key
-        self.api_key = api_key
 
     def _clean_messages_openai(self, messages):
         cleaned_messages = []
@@ -22,7 +23,6 @@ class DocsGPTAPILLM(BaseLLM):
 
             if role == "model":
                 role = "assistant"
-
             if role and content is not None:
                 if isinstance(content, str):
                     cleaned_messages.append({"role": role, "content": content})
@@ -33,14 +33,15 @@ class DocsGPTAPILLM(BaseLLM):
                                 {"role": role, "content": item["text"]}
                             )
                         elif "function_call" in item:
+                            cleaned_args = self._remove_null_values(
+                                item["function_call"]["args"]
+                            )
                             tool_call = {
                                 "id": item["function_call"]["call_id"],
                                 "type": "function",
                                 "function": {
                                     "name": item["function_call"]["name"],
-                                    "arguments": json.dumps(
-                                        item["function_call"]["args"]
-                                    ),
+                                    "arguments": json.dumps(cleaned_args),
                                 },
                             }
                             cleaned_messages.append(
@@ -68,7 +69,6 @@ class DocsGPTAPILLM(BaseLLM):
                             )
                 else:
                     raise ValueError(f"Unexpected content type: {type(content)}")
-
         return cleaned_messages
 
     def _raw_gen(
@@ -120,12 +120,19 @@ class DocsGPTAPILLM(BaseLLM):
             response = self.client.chat.completions.create(
                 model="docsgpt", messages=messages, stream=stream, **kwargs
             )
-
-        for line in response:
-            if len(line.choices) > 0 and line.choices[0].delta.content is not None and len(line.choices[0].delta.content) > 0:
-                yield line.choices[0].delta.content
-            elif len(line.choices) > 0:
-                yield line.choices[0]
+        try:
+            for line in response:
+                if (
+                    len(line.choices) > 0
+                    and line.choices[0].delta.content is not None
+                    and len(line.choices[0].delta.content) > 0
+                ):
+                    yield line.choices[0].delta.content
+                elif len(line.choices) > 0:
+                    yield line.choices[0]
+        finally:
+            if hasattr(response, "close"):
+                response.close()
 
     def _supports_tools(self):
-        return True
+        return True

application/llm/google_ai.py

@@ -1,4 +1,3 @@
-import json
 import logging
 
 from google import genai
@@ -11,10 +10,13 @@ from application.storage.storage_creator import StorageCreator
 
 
 class GoogleLLM(BaseLLM):
-    def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
+    def __init__(
+        self, api_key=None, user_api_key=None, decoded_token=None, *args, **kwargs
+    ):
         super().__init__(*args, **kwargs)
-        self.api_key = api_key
+        self.api_key = api_key or settings.GOOGLE_API_KEY or settings.API_KEY
         self.user_api_key = user_api_key
+
         self.client = genai.Client(api_key=self.api_key)
         self.storage = StorageCreator.get_storage()
 
@@ -32,6 +34,12 @@ class GoogleLLM(BaseLLM):
             "image/jpg",
             "image/webp",
             "image/gif",
+            "application/pdf",
+            "image/png",
+            "image/jpeg",
+            "image/jpg",
+            "image/webp",
+            "image/gif",
         ]
 
     def prepare_messages_with_attachments(self, messages, attachments=None):
@@ -47,21 +55,19 @@ class GoogleLLM(BaseLLM):
         """
         if not attachments:
             return messages
-
         prepared_messages = messages.copy()
 
         # Find the user message to attach files to the last one
+
         user_message_index = None
         for i in range(len(prepared_messages) - 1, -1, -1):
             if prepared_messages[i].get("role") == "user":
                 user_message_index = i
                 break
-
         if user_message_index is None:
             user_message = {"role": "user", "content": []}
             prepared_messages.append(user_message)
             user_message_index = len(prepared_messages) - 1
-
         if isinstance(prepared_messages[user_message_index].get("content"), str):
             text_content = prepared_messages[user_message_index]["content"]
             prepared_messages[user_message_index]["content"] = [
@@ -69,7 +75,6 @@ class GoogleLLM(BaseLLM):
             ]
         elif not isinstance(prepared_messages[user_message_index].get("content"), list):
             prepared_messages[user_message_index]["content"] = []
-
         files = []
         for attachment in attachments:
             mime_type = attachment.get("mime_type")
@@ -92,11 +97,9 @@ class GoogleLLM(BaseLLM):
                                 "text": f"[File could not be processed: {attachment.get('path', 'unknown')}]",
                             }
                         )
-
         if files:
             logging.info(f"GoogleLLM: Adding {len(files)} files to message")
             prepared_messages[user_message_index]["content"].append({"files": files})
-
         return prepared_messages
 
     def _upload_file_to_google(self, attachment):
@@ -111,14 +114,11 @@ class GoogleLLM(BaseLLM):
         """
         if "google_file_uri" in attachment:
             return attachment["google_file_uri"]
-
         file_path = attachment.get("path")
         if not file_path:
             raise ValueError("No file path provided in attachment")
-
         if not self.storage.file_exists(file_path):
             raise FileNotFoundError(f"File not found: {file_path}")
-
         try:
             file_uri = self.storage.process_file(
                 file_path,
@@ -136,24 +136,48 @@ class GoogleLLM(BaseLLM):
                 attachments_collection.update_one(
                     {"_id": attachment["_id"]}, {"$set": {"google_file_uri": file_uri}}
                 )
-
             return file_uri
         except Exception as e:
             logging.error(f"Error uploading file to Google AI: {e}", exc_info=True)
             raise
 
     def _clean_messages_google(self, messages):
-        """Convert OpenAI format messages to Google AI format."""
+        """
+        Convert OpenAI format messages to Google AI format and collect system prompts.
+
+        Returns:
+            tuple[list[types.Content], Optional[str]]: cleaned messages and optional
+            combined system instruction.
+        """
         cleaned_messages = []
+        system_instructions = []
+
+        def _extract_system_text(content):
+            if isinstance(content, str):
+                return content
+            if isinstance(content, list):
+                parts = []
+                for item in content:
+                    if isinstance(item, dict) and "text" in item and item["text"] is not None:
+                        parts.append(item["text"])
+                return "\n".join(parts)
+            return ""
+
         for message in messages:
             role = message.get("role")
             content = message.get("content")
 
+            # Gemini only accepts user/model in the contents list.
+            if role == "system":
+                sys_text = _extract_system_text(content)
+                if sys_text:
+                    system_instructions.append(sys_text)
+                continue
+
             if role == "assistant":
                 role = "model"
             elif role == "tool":
                 role = "model"
-
             parts = []
             if role and content is not None:
                 if isinstance(content, str):
@@ -163,12 +187,32 @@ class GoogleLLM(BaseLLM):
                         if "text" in item:
                             parts.append(types.Part.from_text(text=item["text"]))
                         elif "function_call" in item:
-                            parts.append(
-                                types.Part.from_function_call(
-                                    name=item["function_call"]["name"],
-                                    args=item["function_call"]["args"],
-                                )
+                            # Remove null values from args to avoid API errors
+
+                            cleaned_args = self._remove_null_values(
+                                item["function_call"]["args"]
                             )
+                            # Create function call part with thought_signature if present
+                            # For Gemini 3 models, we need to include thought_signature
+                            if "thought_signature" in item:
+                                # Use Part constructor with functionCall and thoughtSignature
+                                parts.append(
+                                    types.Part(
+                                        functionCall=types.FunctionCall(
+                                            name=item["function_call"]["name"],
+                                            args=cleaned_args,
+                                        ),
+                                        thoughtSignature=item["thought_signature"],
+                                    )
+                                )
+                            else:
+                                # Use helper method when no thought_signature
+                                parts.append(
+                                    types.Part.from_function_call(
+                                        name=item["function_call"]["name"],
+                                        args=cleaned_args,
+                                    )
+                                )
                         elif "function_response" in item:
                             parts.append(
                                 types.Part.from_function_response(
@@ -190,11 +234,10 @@ class GoogleLLM(BaseLLM):
                             )
                 else:
                     raise ValueError(f"Unexpected content type: {type(content)}")
-
                 if parts:
                     cleaned_messages.append(types.Content(role=role, parts=parts))
-
-        return cleaned_messages
+        system_instruction = "\n\n".join(system_instructions) if system_instructions else None
+        return cleaned_messages, system_instruction
 
     def _clean_schema(self, schema_obj):
         """
@@ -229,8 +272,8 @@ class GoogleLLM(BaseLLM):
                 cleaned[key] = [self._clean_schema(item) for item in value]
             else:
                 cleaned[key] = value
-
         # Validate that required properties actually exist in properties
+
         if "required" in cleaned and "properties" in cleaned:
             valid_required = []
             properties_keys = set(cleaned["properties"].keys())
@@ -243,7 +286,6 @@ class GoogleLLM(BaseLLM):
                 cleaned.pop("required", None)
         elif "required" in cleaned and "properties" not in cleaned:
             cleaned.pop("required", None)
-
         return cleaned
 
     def _clean_tools_format(self, tools_list):
@@ -259,7 +301,6 @@ class GoogleLLM(BaseLLM):
                     cleaned_properties = {}
                     for k, v in properties.items():
                         cleaned_properties[k] = self._clean_schema(v)
-
                     genai_function = dict(
                         name=function["name"],
                         description=function["description"],
@@ -278,12 +319,65 @@ class GoogleLLM(BaseLLM):
                         name=function["name"],
                         description=function["description"],
                     )
-
                 genai_tool = types.Tool(function_declarations=[genai_function])
                 genai_tools.append(genai_tool)
-
         return genai_tools
 
+    def _extract_preview_from_message(self, message):
+        """Get a short, human-readable preview from the last message."""
+        try:
+            if hasattr(message, "parts"):
+                for part in reversed(message.parts):
+                    if getattr(part, "text", None):
+                        return part.text
+                    function_call = getattr(part, "function_call", None)
+                    if function_call:
+                        name = getattr(function_call, "name", "") or "function_call"
+                        return f"function_call:{name}"
+                    function_response = getattr(part, "function_response", None)
+                    if function_response:
+                        name = getattr(function_response, "name", "") or "function_response"
+                        return f"function_response:{name}"
+            if isinstance(message, dict):
+                content = message.get("content")
+                if isinstance(content, str):
+                    return content
+                if isinstance(content, list):
+                    for item in reversed(content):
+                        if isinstance(item, str):
+                            return item
+                        if isinstance(item, dict):
+                            if item.get("text"):
+                                return item["text"]
+                            if item.get("function_call"):
+                                fn = item["function_call"]
+                                if isinstance(fn, dict):
+                                    name = fn.get("name") or "function_call"
+                                    return f"function_call:{name}"
+                                return "function_call"
+                            if item.get("function_response"):
+                                resp = item["function_response"]
+                                if isinstance(resp, dict):
+                                    name = resp.get("name") or "function_response"
+                                    return f"function_response:{name}"
+                                return "function_response"
+                if "text" in message and isinstance(message["text"], str):
+                    return message["text"]
+        except Exception:
+            pass
+        return str(message)
+
+    def _summarize_messages_for_log(self, messages, preview_chars=20):
+        """Return a compact summary for logging to avoid huge payloads."""
+        message_count = len(messages) if messages else 0
+        last_preview = ""
+        if messages:
+            last_preview = self._extract_preview_from_message(messages[-1]) or ""
+        last_preview = str(last_preview).replace("\n", " ")
+        if len(last_preview) > preview_chars:
+            last_preview = f"{last_preview[:preview_chars]}..."
+        return f"count={message_count}, last='{last_preview}'"
+
     def _raw_gen(
         self,
         baseself,
@@ -297,22 +391,20 @@ class GoogleLLM(BaseLLM):
     ):
         """Generate content using Google AI API without streaming."""
         client = genai.Client(api_key=self.api_key)
+        system_instruction = None
         if formatting == "openai":
-            messages = self._clean_messages_google(messages)
+            messages, system_instruction = self._clean_messages_google(messages)
         config = types.GenerateContentConfig()
-        if messages[0].role == "system":
-            config.system_instruction = messages[0].parts[0].text
-            messages = messages[1:]
-
+        if system_instruction:
+            config.system_instruction = system_instruction
         if tools:
             cleaned_tools = self._clean_tools_format(tools)
             config.tools = cleaned_tools
-
         # Add response schema for structured output if provided
+
         if response_schema:
             config.response_schema = response_schema
             config.response_mime_type = "application/json"
-
         response = client.models.generate_content(
             model=model,
             contents=messages,
@@ -337,23 +429,22 @@ class GoogleLLM(BaseLLM):
     ):
         """Generate content using Google AI API with streaming."""
         client = genai.Client(api_key=self.api_key)
+        system_instruction = None
         if formatting == "openai":
-            messages = self._clean_messages_google(messages)
+            messages, system_instruction = self._clean_messages_google(messages)
         config = types.GenerateContentConfig()
-        if messages[0].role == "system":
-            config.system_instruction = messages[0].parts[0].text
-            messages = messages[1:]
-
+        if system_instruction:
+            config.system_instruction = system_instruction
         if tools:
             cleaned_tools = self._clean_tools_format(tools)
             config.tools = cleaned_tools
-
         # Add response schema for structured output if provided
+
         if response_schema:
             config.response_schema = response_schema
             config.response_mime_type = "application/json"
-
         # Check if we have both tools and file attachments
+
         has_attachments = False
         for message in messages:
             for part in message.parts:
@@ -362,9 +453,12 @@ class GoogleLLM(BaseLLM):
                     break
             if has_attachments:
                 break
-
+        messages_summary = self._summarize_messages_for_log(messages)
         logging.info(
-            f"GoogleLLM: Starting stream generation. Model: {model}, Messages: {json.dumps(messages, default=str)}, Has attachments: {has_attachments}"
+            "GoogleLLM: Starting stream generation. Model: %s, Messages: %s, Has attachments: %s",
+            model,
+            messages_summary,
+            has_attachments,
         )
 
         response = client.models.generate_content_stream(
@@ -373,17 +467,21 @@ class GoogleLLM(BaseLLM):
             config=config,
         )
 
-        for chunk in response:
-            if hasattr(chunk, "candidates") and chunk.candidates:
-                for candidate in chunk.candidates:
-                    if candidate.content and candidate.content.parts:
-                        for part in candidate.content.parts:
-                            if part.function_call:
-                                yield part
-                            elif part.text:
-                                yield part.text
-            elif hasattr(chunk, "text"):
-                yield chunk.text
+        try:
+            for chunk in response:
+                if hasattr(chunk, "candidates") and chunk.candidates:
+                    for candidate in chunk.candidates:
+                        if candidate.content and candidate.content.parts:
+                            for part in candidate.content.parts:
+                                if part.function_call:
+                                    yield part
+                                elif part.text:
+                                    yield part.text
+                elif hasattr(chunk, "text"):
+                    yield chunk.text
+        finally:
+            if hasattr(response, "close"):
+                response.close()
 
     def _supports_tools(self):
         """Return whether this LLM supports function calling."""
@@ -397,7 +495,6 @@ class GoogleLLM(BaseLLM):
         """Convert JSON schema to Google AI structured output format."""
         if not json_schema:
             return None
-
         type_map = {
             "object": "OBJECT",
             "array": "ARRAY",
@@ -410,12 +507,10 @@ class GoogleLLM(BaseLLM):
         def convert(schema):
             if not isinstance(schema, dict):
                 return schema
-
             result = {}
             schema_type = schema.get("type")
             if schema_type:
                 result["type"] = type_map.get(schema_type.lower(), schema_type.upper())
-
             for key in [
                 "description",
                 "nullable",
@@ -427,7 +522,6 @@ class GoogleLLM(BaseLLM):
             ]:
                 if key in schema:
                     result[key] = schema[key]
-
             if "format" in schema:
                 format_value = schema["format"]
                 if schema_type == "string":
@@ -437,21 +531,17 @@ class GoogleLLM(BaseLLM):
                         result["format"] = format_value
                 else:
                     result["format"] = format_value
-
             if "properties" in schema:
                 result["properties"] = {
                     k: convert(v) for k, v in schema["properties"].items()
                 }
                 if "propertyOrdering" not in result and result.get("type") == "OBJECT":
                     result["propertyOrdering"] = list(result["properties"].keys())
-
             if "items" in schema:
                 result["items"] = convert(schema["items"])
-
             for field in ["anyOf", "oneOf", "allOf"]:
                 if field in schema:
                     result[field] = [convert(s) for s in schema[field]]
-
             return result
 
         try:

application/llm/groq.py

@@ -1,13 +1,18 @@
-from application.llm.base import BaseLLM
 from openai import OpenAI
 
+from application.core.settings import settings
+from application.llm.base import BaseLLM
+
 
 class GroqLLM(BaseLLM):
     def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
+
         super().__init__(*args, **kwargs)
-        self.client = OpenAI(api_key=api_key, base_url="https://api.groq.com/openai/v1")
-        self.api_key = api_key
+        self.api_key = api_key or settings.GROQ_API_KEY or settings.API_KEY
         self.user_api_key = user_api_key
+        self.client = OpenAI(
+            api_key=self.api_key, base_url="https://api.groq.com/openai/v1"
+        )
 
     def _raw_gen(self, baseself, model, messages, stream=False, tools=None, **kwargs):
         if tools:

application/llm/handlers/base.py

@@ -1,4 +1,5 @@
 import logging
+import uuid
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, Generator, List, Optional, Union
@@ -16,6 +17,7 @@ class ToolCall:
     name: str
     arguments: Union[str, Dict]
     index: Optional[int] = None
+    thought_signature: Optional[str] = None
 
     @classmethod
     def from_dict(cls, data: Dict) -> "ToolCall":
@@ -178,6 +180,406 @@ class LLMHandler(ABC):
             system_msg["content"] += f"\n\n{combined_text}"
         return prepared_messages
 
+    def _prune_messages_minimal(self, messages: List[Dict]) -> Optional[List[Dict]]:
+        """
+        Build a minimal context: system prompt + latest user message only.
+        Drops all tool/function messages to shrink context aggressively.
+        """
+        system_message = next((m for m in messages if m.get("role") == "system"), None)
+        if not system_message:
+            logger.warning("Cannot prune messages minimally: missing system message.")
+            return None
+        last_non_system = None
+        for m in reversed(messages):
+            if m.get("role") == "user":
+                last_non_system = m
+                break
+            if not last_non_system and m.get("role") not in ("system", None):
+                last_non_system = m
+        if not last_non_system:
+            logger.warning("Cannot prune messages minimally: missing user/assistant messages.")
+            return None
+        logger.info("Pruning context to system + latest user/assistant message to proceed.")
+        return [system_message, last_non_system]
+
+    def _extract_text_from_content(self, content: Any) -> str:
+        """
+        Convert message content (str or list of parts) to plain text for compression.
+        """
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts_text = []
+            for item in content:
+                if isinstance(item, dict):
+                    if "text" in item and item["text"] is not None:
+                        parts_text.append(str(item["text"]))
+                    elif "function_call" in item or "function_response" in item:
+                        # Keep serialized function calls/responses so the compressor sees actions
+                        parts_text.append(str(item))
+                    elif "files" in item:
+                        parts_text.append(str(item))
+            return "\n".join(parts_text)
+        return ""
+
+    def _build_conversation_from_messages(self, messages: List[Dict]) -> Optional[Dict]:
+        """
+        Build a conversation-like dict from current messages so we can compress
+        even when the conversation isn't persisted yet. Includes tool calls/results.
+        """
+        queries = []
+        current_prompt = None
+        current_tool_calls = {}
+
+        def _commit_query(response_text: str):
+            nonlocal current_prompt, current_tool_calls
+            if current_prompt is None and not response_text:
+                return
+            tool_calls_list = list(current_tool_calls.values())
+            queries.append(
+                {
+                    "prompt": current_prompt or "",
+                    "response": response_text,
+                    "tool_calls": tool_calls_list,
+                }
+            )
+            current_prompt = None
+            current_tool_calls = {}
+
+        for message in messages:
+            role = message.get("role")
+            content = message.get("content")
+
+            if role == "user":
+                current_prompt = self._extract_text_from_content(content)
+
+            elif role in {"assistant", "model"}:
+                # If this assistant turn contains tool calls, collect them; otherwise commit a response.
+                if isinstance(content, list):
+                    for item in content:
+                        if "function_call" in item:
+                            fc = item["function_call"]
+                            call_id = fc.get("call_id") or str(uuid.uuid4())
+                            current_tool_calls[call_id] = {
+                                "tool_name": "unknown_tool",
+                                "action_name": fc.get("name"),
+                                "arguments": fc.get("args"),
+                                "result": None,
+                                "status": "called",
+                                "call_id": call_id,
+                            }
+                        elif "function_response" in item:
+                            fr = item["function_response"]
+                            call_id = fr.get("call_id") or str(uuid.uuid4())
+                            current_tool_calls[call_id] = {
+                                "tool_name": "unknown_tool",
+                                "action_name": fr.get("name"),
+                                "arguments": None,
+                                "result": fr.get("response", {}).get("result"),
+                                "status": "completed",
+                                "call_id": call_id,
+                            }
+                    # No direct assistant text here; continue to next message
+                    continue
+
+                response_text = self._extract_text_from_content(content)
+                _commit_query(response_text)
+
+            elif role == "tool":
+                # Attach tool outputs to the latest pending tool call if possible
+                tool_text = self._extract_text_from_content(content)
+                # Attempt to parse function_response style
+                call_id = None
+                if isinstance(content, list):
+                    for item in content:
+                        if "function_response" in item and item["function_response"].get("call_id"):
+                            call_id = item["function_response"]["call_id"]
+                            break
+                if call_id and call_id in current_tool_calls:
+                    current_tool_calls[call_id]["result"] = tool_text
+                    current_tool_calls[call_id]["status"] = "completed"
+                elif queries:
+                    queries[-1].setdefault("tool_calls", []).append(
+                        {
+                            "tool_name": "unknown_tool",
+                            "action_name": "unknown_action",
+                            "arguments": {},
+                            "result": tool_text,
+                            "status": "completed",
+                        }
+                    )
+
+        # If there's an unfinished prompt with tool_calls but no response yet, commit it
+        if current_prompt is not None or current_tool_calls:
+            _commit_query(response_text="")
+
+        if not queries:
+            return None
+
+        return {
+            "queries": queries,
+            "compression_metadata": {
+                "is_compressed": False,
+                "compression_points": [],
+            },
+        }
+
+    def _rebuild_messages_after_compression(
+        self,
+        messages: List[Dict],
+        compressed_summary: Optional[str],
+        recent_queries: List[Dict],
+        include_current_execution: bool = False,
+        include_tool_calls: bool = False,
+    ) -> Optional[List[Dict]]:
+        """
+        Rebuild the message list after compression so tool execution can continue.
+
+        Delegates to MessageBuilder for the actual reconstruction.
+        """
+        from application.api.answer.services.compression.message_builder import (
+            MessageBuilder,
+        )
+
+        return MessageBuilder.rebuild_messages_after_compression(
+            messages=messages,
+            compressed_summary=compressed_summary,
+            recent_queries=recent_queries,
+            include_current_execution=include_current_execution,
+            include_tool_calls=include_tool_calls,
+        )
+
+    def _perform_mid_execution_compression(
+        self, agent, messages: List[Dict]
+    ) -> tuple[bool, Optional[List[Dict]]]:
+        """
+        Perform compression during tool execution and rebuild messages.
+
+        Uses the new orchestrator for simplified compression.
+
+        Args:
+            agent: The agent instance
+            messages: Current conversation messages
+
+        Returns:
+            (success: bool, rebuilt_messages: Optional[List[Dict]])
+        """
+        try:
+            from application.api.answer.services.compression import (
+                CompressionOrchestrator,
+            )
+            from application.api.answer.services.conversation_service import (
+                ConversationService,
+            )
+
+            conversation_service = ConversationService()
+            orchestrator = CompressionOrchestrator(conversation_service)
+
+            # Get conversation from database (may be None for new sessions)
+            conversation = conversation_service.get_conversation(
+                agent.conversation_id, agent.initial_user_id
+            )
+
+            if conversation:
+                # Merge current in-flight messages (including tool calls)
+                conversation_from_msgs = self._build_conversation_from_messages(messages)
+                if conversation_from_msgs:
+                    conversation = conversation_from_msgs
+            else:
+                logger.warning(
+                    "Could not load conversation for compression; attempting in-memory compression"
+                )
+                return self._perform_in_memory_compression(agent, messages)
+
+            # Use orchestrator to perform compression
+            result = orchestrator.compress_mid_execution(
+                conversation_id=agent.conversation_id,
+                user_id=agent.initial_user_id,
+                model_id=agent.model_id,
+                decoded_token=getattr(agent, "decoded_token", {}),
+                current_conversation=conversation,
+            )
+
+            if not result.success:
+                logger.warning(f"Mid-execution compression failed: {result.error}")
+                # Try minimal pruning as fallback
+                pruned = self._prune_messages_minimal(messages)
+                if pruned:
+                    agent.context_limit_reached = False
+                    agent.current_token_count = 0
+                    return True, pruned
+                return False, None
+
+            if not result.compression_performed:
+                logger.warning("Compression not performed")
+                return False, None
+
+            # Check if compression actually reduced tokens
+            if result.metadata:
+                if result.metadata.compressed_token_count >= result.metadata.original_token_count:
+                    logger.warning(
+                        "Compression did not reduce token count; falling back to minimal pruning"
+                    )
+                    pruned = self._prune_messages_minimal(messages)
+                    if pruned:
+                        agent.context_limit_reached = False
+                        agent.current_token_count = 0
+                        return True, pruned
+                    return False, None
+
+                logger.info(
+                    f"Mid-execution compression successful - ratio: {result.metadata.compression_ratio:.1f}x, "
+                    f"saved {result.metadata.original_token_count - result.metadata.compressed_token_count} tokens"
+                )
+
+            # Also store the compression summary as a visible message
+            if result.metadata:
+                conversation_service.append_compression_message(
+                    agent.conversation_id, result.metadata.to_dict()
+                )
+
+            # Update agent's compressed summary for downstream persistence
+            agent.compressed_summary = result.compressed_summary
+            agent.compression_metadata = result.metadata.to_dict() if result.metadata else None
+            agent.compression_saved = False
+
+            # Reset the context limit flag so tools can continue
+            agent.context_limit_reached = False
+            agent.current_token_count = 0
+
+            # Rebuild messages
+            rebuilt_messages = self._rebuild_messages_after_compression(
+                messages,
+                result.compressed_summary,
+                result.recent_queries,
+                include_current_execution=False,
+                include_tool_calls=False,
+            )
+
+            if rebuilt_messages is None:
+                return False, None
+
+            return True, rebuilt_messages
+
+        except Exception as e:
+            logger.error(
+                f"Error performing mid-execution compression: {str(e)}", exc_info=True
+            )
+            return False, None
+
+    def _perform_in_memory_compression(
+        self, agent, messages: List[Dict]
+    ) -> tuple[bool, Optional[List[Dict]]]:
+        """
+        Fallback compression path when the conversation is not yet persisted.
+
+        Uses CompressionService directly without DB persistence.
+        """
+        try:
+            from application.api.answer.services.compression.service import (
+                CompressionService,
+            )
+            from application.core.model_utils import (
+                get_api_key_for_provider,
+                get_provider_from_model_id,
+            )
+            from application.core.settings import settings
+            from application.llm.llm_creator import LLMCreator
+
+            conversation = self._build_conversation_from_messages(messages)
+            if not conversation:
+                logger.warning(
+                    "Cannot perform in-memory compression: no user/assistant turns found"
+                )
+                return False, None
+
+            compression_model = (
+                settings.COMPRESSION_MODEL_OVERRIDE
+                if settings.COMPRESSION_MODEL_OVERRIDE
+                else agent.model_id
+            )
+            provider = get_provider_from_model_id(compression_model)
+            api_key = get_api_key_for_provider(provider)
+            compression_llm = LLMCreator.create_llm(
+                provider,
+                api_key,
+                getattr(agent, "user_api_key", None),
+                getattr(agent, "decoded_token", None),
+                model_id=compression_model,
+            )
+
+            # Create service without DB persistence capability
+            compression_service = CompressionService(
+                llm=compression_llm,
+                model_id=compression_model,
+                conversation_service=None,  # No DB updates for in-memory
+            )
+
+            queries_count = len(conversation.get("queries", []))
+            compress_up_to = queries_count - 1
+
+            if compress_up_to < 0 or queries_count == 0:
+                logger.warning("Not enough queries to compress in-memory context")
+                return False, None
+
+            metadata = compression_service.compress_conversation(
+                conversation,
+                compress_up_to_index=compress_up_to,
+            )
+
+            # If compression doesn't reduce tokens, fall back to minimal pruning
+            if (
+                metadata.compressed_token_count
+                >= metadata.original_token_count
+            ):
+                logger.warning(
+                    "In-memory compression did not reduce token count; falling back to minimal pruning"
+                )
+                pruned = self._prune_messages_minimal(messages)
+                if pruned:
+                    agent.context_limit_reached = False
+                    agent.current_token_count = 0
+                    return True, pruned
+                return False, None
+
+            # Attach metadata to synthetic conversation
+            conversation["compression_metadata"] = {
+                "is_compressed": True,
+                "compression_points": [metadata.to_dict()],
+            }
+
+            compressed_summary, recent_queries = (
+                compression_service.get_compressed_context(conversation)
+            )
+
+            agent.compressed_summary = compressed_summary
+            agent.compression_metadata = metadata.to_dict()
+            agent.compression_saved = False
+            agent.context_limit_reached = False
+            agent.current_token_count = 0
+
+            rebuilt_messages = self._rebuild_messages_after_compression(
+                messages,
+                compressed_summary,
+                recent_queries,
+                include_current_execution=False,
+                include_tool_calls=False,
+            )
+            if rebuilt_messages is None:
+                return False, None
+
+            logger.info(
+                f"In-memory compression successful - ratio: {metadata.compression_ratio:.1f}x, "
+                f"saved {metadata.original_token_count - metadata.compressed_token_count} tokens"
+            )
+            return True, rebuilt_messages
+
+        except Exception as e:
+            logger.error(
+                f"Error performing in-memory compression: {str(e)}", exc_info=True
+            )
+            return False, None
+
     def handle_tool_calls(
         self, agent, tool_calls: List[ToolCall], tools_dict: Dict, messages: List[Dict]
     ) -> Generator:
@@ -195,7 +597,110 @@ class LLMHandler(ABC):
         """
         updated_messages = messages.copy()
 
-        for call in tool_calls:
+        for i, call in enumerate(tool_calls):
+            # Check context limit before executing tool call
+            if hasattr(agent, '_check_context_limit') and agent._check_context_limit(updated_messages):
+                # Context limit reached - attempt mid-execution compression
+                compression_attempted = False
+                compression_successful = False
+
+                try:
+                    from application.core.settings import settings
+                    compression_enabled = settings.ENABLE_CONVERSATION_COMPRESSION
+                except Exception:
+                    compression_enabled = False
+
+                if compression_enabled:
+                    compression_attempted = True
+                    try:
+                        logger.info(
+                            f"Context limit reached with {len(tool_calls) - i} remaining tool calls. "
+                            f"Attempting mid-execution compression..."
+                        )
+
+                        # Trigger mid-execution compression (DB-backed if available, otherwise in-memory)
+                        compression_successful, rebuilt_messages = self._perform_mid_execution_compression(
+                            agent, updated_messages
+                        )
+
+                        if compression_successful and rebuilt_messages is not None:
+                            # Update the messages list with rebuilt compressed version
+                            updated_messages = rebuilt_messages
+
+                            # Yield compression success message
+                            yield {
+                                "type": "info",
+                                "data": {
+                                    "message": "Context window limit reached. Compressed conversation history to continue processing."
+                                }
+                            }
+
+                            logger.info(
+                                f"Mid-execution compression successful. Continuing with {len(tool_calls) - i} remaining tool calls."
+                            )
+                            # Proceed to execute the current tool call with the reduced context
+                        else:
+                            logger.warning("Mid-execution compression attempted but failed. Skipping remaining tools.")
+                    except Exception as e:
+                        logger.error(f"Error during mid-execution compression: {str(e)}", exc_info=True)
+                        compression_attempted = True
+                        compression_successful = False
+
+                # If compression wasn't attempted or failed, skip remaining tools
+                if not compression_successful:
+                    if i == 0:
+                        # Special case: limit reached before executing any tools
+                        # This can happen when previous tool responses pushed context over limit
+                        if compression_attempted:
+                            logger.warning(
+                                f"Context limit reached before executing any tools. "
+                                f"Compression attempted but failed. "
+                                f"Skipping all {len(tool_calls)} pending tool call(s). "
+                                f"This typically occurs when previous tool responses contained large amounts of data."
+                            )
+                        else:
+                            logger.warning(
+                                f"Context limit reached before executing any tools. "
+                                f"Skipping all {len(tool_calls)} pending tool call(s). "
+                                f"This typically occurs when previous tool responses contained large amounts of data. "
+                                f"Consider enabling compression or using a model with larger context window."
+                            )
+                    else:
+                        # Normal case: executed some tools, now stopping
+                        tool_word = "tool call" if i == 1 else "tool calls"
+                        remaining = len(tool_calls) - i
+                        remaining_word = "tool call" if remaining == 1 else "tool calls"
+                        if compression_attempted:
+                            logger.warning(
+                                f"Context limit reached after executing {i} {tool_word}. "
+                                f"Compression attempted but failed. "
+                                f"Skipping remaining {remaining} {remaining_word}."
+                            )
+                        else:
+                            logger.warning(
+                                f"Context limit reached after executing {i} {tool_word}. "
+                                f"Skipping remaining {remaining} {remaining_word}. "
+                                f"Consider enabling compression or using a model with larger context window."
+                            )
+
+                    # Mark remaining tools as skipped
+                    for remaining_call in tool_calls[i:]:
+                        skip_message = {
+                            "type": "tool_call",
+                            "data": {
+                                "tool_name": "system",
+                                "call_id": remaining_call.id,
+                                "action_name": remaining_call.name,
+                                "arguments": {},
+                                "result": "Skipped: Context limit reached. Too many tool calls in conversation.",
+                                "status": "skipped"
+                            }
+                        }
+                        yield skip_message
+
+                    # Set flag on agent
+                    agent.context_limit_reached = True
+                    break
             try:
                 self.tool_calls.append(call)
                 tool_executor_gen = agent._execute_tool_action(tools_dict, call)
@@ -205,21 +710,26 @@ class LLMHandler(ABC):
                     except StopIteration as e:
                         tool_response, call_id = e.value
                         break
+                    
+                function_call_content = {
+                    "function_call": {
+                        "name": call.name,
+                        "args": call.arguments,
+                        "call_id": call_id,
+                    }
+                }
+                # Include thought_signature for Google Gemini 3 models
+                # It should be at the same level as function_call, not inside it
+                if call.thought_signature:
+                    function_call_content["thought_signature"] = call.thought_signature
                 updated_messages.append(
                     {
                         "role": "assistant",
-                        "content": [
-                            {
-                                "function_call": {
-                                    "name": call.name,
-                                    "args": call.arguments,
-                                    "call_id": call_id,
-                                }
-                            }
-                        ],
+                        "content": [function_call_content],
                     }
                 )
 
+
                 updated_messages.append(self.create_tool_message(call, tool_response))
             except Exception as e:
                 logger.error(f"Error executing tool: {str(e)}", exc_info=True)
@@ -282,7 +792,7 @@ class LLMHandler(ABC):
                     messages = e.value
                     break
             response = agent.llm.gen(
-                model=agent.gpt_model, messages=messages, tools=agent.tools
+                model=agent.model_id, messages=messages, tools=agent.tools
             )
             parsed = self.parse_response(response)
             self.llm_calls.append(build_stack_data(agent.llm))
@@ -324,6 +834,9 @@ class LLMHandler(ABC):
                             existing.name = call.name
                         if call.arguments:
                             existing.arguments += call.arguments
+                        # Preserve thought_signature for Google Gemini 3 models
+                        if call.thought_signature:
+                            existing.thought_signature = call.thought_signature
             if parsed.finish_reason == "tool_calls":
                 tool_handler_gen = self.handle_tool_calls(
                     agent, list(tool_calls.values()), tools_dict, messages
@@ -336,8 +849,21 @@ class LLMHandler(ABC):
                         break
                 tool_calls = {}
 
+                # Check if context limit was reached during tool execution
+                if hasattr(agent, 'context_limit_reached') and agent.context_limit_reached:
+                    # Add system message warning about context limit
+                    messages.append({
+                        "role": "system",
+                        "content": (
+                            "WARNING: Context window limit has been reached. "
+                            "Please provide a final response to the user without making additional tool calls. "
+                            "Summarize the work completed so far."
+                        )
+                    })
+                    logger.info("Context limit reached - instructing agent to wrap up")
+
                 response = agent.llm.gen_stream(
-                    model=agent.gpt_model, messages=messages, tools=agent.tools
+                    model=agent.model_id, messages=messages, tools=agent.tools if not agent.context_limit_reached else None
                 )
                 self.llm_calls.append(build_stack_data(agent.llm))
 

application/llm/handlers/google.py

@@ -19,15 +19,20 @@ class GoogleLLMHandler(LLMHandler):
             )
         if hasattr(response, "candidates"):
             parts = response.candidates[0].content.parts if response.candidates else []
-            tool_calls = [
-                ToolCall(
-                    id=str(uuid.uuid4()),
-                    name=part.function_call.name,
-                    arguments=part.function_call.args,
-                )
-                for part in parts
-                if hasattr(part, "function_call") and part.function_call is not None
-            ]
+            tool_calls = []
+            for idx, part in enumerate(parts):
+                if hasattr(part, "function_call") and part.function_call is not None:
+                    has_sig = hasattr(part, "thought_signature") and part.thought_signature is not None
+                    thought_sig = part.thought_signature if has_sig else None
+                    tool_calls.append(
+                        ToolCall(
+                            id=str(uuid.uuid4()),
+                            name=part.function_call.name,
+                            arguments=part.function_call.args,
+                            index=idx,
+                            thought_signature=thought_sig,
+                        )
+                    )
 
             content = " ".join(
                 part.text
@@ -41,13 +46,17 @@ class GoogleLLMHandler(LLMHandler):
                 raw_response=response,
             )
         else:
+            # This branch handles individual Part objects from streaming responses
             tool_calls = []
-            if hasattr(response, "function_call"):
+            if hasattr(response, "function_call") and response.function_call is not None:
+                has_sig = hasattr(response, "thought_signature") and response.thought_signature is not None
+                thought_sig = response.thought_signature if has_sig else None
                 tool_calls.append(
                     ToolCall(
                         id=str(uuid.uuid4()),
                         name=response.function_call.name,
                         arguments=response.function_call.args,
+                        thought_signature=thought_sig,
                     )
                 )
             return LLMResponse(

application/llm/llm_creator.py

@@ -1,13 +1,17 @@
-from application.llm.groq import GroqLLM
-from application.llm.openai import OpenAILLM, AzureOpenAILLM
-from application.llm.sagemaker import SagemakerAPILLM
-from application.llm.huggingface import HuggingFaceLLM
-from application.llm.llama_cpp import LlamaCpp
+import logging
+
 from application.llm.anthropic import AnthropicLLM
 from application.llm.docsgpt_provider import DocsGPTAPILLM
-from application.llm.premai import PremAILLM
 from application.llm.google_ai import GoogleLLM
+from application.llm.groq import GroqLLM
+from application.llm.huggingface import HuggingFaceLLM
+from application.llm.llama_cpp import LlamaCpp
 from application.llm.novita import NovitaLLM
+from application.llm.openai import AzureOpenAILLM, OpenAILLM
+from application.llm.premai import PremAILLM
+from application.llm.sagemaker import SagemakerAPILLM
+
+logger = logging.getLogger(__name__)
 
 
 class LLMCreator:
@@ -26,10 +30,26 @@ class LLMCreator:
     }
 
     @classmethod
-    def create_llm(cls, type, api_key, user_api_key, decoded_token, *args, **kwargs):
+    def create_llm(
+        cls, type, api_key, user_api_key, decoded_token, model_id=None, *args, **kwargs
+    ):
+        from application.core.model_utils import get_base_url_for_model
+
         llm_class = cls.llms.get(type.lower())
         if not llm_class:
             raise ValueError(f"No LLM class found for type {type}")
+
+        # Extract base_url from model configuration if model_id is provided
+        base_url = None
+        if model_id:
+            base_url = get_base_url_for_model(model_id)
+
         return llm_class(
-            api_key, user_api_key, decoded_token=decoded_token, *args, **kwargs
+            api_key,
+            user_api_key,
+            decoded_token=decoded_token,
+            model_id=model_id,
+            base_url=base_url,
+            *args,
+            **kwargs,
         )

application/llm/openai.py

@@ -2,6 +2,8 @@ import base64
 import json
 import logging
 
+from openai import OpenAI
+
 from application.core.settings import settings
 from application.llm.base import BaseLLM
 from application.storage.storage_creator import StorageCreator
@@ -9,20 +11,25 @@ from application.storage.storage_creator import StorageCreator
 
 class OpenAILLM(BaseLLM):
 
-    def __init__(self, api_key=None, user_api_key=None, *args, **kwargs):
-        from openai import OpenAI
+    def __init__(self, api_key=None, user_api_key=None, base_url=None, *args, **kwargs):
 
         super().__init__(*args, **kwargs)
-        if (
+        self.api_key = api_key or settings.OPENAI_API_KEY or settings.API_KEY
+        self.user_api_key = user_api_key
+
+        # Priority: 1) Parameter base_url, 2) Settings OPENAI_BASE_URL, 3) Default
+        effective_base_url = None
+        if base_url and isinstance(base_url, str) and base_url.strip():
+            effective_base_url = base_url
+        elif (
             isinstance(settings.OPENAI_BASE_URL, str)
             and settings.OPENAI_BASE_URL.strip()
         ):
-            self.client = OpenAI(api_key=api_key, base_url=settings.OPENAI_BASE_URL)
+            effective_base_url = settings.OPENAI_BASE_URL
         else:
-            DEFAULT_OPENAI_API_BASE = "https://api.openai.com/v1"
-            self.client = OpenAI(api_key=api_key, base_url=DEFAULT_OPENAI_API_BASE)
-        self.api_key = api_key
-        self.user_api_key = user_api_key
+            effective_base_url = "https://api.openai.com/v1"
+
+        self.client = OpenAI(api_key=self.api_key, base_url=effective_base_url)
         self.storage = StorageCreator.get_storage()
 
     def _clean_messages_openai(self, messages):
@@ -33,7 +40,6 @@ class OpenAILLM(BaseLLM):
 
             if role == "model":
                 role = "assistant"
-
             if role and content is not None:
                 if isinstance(content, str):
                     cleaned_messages.append({"role": role, "content": content})
@@ -44,14 +50,15 @@ class OpenAILLM(BaseLLM):
                                 {"role": role, "content": item["text"]}
                             )
                         elif "function_call" in item:
+                            cleaned_args = self._remove_null_values(
+                                item["function_call"]["args"]
+                            )
                             tool_call = {
                                 "id": item["function_call"]["call_id"],
                                 "type": "function",
                                 "function": {
                                     "name": item["function_call"]["name"],
-                                    "arguments": json.dumps(
-                                        item["function_call"]["args"]
-                                    ),
+                                    "arguments": json.dumps(cleaned_args),
                                 },
                             }
                             cleaned_messages.append(
@@ -106,7 +113,6 @@ class OpenAILLM(BaseLLM):
                             )
                 else:
                     raise ValueError(f"Unexpected content type: {type(content)}")
-
         return cleaned_messages
 
     def _raw_gen(
@@ -122,6 +128,10 @@ class OpenAILLM(BaseLLM):
     ):
         messages = self._clean_messages_openai(messages)
 
+        # Convert max_tokens to max_completion_tokens for newer models
+        if "max_tokens" in kwargs:
+            kwargs["max_completion_tokens"] = kwargs.pop("max_tokens")
+
         request_params = {
             "model": model,
             "messages": messages,
@@ -131,10 +141,8 @@ class OpenAILLM(BaseLLM):
 
         if tools:
             request_params["tools"] = tools
-
         if response_format:
             request_params["response_format"] = response_format
-
         response = self.client.chat.completions.create(**request_params)
 
         if tools:
@@ -155,6 +163,10 @@ class OpenAILLM(BaseLLM):
     ):
         messages = self._clean_messages_openai(messages)
 
+        # Convert max_tokens to max_completion_tokens for newer models
+        if "max_tokens" in kwargs:
+            kwargs["max_completion_tokens"] = kwargs.pop("max_tokens")
+
         request_params = {
             "model": model,
             "messages": messages,
@@ -164,21 +176,23 @@ class OpenAILLM(BaseLLM):
 
         if tools:
             request_params["tools"] = tools
-
         if response_format:
             request_params["response_format"] = response_format
-
         response = self.client.chat.completions.create(**request_params)
 
-        for line in response:
-            if (
-                len(line.choices) > 0
-                and line.choices[0].delta.content is not None
-                and len(line.choices[0].delta.content) > 0
-            ):
-                yield line.choices[0].delta.content
-            elif len(line.choices) > 0:
-                yield line.choices[0]
+        try:
+            for line in response:
+                if (
+                    len(line.choices) > 0
+                    and line.choices[0].delta.content is not None
+                    and len(line.choices[0].delta.content) > 0
+                ):
+                    yield line.choices[0].delta.content
+                elif len(line.choices) > 0:
+                    yield line.choices[0]
+        finally:
+            if hasattr(response, "close"):
+                response.close()
 
     def _supports_tools(self):
         return True
@@ -189,7 +203,6 @@ class OpenAILLM(BaseLLM):
     def prepare_structured_output_format(self, json_schema):
         if not json_schema:
             return None
-
         try:
 
             def add_additional_properties_false(schema_obj):
@@ -199,11 +212,11 @@ class OpenAILLM(BaseLLM):
                     if schema_copy.get("type") == "object":
                         schema_copy["additionalProperties"] = False
                         # Ensure 'required' includes all properties for OpenAI strict mode
+
                         if "properties" in schema_copy:
                             schema_copy["required"] = list(
                                 schema_copy["properties"].keys()
                             )
-
                     for key, value in schema_copy.items():
                         if key == "properties" and isinstance(value, dict):
                             schema_copy[key] = {
@@ -219,7 +232,6 @@ class OpenAILLM(BaseLLM):
                                 add_additional_properties_false(sub_schema)
                                 for sub_schema in value
                             ]
-
                     return schema_copy
                 return schema_obj
 
@@ -238,7 +250,6 @@ class OpenAILLM(BaseLLM):
             }
 
             return result
-
         except Exception as e:
             logging.error(f"Error preparing structured output format: {e}")
             return None
@@ -272,21 +283,19 @@ class OpenAILLM(BaseLLM):
         """
         if not attachments:
             return messages
-
         prepared_messages = messages.copy()
 
         # Find the user message to attach file_id to the last one
+
         user_message_index = None
         for i in range(len(prepared_messages) - 1, -1, -1):
             if prepared_messages[i].get("role") == "user":
                 user_message_index = i
                 break
-
         if user_message_index is None:
             user_message = {"role": "user", "content": []}
             prepared_messages.append(user_message)
             user_message_index = len(prepared_messages) - 1
-
         if isinstance(prepared_messages[user_message_index].get("content"), str):
             text_content = prepared_messages[user_message_index]["content"]
             prepared_messages[user_message_index]["content"] = [
@@ -294,7 +303,6 @@ class OpenAILLM(BaseLLM):
             ]
         elif not isinstance(prepared_messages[user_message_index].get("content"), list):
             prepared_messages[user_message_index]["content"] = []
-
         for attachment in attachments:
             mime_type = attachment.get("mime_type")
 
@@ -321,6 +329,7 @@ class OpenAILLM(BaseLLM):
                             }
                         )
             # Handle PDFs using the file API
+
             elif mime_type == "application/pdf":
                 try:
                     file_id = self._upload_file_to_openai(attachment)
@@ -336,7 +345,6 @@ class OpenAILLM(BaseLLM):
                                 "text": f"File content:\n\n{attachment['content']}",
                             }
                         )
-
         return prepared_messages
 
     def _get_base64_image(self, attachment):
@@ -352,7 +360,6 @@ class OpenAILLM(BaseLLM):
         file_path = attachment.get("path")
         if not file_path:
             raise ValueError("No file path provided in attachment")
-
         try:
             with self.storage.get_file(file_path) as image_file:
                 return base64.b64encode(image_file.read()).decode("utf-8")
@@ -376,12 +383,10 @@ class OpenAILLM(BaseLLM):
 
         if "openai_file_id" in attachment:
             return attachment["openai_file_id"]
-
         file_path = attachment.get("path")
 
         if not self.storage.file_exists(file_path):
             raise FileNotFoundError(f"File not found: {file_path}")
-
         try:
             file_id = self.storage.process_file(
                 file_path,
@@ -399,7 +404,6 @@ class OpenAILLM(BaseLLM):
                 attachments_collection.update_one(
                     {"_id": attachment["_id"]}, {"$set": {"openai_file_id": file_id}}
                 )
-
             return file_id
         except Exception as e:
             logging.error(f"Error uploading file to OpenAI: {e}", exc_info=True)

application/parser/embedding_pipeline.py

@@ -1,5 +1,6 @@
 import os
 import logging
+from typing import List, Any
 from retry import retry
 from tqdm import tqdm
 from application.core.settings import settings
@@ -22,13 +23,16 @@ def sanitize_content(content: str) -> str:
 
 
 @retry(tries=10, delay=60)
-def add_text_to_store_with_retry(store, doc, source_id):
-    """
-    Add a document's text and metadata to the vector store with retry logic.
+def add_text_to_store_with_retry(store: Any, doc: Any, source_id: str) -> None:
+    """Add a document's text and metadata to the vector store with retry logic.
+    
     Args:
         store: The vector store object.
         doc: The document to be added.
         source_id: Unique identifier for the source.
+        
+    Raises:
+        Exception: If document addition fails after all retry attempts.
     """
     try:
         # Sanitize content to remove NUL characters that cause ingestion failures
@@ -41,18 +45,21 @@ def add_text_to_store_with_retry(store, doc, source_id):
         raise
 
 
-def embed_and_store_documents(docs, folder_name, source_id, task_status):
-    """
-    Embeds documents and stores them in a vector store.
+def embed_and_store_documents(docs: List[Any], folder_name: str, source_id: str, task_status: Any) -> None:
+    """Embeds documents and stores them in a vector store.
 
     Args:
-        docs (list): List of documents to be embedded and stored.
-        folder_name (str): Directory to save the vector store.
-        source_id (str): Unique identifier for the source.
+        docs: List of documents to be embedded and stored.
+        folder_name: Directory to save the vector store.
+        source_id: Unique identifier for the source.
         task_status: Task state manager for progress updates.
 
     Returns:
         None
+        
+    Raises:
+        OSError: If unable to create folder or save vector store.
+        Exception: If vector store creation or document embedding fails.
     """
     # Ensure the folder exists
     if not os.path.exists(folder_name):
@@ -95,10 +102,21 @@ def embed_and_store_documents(docs, folder_name, source_id, task_status):
         except Exception as e:
             logging.error(f"Error embedding document {idx}: {e}", exc_info=True)
             logging.info(f"Saving progress at document {idx} out of {total_docs}")
-            store.save_local(folder_name)
+            try:
+                store.save_local(folder_name)
+                logging.info("Progress saved successfully")
+            except Exception as save_error:
+                logging.error(f"CRITICAL: Failed to save progress: {save_error}", exc_info=True)
+                # Continue without breaking to attempt final save
             break
 
     # Save the vector store
     if settings.VECTOR_STORE == "faiss":
-        store.save_local(folder_name)
-    logging.info("Vector store saved successfully.")
+        try:
+            store.save_local(folder_name)
+            logging.info("Vector store saved successfully.")
+        except Exception as e:
+            logging.error(f"CRITICAL: Failed to save final vector store: {e}", exc_info=True)
+            raise OSError(f"Unable to save vector store to {folder_name}: {e}") from e
+    else:
+        logging.info("Vector store saved successfully.")

application/parser/remote/github_loader.py

@@ -1,44 +1,135 @@
 import base64
 import requests
-from typing import List
+import time
+from typing import List, Optional
 from application.parser.remote.base import BaseRemote
-from langchain_core.documents import Document
+from application.parser.schema.base import Document
 import mimetypes
+from application.core.settings import settings
 
 class GitHubLoader(BaseRemote):
     def __init__(self):
-        self.access_token = None
+        self.access_token = settings.GITHUB_ACCESS_TOKEN
         self.headers = {
-            "Authorization": f"token {self.access_token}"
-        } if self.access_token else {}
+            "Authorization": f"token {self.access_token}",
+            "Accept": "application/vnd.github.v3+json"
+        } if self.access_token else {
+            "Accept": "application/vnd.github.v3+json"
+        }
         return
 
-    def fetch_file_content(self, repo_url: str, file_path: str) -> str:
+    def is_text_file(self, file_path: str) -> bool:
+        """Determine if a file is a text file based on extension."""
+        # Common text file extensions
+        text_extensions = {
+            '.txt', '.md', '.markdown', '.rst', '.json', '.xml', '.yaml', '.yml',
+            '.py', '.js', '.ts', '.jsx', '.tsx', '.java', '.c', '.cpp', '.h', '.hpp',
+            '.cs', '.go', '.rs', '.rb', '.php', '.swift', '.kt', '.scala',
+            '.html', '.css', '.scss', '.sass', '.less',
+            '.sh', '.bash', '.zsh', '.fish',
+            '.sql', '.r', '.m', '.mat',
+            '.ini', '.cfg', '.conf', '.config', '.env',
+            '.gitignore', '.dockerignore', '.editorconfig',
+            '.log', '.csv', '.tsv'
+        }
+
+        # Get file extension
+        file_lower = file_path.lower()
+        for ext in text_extensions:
+            if file_lower.endswith(ext):
+                return True
+
+        # Also check MIME type
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type and (mime_type.startswith("text") or mime_type in ["application/json", "application/xml"]):
+            return True
+
+        return False
+
+    def fetch_file_content(self, repo_url: str, file_path: str) -> Optional[str]:
+        """Fetch file content. Returns None if file should be skipped (binary files or empty files)."""
         url = f"https://api.github.com/repos/{repo_url}/contents/{file_path}"
-        response = requests.get(url, headers=self.headers)
+        response = self._make_request(url)
 
-        if response.status_code == 200:
-            content = response.json()
-            mime_type, _ = mimetypes.guess_type(file_path)  # Guess the MIME type based on the file extension
+        content = response.json()
 
-            if content.get("encoding") == "base64":
-                if mime_type and mime_type.startswith("text"):  # Handle only text files
-                    try:
-                        decoded_content = base64.b64decode(content["content"]).decode("utf-8")
-                        return f"Filename: {file_path}\n\n{decoded_content}"
-                    except Exception as e:
-                        raise e
-                else:
-                    return f"Filename: {file_path} is a binary file and was skipped."
+        if content.get("encoding") == "base64":
+            if self.is_text_file(file_path):  # Handle only text files
+                try:
+                    decoded_content = base64.b64decode(content["content"]).decode("utf-8").strip()
+                    # Skip empty files
+                    if not decoded_content:
+                        return None
+                    return decoded_content
+                except Exception:
+                    # If decoding fails, it's probably a binary file
+                    return None
             else:
-                return f"Filename: {file_path}\n\n{content['content']}"
+                # Skip binary files by returning None
+                return None
         else:
-            response.raise_for_status()
+            file_content = content['content'].strip()
+            # Skip empty files
+            if not file_content:
+                return None
+            return file_content
+
+    def _make_request(self, url: str, max_retries: int = 3) -> requests.Response:
+        """Make a request with retry logic for rate limiting"""
+        for attempt in range(max_retries):
+            response = requests.get(url, headers=self.headers)
+
+            if response.status_code == 200:
+                return response
+            elif response.status_code == 403:
+                # Check if it's a rate limit issue
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get("message", "")
+
+                    # Check rate limit headers
+                    remaining = response.headers.get("X-RateLimit-Remaining", "unknown")
+                    reset_time = response.headers.get("X-RateLimit-Reset", "unknown")
+
+                    print(f"GitHub API 403 Error: {error_msg}")
+                    print(f"Rate limit remaining: {remaining}, Reset time: {reset_time}")
+
+                    if "rate limit" in error_msg.lower():
+                        if attempt < max_retries - 1:
+                            wait_time = 2 ** attempt  # Exponential backoff
+                            print(f"Rate limit hit, waiting {wait_time} seconds before retry...")
+                            time.sleep(wait_time)
+                            continue
+
+                    # Provide helpful error message
+                    if remaining == "0":
+                        raise Exception(f"GitHub API rate limit exceeded. Please set GITHUB_ACCESS_TOKEN environment variable. Reset time: {reset_time}")
+                    else:
+                        raise Exception(f"GitHub API error: {error_msg}. This may require authentication - set GITHUB_ACCESS_TOKEN environment variable.")
+                except Exception as e:
+                    if isinstance(e, Exception) and "GitHub API" in str(e):
+                        raise
+                    # If we can't parse the response, raise the original error
+                    response.raise_for_status()
+            else:
+                response.raise_for_status()
+
+        return response
 
     def fetch_repo_files(self, repo_url: str, path: str = "") -> List[str]:
         url = f"https://api.github.com/repos/{repo_url}/contents/{path}"
-        response = requests.get(url, headers={**self.headers, "Accept": "application/vnd.github.v3.raw"})
+        response = self._make_request(url)
+
         contents = response.json()
+
+        # Handle error responses from GitHub API
+        if isinstance(contents, dict) and "message" in contents:
+            raise Exception(f"GitHub API error: {contents.get('message')}")
+
+        # Ensure contents is a list
+        if not isinstance(contents, list):
+            raise TypeError(f"Expected list from GitHub API, got {type(contents).__name__}: {contents}")
+
         files = []
         for item in contents:
             if item["type"] == "file":
@@ -53,6 +144,15 @@ class GitHubLoader(BaseRemote):
         documents = []
         for file_path in files:
             content = self.fetch_file_content(repo_name, file_path)
-            documents.append(Document(page_content=content, metadata={"title": file_path, 
-            "source": f"https://github.com/{repo_name}/blob/main/{file_path}"}))
+            # Skip binary files (content is None)
+            if content is None:
+                continue
+            documents.append(Document(
+                text=content,
+                doc_id=file_path,
+                extra_info={
+                    "title": file_path,
+                    "source": f"https://github.com/{repo_name}/blob/main/{file_path}"
+                }
+            ))
         return documents

application/prompts/compression/v1.0.txt

@@ -0,0 +1,35 @@
+Your task is to create a detailed summary of the conversation so far, paying close attention to the user's explicit requests and your previous actions.
+
+This summary should be thorough in capturing technical details, code patterns, and architectural decisions that would be essential for continuing work without losing context.
+
+Before providing your final summary, wrap your analysis in <analysis> tags to organize your thoughts and ensure you've covered all necessary points. In your analysis process:
+
+1. Chronologically analyze each message, tool call and section of the conversation. For each section thoroughly identify:
+   - The user's explicit requests and intents
+   - Your approach to addressing the user's requests
+   - Key decisions, concepts and patterns
+   - Specific details like if applicable:
+     - file names
+     - full code snippets
+     - function signatures
+     - file edits
+   - Errors that you ran into and how you fixed them
+   - Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+
+2. Double-check for accuracy and completeness, addressing each required element thoroughly.
+
+Your summary should include the following sections:
+
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Concepts: List all important concepts discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
+7. Tool Calls: List ALL tool calls made, including their inputs relevant parts of the outputs.
+8. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+9. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+10. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's most recent explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests or really old requests that were already completed without confirming with the user first.
+If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.
+
+Please provide your summary based on the conversation and tools used so far, following this structure and ensuring precision and thoroughness in your response.

application/requirements.txt

@@ -10,11 +10,12 @@ ebooklib==0.18
 escodegen==1.0.11
 esprima==4.0.1
 esutils==1.0.1
+elevenlabs==2.17.0
 Flask==3.1.1
 faiss-cpu==1.9.0.post1
 fastmcp==2.11.0
 flask-restx==1.3.0
-google-genai==1.3.0
+google-genai==1.49.0
 google-api-python-client==2.179.0
 google-auth-httplib2==0.2.0
 google-auth-oauthlib==1.2.2

application/retriever/base.py

@@ -8,7 +8,3 @@ class BaseRetriever(ABC):
     @abstractmethod
     def search(self, *args, **kwargs):
         pass
-
-    @abstractmethod
-    def get_params(self):
-        pass

application/retriever/classic_rag.py

@@ -4,7 +4,7 @@ import os
 from application.core.settings import settings
 from application.llm.llm_creator import LLMCreator
 from application.retriever.base import BaseRetriever
-
+from application.utils import num_tokens_from_string
 from application.vectorstore.vector_creator import VectorCreator
 
 
@@ -15,14 +15,13 @@ class ClassicRAG(BaseRetriever):
         chat_history=None,
         prompt="",
         chunks=2,
-        token_limit=150,
-        gpt_model="docsgpt",
+        doc_token_limit=50000,
+        model_id="docsgpt-local",
         user_api_key=None,
         llm_name=settings.LLM_PROVIDER,
         api_key=settings.API_KEY,
         decoded_token=None,
     ):
-        """Initialize ClassicRAG retriever with vectorstore sources and LLM configuration"""
         self.original_question = source.get("question", "")
         self.chat_history = chat_history if chat_history is not None else []
         self.prompt = prompt
@@ -41,17 +40,8 @@ class ClassicRAG(BaseRetriever):
             f"ClassicRAG initialized with chunks={self.chunks}, user_api_key={user_identifier}, "
             f"sources={'active_docs' in source and source['active_docs'] is not None}"
         )
-        self.gpt_model = gpt_model
-        self.token_limit = (
-            token_limit
-            if token_limit
-            < settings.LLM_TOKEN_LIMITS.get(
-                self.gpt_model, settings.DEFAULT_MAX_HISTORY
-            )
-            else settings.LLM_TOKEN_LIMITS.get(
-                self.gpt_model, settings.DEFAULT_MAX_HISTORY
-            )
-        )
+        self.model_id = model_id
+        self.doc_token_limit = doc_token_limit
         self.user_api_key = user_api_key
         self.llm_name = llm_name
         self.api_key = api_key
@@ -110,7 +100,7 @@ class ClassicRAG(BaseRetriever):
         ]
 
         try:
-            rephrased_query = self.llm.gen(model=self.gpt_model, messages=messages)
+            rephrased_query = self.llm.gen(model=self.model_id, messages=messages)
             print(f"Rephrased query: {rephrased_query}")
             return rephrased_query if rephrased_query else self.original_question
         except Exception as e:
@@ -118,21 +108,17 @@ class ClassicRAG(BaseRetriever):
             return self.original_question
 
     def _get_data(self):
-        """Retrieve relevant documents from configured vectorstores"""
         if self.chunks == 0 or not self.vectorstores:
             logging.info(
                 f"ClassicRAG._get_data: Skipping retrieval - chunks={self.chunks}, "
                 f"vectorstores_count={len(self.vectorstores) if self.vectorstores else 0}"
             )
             return []
+
         all_docs = []
         chunks_per_source = max(1, self.chunks // len(self.vectorstores))
-
-        logging.info(
-            f"ClassicRAG._get_data: Starting retrieval with chunks={self.chunks}, "
-            f"vectorstores={self.vectorstores}, chunks_per_source={chunks_per_source}, "
-            f"query='{self.question[:50]}...'"
-        )
+        token_budget = max(int(self.doc_token_limit * 0.9), 100)
+        cumulative_tokens = 0
 
         for vectorstore_id in self.vectorstores:
             if vectorstore_id:
@@ -140,15 +126,21 @@ class ClassicRAG(BaseRetriever):
                     docsearch = VectorCreator.create_vectorstore(
                         settings.VECTOR_STORE, vectorstore_id, settings.EMBEDDINGS_KEY
                     )
-                    docs_temp = docsearch.search(self.question, k=chunks_per_source)
+                    docs_temp = docsearch.search(
+                        self.question, k=max(chunks_per_source * 2, 20)
+                    )
 
                     for doc in docs_temp:
+                        if cumulative_tokens >= token_budget:
+                            break
+
                         if hasattr(doc, "page_content") and hasattr(doc, "metadata"):
                             page_content = doc.page_content
                             metadata = doc.metadata
                         else:
                             page_content = doc.get("text", doc.get("page_content", ""))
                             metadata = doc.get("metadata", {})
+
                         title = metadata.get(
                             "title", metadata.get("post_title", page_content)
                         )
@@ -168,23 +160,35 @@ class ClassicRAG(BaseRetriever):
                         if not filename:
                             filename = title
                         source_path = metadata.get("source") or vectorstore_id
-                        all_docs.append(
-                            {
-                                "title": title,
-                                "text": page_content,
-                                "source": source_path,
-                                "filename": filename,
-                            }
-                        )
+
+                        doc_text_with_header = f"{filename}\n{page_content}"
+                        doc_tokens = num_tokens_from_string(doc_text_with_header)
+
+                        if cumulative_tokens + doc_tokens < token_budget:
+                            all_docs.append(
+                                {
+                                    "title": title,
+                                    "text": page_content,
+                                    "source": source_path,
+                                    "filename": filename,
+                                }
+                            )
+                            cumulative_tokens += doc_tokens
+
+                    if cumulative_tokens >= token_budget:
+                        break
+
                 except Exception as e:
                     logging.error(
                         f"Error searching vectorstore {vectorstore_id}: {e}",
                         exc_info=True,
                     )
                     continue
+
         logging.info(
             f"ClassicRAG._get_data: Retrieval complete - retrieved {len(all_docs)} documents "
-            f"(requested chunks={self.chunks}, chunks_per_source={chunks_per_source})"
+            f"(requested chunks={self.chunks}, chunks_per_source={chunks_per_source}, "
+            f"cumulative_tokens={cumulative_tokens}/{token_budget})"
         )
         return all_docs
 
@@ -194,15 +198,3 @@ class ClassicRAG(BaseRetriever):
             self.original_question = query
             self.question = self._rephrase_query()
         return self._get_data()
-
-    def get_params(self):
-        """Return current retriever configuration parameters"""
-        return {
-            "question": self.original_question,
-            "rephrased_question": self.question,
-            "sources": self.vectorstores,
-            "chunks": self.chunks,
-            "token_limit": self.token_limit,
-            "gpt_model": self.gpt_model,
-            "user_api_key": self.user_api_key,
-        }

application/seed/commands.py

@@ -0,0 +1,26 @@
+import click
+
+from application.core.mongo_db import MongoDB
+from application.core.settings import settings
+from application.seed.seeder import DatabaseSeeder
+
+
+@click.group()
+def seed():
+    """Database seeding commands"""
+    pass
+
+
+@seed.command()
+@click.option("--force", is_flag=True, help="Force reseeding even if data exists")
+def init(force):
+    """Initialize database with seed data"""
+    mongo = MongoDB.get_client()
+    db = mongo[settings.MONGO_DB_NAME]
+
+    seeder = DatabaseSeeder(db)
+    seeder.seed_initial_data(force=force)
+
+
+if __name__ == "__main__":
+    seed()

application/seed/config/agents_template.yaml

@@ -0,0 +1,36 @@
+# Configuration for Premade Agents
+# This file contains template agents that will be seeded into the database
+
+agents:
+  # Basic Agent Template
+  - name: "Agent Name" # Required: Unique name for the agent
+    description: "What this agent does" # Required: Brief description of the agent's purpose
+    image: "URL_TO_IMAGE" # Optional: URL to agent's avatar/image
+    agent_type: "classic" # Required: Type of agent (e.g., classic, react, etc.)
+    prompt_id: "default" # Optional: Reference to prompt template
+    prompt: # Optional: Define new prompt
+      name: "New Prompt"
+      content: "You are new agent with cool new prompt."
+    chunks: "0" # Optional: Chunking strategy for documents
+    retriever: "" # Optional: Retriever type for document search
+
+    # Source Configuration (where the agent gets its knowledge)
+    source: # Optional: Select a source to link with agent
+      name: "Source Display Name" # Human-readable name for the source
+      url: "https://example.com/data-source" # URL or path to knowledge source
+      loader: "url" # Type of loader (url, pdf, txt, etc.)
+
+    # Tools Configuration (what capabilities the agent has)
+    tools: # Optional: Remove if agent doesn't need tools
+      - name: "tool_name" # Must match a supported tool name
+        display_name: "Tool Display Name" # Optional: Human-readable name for the tool
+        config:
+        # Tool-specific configuration
+        # Example for DuckDuckGo:
+        # token: "${DDG_API_KEY}"          # ${} denotes environment variable
+
+      # Add more tools as needed
+      # - name: "another_tool"
+      #   config:
+      #     param1: "value1"
+      #     param2: "${ENV_VAR}"

application/seed/config/premade_agents.yaml

@@ -0,0 +1,94 @@
+# Configuration for Premade Agents
+
+agents:
+  - name: "Assistant"
+    description: "Your general-purpose AI assistant. Ready to help with a wide range of tasks."
+    image: "https://d3dg1063dc54p9.cloudfront.net/imgs/agents/agent-logo.svg"
+    agent_type: "classic"
+    prompt_id: "default"
+    chunks: "0"
+    retriever: ""
+
+    # Tools Configuration
+    tools:
+      - name: "tool_name"
+        display_name: "read_webpage" 
+        config:
+
+  - name: "Researcher"
+    description: "A specialized research agent that performs deep dives into subjects."
+    image: "https://d3dg1063dc54p9.cloudfront.net/imgs/agents/agent-researcher.svg"
+    agent_type: "react"
+    prompt:
+      name: "Researcher-Agent"
+      content: |
+        You are a specialized AI research assistant, DocsGPT. Your primary function is to conduct in-depth research on a given subject or question. You are methodical, thorough, and analytical. You should perform multiple iterations of thinking to gather and synthesize information before providing a final, comprehensive answer.
+
+        You have access to the 'Read Webpage' tool. Use this tool to explore sources, gather data, and deepen your understanding. Be proactive in using the tool to fill in knowledge gaps and validate information.
+
+        Users can Upload documents for your context as attachments or sources via UI using the Conversation input box.
+        If appropriate, your answers can include code examples, formatted as follows:
+        ```(language)
+        (code)
+        ```
+        Users are also able to see charts and diagrams if you use them with valid mermaid syntax in your responses. Try to respond with mermaid charts if visualization helps with users queries. You effectively utilize chat history, ensuring relevant and tailored responses. Try to use additional provided context if it's available, otherwise use your knowledge and tool capabilities.
+        ----------------
+        Possible additional context from uploaded sources:
+        {summaries}
+
+    chunks: "0"
+    retriever: ""
+
+    # Tools Configuration
+    tools:
+      - name: "tool_name"
+        display_name: "read_webpage" 
+        config:
+
+  - name: "Search Widget"
+    description: "A powerful search widget agent. Ask it anything about DocsGPT"
+    image: "https://d3dg1063dc54p9.cloudfront.net/imgs/agents/agent-search.svg"
+    agent_type: "classic"
+    prompt:
+      name: "Search-Agent"
+      content: |
+        You are a website search assistant, DocsGPT. Your sole purpose is to help users find information within the provided context of the DocsGPT documentation. Act as a specialized search engine.
+
+        Your answers must be based *only* on the provided context. Do not use any external knowledge. If the answer is not in the context, inform the user that you could not find the information within the documentation.
+
+        Keep your responses concise and directly related to the user's query, pointing them to the most relevant information.
+        ----------------
+        Possible additional context from uploaded sources:
+        {summaries}
+
+    chunks: "8"
+    retriever: ""
+
+    source:
+      name: "DocsGPT-Docs"
+      url: "https://d3dg1063dc54p9.cloudfront.net/agent-source/docsgpt-documentation.md" # URL to DocsGPT documentation
+      loader: "url" 
+
+  - name: "Support Widget"
+    description: "A friendly support widget agent to help you with any questions."
+    image: "https://d3dg1063dc54p9.cloudfront.net/imgs/agents/agent-support.svg"
+    agent_type: "classic"
+    prompt:
+      name: "Support-Agent"
+      content: |
+        You are a helpful AI support widget agent, DocsGPT. Your goal is to assist users by answering their questions about our website, product and its features. Provide friendly, clear, and direct support.
+
+        Your knowledge is strictly limited to the provided context from the DocsGPT documentation. You must not answer questions outside of this scope. If a user asks something you cannot answer from the context, politely state that you can only help with questions about this website.
+
+        Effectively utilize chat history to understand the user's issue fully. Guide users to the information they need in a helpful and conversational manner.
+        ----------------
+        Possible additional context from uploaded sources:
+        {summaries}
+
+    chunks: "8"
+    retriever: ""
+
+    source:
+      name: "DocsGPT-Docs"
+      url: "https://d3dg1063dc54p9.cloudfront.net/agent-source/docsgpt-documentation.md" # URL to DocsGPT documentation
+      loader: "url" 

application/seed/seeder.py

@@ -0,0 +1,277 @@
+import logging
+import os
+from datetime import datetime, timezone
+from typing import Dict, List, Optional, Union
+
+import yaml
+from bson import ObjectId
+from bson.dbref import DBRef
+
+from dotenv import load_dotenv
+from pymongo import MongoClient
+
+from application.agents.tools.tool_manager import ToolManager
+from application.api.user.tasks import ingest_remote
+
+load_dotenv()
+tool_config = {}
+tool_manager = ToolManager(config=tool_config)
+
+
+class DatabaseSeeder:
+    def __init__(self, db):
+        self.db = db
+        self.tools_collection = self.db["user_tools"]
+        self.sources_collection = self.db["sources"]
+        self.agents_collection = self.db["agents"]
+        self.prompts_collection = self.db["prompts"]
+        self.system_user_id = "system"
+        self.logger = logging.getLogger(__name__)
+
+    def seed_initial_data(self, config_path: str = None, force=False):
+        """Main entry point for seeding all initial data"""
+        if not force and self._is_already_seeded():
+            self.logger.info("Database already seeded. Use force=True to reseed.")
+            return
+        config_path = config_path or os.path.join(
+            os.path.dirname(__file__), "config", "premade_agents.yaml"
+        )
+
+        try:
+            with open(config_path, "r") as f:
+                config = yaml.safe_load(f)
+                self._seed_from_config(config)
+        except Exception as e:
+            self.logger.error(f"Failed to load seeding config: {str(e)}")
+            raise
+
+    def _seed_from_config(self, config: Dict):
+        """Seed all data from configuration"""
+        self.logger.info("🌱 Starting seeding...")
+
+        if not config.get("agents"):
+            self.logger.warning("No agents found in config")
+            return
+        used_tool_ids = set()
+
+        for agent_config in config["agents"]:
+            try:
+                self.logger.info(f"Processing agent: {agent_config['name']}")
+
+                # 1. Handle Source
+
+                source_result = self._handle_source(agent_config)
+                if source_result is False:
+                    self.logger.error(
+                        f"Skipping agent {agent_config['name']} due to source ingestion failure"
+                    )
+                    continue
+                source_id = source_result
+                # 2. Handle Tools
+
+                tool_ids = self._handle_tools(agent_config)
+                if len(tool_ids) == 0:
+                    self.logger.warning(
+                        f"No valid tools for agent {agent_config['name']}"
+                    )
+                used_tool_ids.update(tool_ids)
+
+                # 3. Handle Prompt
+
+                prompt_id = self._handle_prompt(agent_config)
+
+                # 4. Create Agent
+
+                agent_data = {
+                    "user": self.system_user_id,
+                    "name": agent_config["name"],
+                    "description": agent_config["description"],
+                    "image": agent_config.get("image", ""),
+                    "source": (
+                        DBRef("sources", ObjectId(source_id)) if source_id else ""
+                    ),
+                    "tools": [str(tid) for tid in tool_ids],
+                    "agent_type": agent_config["agent_type"],
+                    "prompt_id": prompt_id or agent_config.get("prompt_id", "default"),
+                    "chunks": agent_config.get("chunks", "0"),
+                    "retriever": agent_config.get("retriever", ""),
+                    "status": "template",
+                    "createdAt": datetime.now(timezone.utc),
+                    "updatedAt": datetime.now(timezone.utc),
+                }
+
+                existing = self.agents_collection.find_one(
+                    {"user": self.system_user_id, "name": agent_config["name"]}
+                )
+                if existing:
+                    self.logger.info(f"Updating existing agent: {agent_config['name']}")
+                    self.agents_collection.update_one(
+                        {"_id": existing["_id"]}, {"$set": agent_data}
+                    )
+                    agent_id = existing["_id"]
+                else:
+                    self.logger.info(f"Creating new agent: {agent_config['name']}")
+                    result = self.agents_collection.insert_one(agent_data)
+                    agent_id = result.inserted_id
+                self.logger.info(
+                    f"Successfully processed agent: {agent_config['name']} (ID: {agent_id})"
+                )
+            except Exception as e:
+                self.logger.error(
+                    f"Error processing agent {agent_config['name']}: {str(e)}"
+                )
+                continue
+        self.logger.info("✅ Database seeding completed")
+
+    def _handle_source(self, agent_config: Dict) -> Union[ObjectId, None, bool]:
+        """Handle source ingestion and return source ID"""
+        if not agent_config.get("source"):
+            self.logger.info(
+                "No source provided for agent - will create agent without source"
+            )
+            return None
+        source_config = agent_config["source"]
+        self.logger.info(f"Ingesting source: {source_config['url']}")
+
+        try:
+            existing = self.sources_collection.find_one(
+                {"user": self.system_user_id, "remote_data": source_config["url"]}
+            )
+            if existing:
+                self.logger.info(f"Source already exists: {existing['_id']}")
+                return existing["_id"]
+            # Ingest new source using worker
+
+            task = ingest_remote.delay(
+                source_data=source_config["url"],
+                job_name=source_config["name"],
+                user=self.system_user_id,
+                loader=source_config.get("loader", "url"),
+            )
+
+            result = task.get(timeout=300)
+
+            if not task.successful():
+                raise Exception(f"Source ingestion failed: {result}")
+            source_id = None
+            if isinstance(result, dict) and "id" in result:
+                source_id = result["id"]
+            else:
+                raise Exception(f"Source ingestion result missing 'id': {result}")
+            self.logger.info(f"Source ingested successfully: {source_id}")
+            return source_id
+        except Exception as e:
+            self.logger.error(f"Failed to ingest source: {str(e)}")
+            return False
+
+    def _handle_tools(self, agent_config: Dict) -> List[ObjectId]:
+        """Handle tool creation and return list of tool IDs"""
+        tool_ids = []
+        if not agent_config.get("tools"):
+            return tool_ids
+        for tool_config in agent_config["tools"]:
+            try:
+                tool_name = tool_config["name"]
+                processed_config = self._process_config(tool_config.get("config", {}))
+                self.logger.info(f"Processing tool: {tool_name}")
+
+                existing = self.tools_collection.find_one(
+                    {
+                        "user": self.system_user_id,
+                        "name": tool_name,
+                        "config": processed_config,
+                    }
+                )
+                if existing:
+                    self.logger.info(f"Tool already exists: {existing['_id']}")
+                    tool_ids.append(existing["_id"])
+                    continue
+                tool_data = {
+                    "user": self.system_user_id,
+                    "name": tool_name,
+                    "displayName": tool_config.get("display_name", tool_name),
+                    "description": tool_config.get("description", ""),
+                    "actions": tool_manager.tools[tool_name].get_actions_metadata(),
+                    "config": processed_config,
+                    "status": True,
+                }
+
+                result = self.tools_collection.insert_one(tool_data)
+                tool_ids.append(result.inserted_id)
+                self.logger.info(f"Created new tool: {result.inserted_id}")
+            except Exception as e:
+                self.logger.error(f"Failed to process tool {tool_name}: {str(e)}")
+                continue
+        return tool_ids
+
+    def _handle_prompt(self, agent_config: Dict) -> Optional[str]:
+        """Handle prompt creation and return prompt ID"""
+        if not agent_config.get("prompt"):
+            return None
+
+        prompt_config = agent_config["prompt"]
+        prompt_name = prompt_config.get("name", f"{agent_config['name']} Prompt")
+        prompt_content = prompt_config.get("content", "")
+
+        if not prompt_content:
+            self.logger.warning(
+                f"No prompt content provided for agent {agent_config['name']}"
+            )
+            return None
+
+        self.logger.info(f"Processing prompt: {prompt_name}")
+
+        try:
+            existing = self.prompts_collection.find_one(
+                {
+                    "user": self.system_user_id,
+                    "name": prompt_name,
+                    "content": prompt_content,
+                }
+            )
+            if existing:
+                self.logger.info(f"Prompt already exists: {existing['_id']}")
+                return str(existing["_id"])
+
+            prompt_data = {
+                "name": prompt_name,
+                "content": prompt_content,
+                "user": self.system_user_id,
+            }
+
+            result = self.prompts_collection.insert_one(prompt_data)
+            prompt_id = str(result.inserted_id)
+            self.logger.info(f"Created new prompt: {prompt_id}")
+            return prompt_id
+
+        except Exception as e:
+            self.logger.error(f"Failed to process prompt {prompt_name}: {str(e)}")
+            return None
+
+    def _process_config(self, config: Dict) -> Dict:
+        """Process config values to replace environment variables"""
+        processed = {}
+        for key, value in config.items():
+            if (
+                isinstance(value, str)
+                and value.startswith("${")
+                and value.endswith("}")
+            ):
+                env_var = value[2:-1]
+                processed[key] = os.getenv(env_var, "")
+            else:
+                processed[key] = value
+        return processed
+
+    def _is_already_seeded(self) -> bool:
+        """Check if premade agents already exist"""
+        return self.agents_collection.count_documents({"user": self.system_user_id}) > 0
+
+    @classmethod
+    def initialize_from_env(cls, worker=None):
+        """Factory method to create seeder from environment"""
+        mongo_uri = os.getenv("MONGO_URI", "mongodb://localhost:27017")
+        db_name = os.getenv("MONGO_DB_NAME", "docsgpt")
+        client = MongoClient(mongo_uri)
+        db = client[db_name]
+        return cls(db)

application/templates/namespaces.py

@@ -0,0 +1,190 @@
+import logging
+import uuid
+from abc import ABC, abstractmethod
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class NamespaceBuilder(ABC):
+    """Base class for building template context namespaces"""
+
+    @abstractmethod
+    def build(self, **kwargs) -> Dict[str, Any]:
+        """Build namespace context dictionary"""
+        pass
+
+    @property
+    @abstractmethod
+    def namespace_name(self) -> str:
+        """Name of this namespace for template access"""
+        pass
+
+
+class SystemNamespace(NamespaceBuilder):
+    """System metadata namespace: {{ system.* }}"""
+
+    @property
+    def namespace_name(self) -> str:
+        return "system"
+
+    def build(
+        self, request_id: Optional[str] = None, user_id: Optional[str] = None, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Build system context with metadata.
+
+        Args:
+            request_id: Unique request identifier
+            user_id: Current user identifier
+
+        Returns:
+            Dictionary with system variables
+        """
+        now = datetime.now(timezone.utc)
+
+        return {
+            "date": now.strftime("%Y-%m-%d"),
+            "time": now.strftime("%H:%M:%S"),
+            "timestamp": now.isoformat(),
+            "request_id": request_id or str(uuid.uuid4()),
+            "user_id": user_id,
+        }
+
+
+class PassthroughNamespace(NamespaceBuilder):
+    """Request parameters namespace: {{ passthrough.* }}"""
+
+    @property
+    def namespace_name(self) -> str:
+        return "passthrough"
+
+    def build(
+        self, passthrough_data: Optional[Dict[str, Any]] = None, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Build passthrough context from request parameters.
+
+        Args:
+            passthrough_data: Dictionary of parameters from web request
+
+        Returns:
+            Dictionary with passthrough variables
+        """
+        if not passthrough_data:
+            return {}
+        safe_data = {}
+        for key, value in passthrough_data.items():
+            if isinstance(value, (str, int, float, bool, type(None))):
+                safe_data[key] = value
+            else:
+                logger.warning(
+                    f"Skipping non-serializable passthrough value for key '{key}': {type(value)}"
+                )
+        return safe_data
+
+
+class SourceNamespace(NamespaceBuilder):
+    """RAG source documents namespace: {{ source.* }}"""
+
+    @property
+    def namespace_name(self) -> str:
+        return "source"
+
+    def build(
+        self, docs: Optional[list] = None, docs_together: Optional[str] = None, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Build source context from RAG retrieval results.
+
+        Args:
+            docs: List of retrieved documents
+            docs_together: Concatenated document content (for backward compatibility)
+
+        Returns:
+            Dictionary with source variables
+        """
+        context = {}
+
+        if docs:
+            context["documents"] = docs
+            context["count"] = len(docs)
+        if docs_together:
+            context["docs_together"] = docs_together  # Add docs_together for custom templates
+            context["content"] = docs_together
+            context["summaries"] = docs_together
+        return context
+
+
+class ToolsNamespace(NamespaceBuilder):
+    """Pre-executed tools namespace: {{ tools.* }}"""
+
+    @property
+    def namespace_name(self) -> str:
+        return "tools"
+
+    def build(
+        self, tools_data: Optional[Dict[str, Any]] = None, **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Build tools context with pre-executed tool results.
+
+        Args:
+            tools_data: Dictionary of pre-fetched tool results organized by tool name
+                       e.g., {"memory": {"notes": "content", "tasks": "list"}}
+
+        Returns:
+            Dictionary with tool results organized by tool name
+        """
+        if not tools_data:
+            return {}
+
+        safe_data = {}
+        for tool_name, tool_result in tools_data.items():
+            if isinstance(tool_result, (str, dict, list, int, float, bool, type(None))):
+                safe_data[tool_name] = tool_result
+            else:
+                logger.warning(
+                    f"Skipping non-serializable tool result for '{tool_name}': {type(tool_result)}"
+                )
+        return safe_data
+
+
+class NamespaceManager:
+    """Manages all namespace builders and context assembly"""
+
+    def __init__(self):
+        self._builders = {
+            "system": SystemNamespace(),
+            "passthrough": PassthroughNamespace(),
+            "source": SourceNamespace(),
+            "tools": ToolsNamespace(),
+        }
+
+    def build_context(self, **kwargs) -> Dict[str, Any]:
+        """
+        Build complete template context from all namespaces.
+
+        Args:
+            **kwargs: Parameters to pass to namespace builders
+
+        Returns:
+            Complete context dictionary for template rendering
+        """
+        context = {}
+
+        for namespace_name, builder in self._builders.items():
+            try:
+                namespace_context = builder.build(**kwargs)
+                # Always include namespace, even if empty, to prevent undefined errors
+                context[namespace_name] = namespace_context if namespace_context else {}
+            except Exception as e:
+                logger.error(f"Failed to build {namespace_name} namespace: {str(e)}")
+                # Include empty namespace on error to prevent template failures
+                context[namespace_name] = {}
+        return context
+
+    def get_builder(self, namespace_name: str) -> Optional[NamespaceBuilder]:
+        """Get specific namespace builder"""
+        return self._builders.get(namespace_name)

application/templates/template_engine.py

@@ -0,0 +1,161 @@
+import logging
+from typing import Any, Dict, List, Optional, Set
+
+from jinja2 import (
+    ChainableUndefined,
+    Environment,
+    nodes,
+    select_autoescape,
+    TemplateSyntaxError,
+)
+from jinja2.exceptions import UndefinedError
+
+logger = logging.getLogger(__name__)
+
+
+class TemplateRenderError(Exception):
+    """Raised when template rendering fails"""
+
+    pass
+
+
+class TemplateEngine:
+    """Jinja2-based template engine for dynamic prompt rendering"""
+
+    def __init__(self):
+        self._env = Environment(
+            undefined=ChainableUndefined,
+            trim_blocks=True,
+            lstrip_blocks=True,
+            autoescape=select_autoescape(default_for_string=True, default=True),
+        )
+
+    def render(self, template_content: str, context: Dict[str, Any]) -> str:
+        """
+        Render template with provided context.
+
+        Args:
+            template_content: Raw template string with Jinja2 syntax
+            context: Dictionary of variables to inject into template
+
+        Returns:
+            Rendered template string
+
+        Raises:
+            TemplateRenderError: If template syntax is invalid or variables undefined
+        """
+        if not template_content:
+            return ""
+        try:
+            template = self._env.from_string(template_content)
+            return template.render(**context)
+        except TemplateSyntaxError as e:
+            error_msg = f"Template syntax error at line {e.lineno}: {e.message}"
+            logger.error(error_msg)
+            raise TemplateRenderError(error_msg) from e
+        except UndefinedError as e:
+            error_msg = f"Undefined variable in template: {e.message}"
+            logger.error(error_msg)
+            raise TemplateRenderError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Template rendering failed: {str(e)}"
+            logger.error(error_msg)
+            raise TemplateRenderError(error_msg) from e
+
+    def validate_template(self, template_content: str) -> bool:
+        """
+        Validate template syntax without rendering.
+
+        Args:
+            template_content: Template string to validate
+
+        Returns:
+            True if template is syntactically valid
+        """
+        if not template_content:
+            return True
+        try:
+            self._env.from_string(template_content)
+            return True
+        except TemplateSyntaxError as e:
+            logger.debug(f"Template syntax invalid at line {e.lineno}: {e.message}")
+            return False
+        except Exception as e:
+            logger.debug(f"Template validation error: {type(e).__name__}: {str(e)}")
+            return False
+
+    def extract_variables(self, template_content: str) -> Set[str]:
+        """
+        Extract all variable names from template.
+
+        Args:
+            template_content: Template string to analyze
+
+        Returns:
+            Set of variable names found in template
+        """
+        if not template_content:
+            return set()
+        try:
+            ast = self._env.parse(template_content)
+            return set(self._env.get_template_module(ast).make_module().keys())
+        except TemplateSyntaxError as e:
+            logger.debug(f"Cannot extract variables - syntax error at line {e.lineno}")
+            return set()
+        except Exception as e:
+            logger.debug(f"Cannot extract variables: {type(e).__name__}")
+            return set()
+
+    def extract_tool_usages(
+        self, template_content: str
+    ) -> Dict[str, Set[Optional[str]]]:
+        """Extract tool and action references from a template"""
+        if not template_content:
+            return {}
+        try:
+            ast = self._env.parse(template_content)
+        except TemplateSyntaxError as e:
+            logger.debug(f"extract_tool_usages - syntax error at line {e.lineno}")
+            return {}
+        except Exception as e:
+            logger.debug(f"extract_tool_usages - parse error: {type(e).__name__}")
+            return {}
+
+        usages: Dict[str, Set[Optional[str]]] = {}
+
+        def record(path: List[str]) -> None:
+            if not path:
+                return
+            tool_name = path[0]
+            action_name = path[1] if len(path) > 1 else None
+            if not tool_name:
+                return
+            tool_entry = usages.setdefault(tool_name, set())
+            tool_entry.add(action_name)
+
+        for node in ast.find_all(nodes.Getattr):
+            path = []
+            current = node
+            while isinstance(current, nodes.Getattr):
+                path.append(current.attr)
+                current = current.node
+            if isinstance(current, nodes.Name) and current.name == "tools":
+                path.reverse()
+                record(path)
+
+        for node in ast.find_all(nodes.Getitem):
+            path = []
+            current = node
+            while isinstance(current, nodes.Getitem):
+                key = current.arg
+                if isinstance(key, nodes.Const) and isinstance(key.value, str):
+                    path.append(key.value)
+                else:
+                    path = []
+                    break
+                current = current.node
+            if path and isinstance(current, nodes.Name) and current.name == "tools":
+                path.reverse()
+                record(path)
+
+        return usages

application/tts/elevenlabs.py

@@ -15,10 +15,11 @@ class ElevenlabsTTS(BaseTTS):
 
     def text_to_speech(self, text):
         lang = "en"
-        audio = self.client.generate(
+        audio = self.client.text_to_speech.convert(
+            voice_id="nPczCjzI2devNBz1zQrb",             
+            model_id="eleven_multilingual_v2",
             text=text,
-            model="eleven_multilingual_v2",
-            voice="Brian",
+            output_format="mp3_44100_128"
         )
         audio_data = BytesIO()
         for chunk in audio:

application/tts/tts_creator.py

@@ -0,0 +1,18 @@
+from application.tts.google_tts import GoogleTTS
+from application.tts.elevenlabs import ElevenlabsTTS
+from application.tts.base import BaseTTS
+
+
+
+class TTSCreator:
+    tts_providers = {
+        "google_tts": GoogleTTS,
+        "elevenlabs": ElevenlabsTTS,
+    }
+
+    @classmethod
+    def create_tts(cls, tts_type, *args, **kwargs)-> BaseTTS:
+        tts_class = cls.tts_providers.get(tts_type.lower())
+        if not tts_class:
+            raise ValueError(f"No tts class found for type {tts_type}")
+        return tts_class(*args, **kwargs)

application/utils.py

@@ -7,6 +7,8 @@ import tiktoken
 from flask import jsonify, make_response
 from werkzeug.utils import secure_filename
 
+from application.core.model_utils import get_token_limit
+
 from application.core.settings import settings
 
 
@@ -21,7 +23,7 @@ def get_encoding():
 
 
 def get_gpt_model() -> str:
-    """Get the appropriate GPT model based on provider"""
+    """Get GPT model based on provider"""
     model_map = {
         "openai": "gpt-4o-mini",
         "anthropic": "claude-2",
@@ -32,16 +34,7 @@ def get_gpt_model() -> str:
 
 
 def safe_filename(filename):
-    """
-    Creates a safe filename that preserves the original extension.
-    Uses secure_filename, but ensures a proper filename is returned even with non-Latin characters.
-
-    Args:
-        filename (str): The original filename
-
-    Returns:
-        str: A safe filename that can be used for storage
-    """
+    """Create safe filename, preserving extension. Handles non-Latin characters."""
     if not filename:
         return str(uuid.uuid4())
     _, extension = os.path.splitext(filename)
@@ -83,8 +76,23 @@ def count_tokens_docs(docs):
     return tokens
 
 
+def calculate_doc_token_budget(
+    model_id: str = "gpt-4o", history_token_limit: int = 2000
+) -> int:
+    total_context = get_token_limit(model_id)
+    reserved = sum(settings.RESERVED_TOKENS.values())
+    doc_budget = total_context - history_token_limit - reserved
+    return max(doc_budget, 1000)
+
+
+def get_missing_fields(data, required_fields):
+    """Check for missing required fields. Returns list of missing field names."""
+    return [field for field in required_fields if field not in data]
+
+
 def check_required_fields(data, required_fields):
-    missing_fields = [field for field in required_fields if field not in data]
+    """Validate required fields. Returns Flask 400 response if validation fails, None otherwise."""
+    missing_fields = get_missing_fields(data, required_fields)
     if missing_fields:
         return make_response(
             jsonify(
@@ -98,7 +106,8 @@ def check_required_fields(data, required_fields):
     return None
 
 
-def validate_required_fields(data, required_fields):
+def get_field_validation_errors(data, required_fields):
+    """Check for missing and empty fields. Returns dict with 'missing_fields' and 'empty_fields', or None."""
     missing_fields = []
     empty_fields = []
 
@@ -107,12 +116,24 @@ def validate_required_fields(data, required_fields):
             missing_fields.append(field)
         elif not data[field]:
             empty_fields.append(field)
-    errors = []
-    if missing_fields:
-        errors.append(f"Missing required fields: {', '.join(missing_fields)}")
-    if empty_fields:
-        errors.append(f"Empty values in required fields: {', '.join(empty_fields)}")
-    if errors:
+    if missing_fields or empty_fields:
+        return {"missing_fields": missing_fields, "empty_fields": empty_fields}
+    return None
+
+
+def validate_required_fields(data, required_fields):
+    """Validate required fields (must exist and be non-empty). Returns Flask 400 response if validation fails, None otherwise."""
+    errors_dict = get_field_validation_errors(data, required_fields)
+    if errors_dict:
+        errors = []
+        if errors_dict["missing_fields"]:
+            errors.append(
+                f"Missing required fields: {', '.join(errors_dict['missing_fields'])}"
+            )
+        if errors_dict["empty_fields"]:
+            errors.append(
+                f"Empty values in required fields: {', '.join(errors_dict['empty_fields'])}"
+            )
         return make_response(
             jsonify({"success": False, "message": " | ".join(errors)}), 400
         )
@@ -123,19 +144,13 @@ def get_hash(data):
     return hashlib.md5(data.encode(), usedforsecurity=False).hexdigest()
 
 
-def limit_chat_history(history, max_token_limit=None, gpt_model="docsgpt"):
-    """
-    Limits chat history based on token count.
-    Returns a list of messages that fit within the token limit.
-    """
-    from application.core.settings import settings
-
+def limit_chat_history(history, max_token_limit=None, model_id="docsgpt-local"):
+    """Limit chat history to fit within token limit."""
+    model_token_limit = get_token_limit(model_id)
     max_token_limit = (
         max_token_limit
-        if max_token_limit
-        and max_token_limit
-        < settings.LLM_TOKEN_LIMITS.get(gpt_model, settings.DEFAULT_MAX_HISTORY)
-        else settings.LLM_TOKEN_LIMITS.get(gpt_model, settings.DEFAULT_MAX_HISTORY)
+        if max_token_limit and max_token_limit < model_token_limit
+        else model_token_limit
     )
 
     if not history:
@@ -161,13 +176,17 @@ def limit_chat_history(history, max_token_limit=None, gpt_model="docsgpt"):
 
 
 def validate_function_name(function_name):
-    """Validates if a function name matches the allowed pattern."""
+    """Validate function name matches allowed pattern (alphanumeric, underscore, hyphen)."""
     if not re.match(r"^[a-zA-Z0-9_-]+$", function_name):
         return False
     return True
 
 
 def generate_image_url(image_path):
+    if isinstance(image_path, str) and (
+        image_path.startswith("http://") or image_path.startswith("https://")
+    ):
+        return image_path
     strategy = getattr(settings, "URL_STRATEGY", "backend")
     if strategy == "s3":
         bucket_name = getattr(settings, "S3_BUCKET_NAME", "docsgpt-test-bucket")
@@ -176,3 +195,69 @@ def generate_image_url(image_path):
     else:
         base_url = getattr(settings, "API_URL", "http://localhost:7091")
         return f"{base_url}/api/images/{image_path}"
+
+
+def calculate_compression_threshold(
+    model_id: str, threshold_percentage: float = 0.8
+) -> int:
+    """
+    Calculate token threshold for triggering compression.
+
+    Args:
+        model_id: Model identifier
+        threshold_percentage: Percentage of context window (default 80%)
+
+    Returns:
+        Token count threshold
+    """
+    total_context = get_token_limit(model_id)
+    threshold = int(total_context * threshold_percentage)
+    return threshold
+
+
+def clean_text_for_tts(text: str) -> str:
+    """
+    clean text for Text-to-Speech processing.
+    """
+    # Handle code blocks and links
+
+    text = re.sub(r"```mermaid[\s\S]*?```", " flowchart, ", text)  ## ```mermaid...```
+    text = re.sub(r"```[\s\S]*?```", " code block, ", text)  ## ```code```
+    text = re.sub(r"\[([^\]]+)\]\([^\)]+\)", r"\1", text)  ## [text](url)
+    text = re.sub(r"!\[([^\]]*)\]\([^\)]+\)", "", text)  ## ![alt](url)
+
+    # Remove markdown formatting
+
+    text = re.sub(r"`([^`]+)`", r"\1", text)  ## `code`
+    text = re.sub(r"\{([^}]*)\}", r" \1 ", text)  ## {text}
+    text = re.sub(r"[{}]", " ", text)  ## unmatched {}
+    text = re.sub(r"\[([^\]]+)\]", r" \1 ", text)  ## [text]
+    text = re.sub(r"[\[\]]", " ", text)  ## unmatched []
+    text = re.sub(r"(\*\*|__)(.*?)\1", r"\2", text)  ## **bold** __bold__
+    text = re.sub(r"(\*|_)(.*?)\1", r"\2", text)  ## *italic* _italic_
+    text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)  ## # headers
+    text = re.sub(r"^>\s+", "", text, flags=re.MULTILINE)  ## > blockquotes
+    text = re.sub(r"^[\s]*[-\*\+]\s+", "", text, flags=re.MULTILINE)  ## - * + lists
+    text = re.sub(r"^[\s]*\d+\.\s+", "", text, flags=re.MULTILINE)  ## 1. numbered lists
+    text = re.sub(
+        r"^[\*\-_]{3,}\s*$", "", text, flags=re.MULTILINE
+    )  ## --- *** ___ rules
+    text = re.sub(r"<[^>]*>", "", text)  ## <html> tags
+
+    # Remove non-ASCII (emojis, special Unicode)
+
+    text = re.sub(r"[^\x20-\x7E\n\r\t]", "", text)
+
+    # Replace special sequences
+
+    text = re.sub(r"-->", ", ", text)  ## -->
+    text = re.sub(r"<--", ", ", text)  ## <--
+    text = re.sub(r"=>", ", ", text)  ## =>
+    text = re.sub(r"::", " ", text)  ## ::
+
+    # Normalize whitespace
+
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+
+    return text

application/worker.py

@@ -39,6 +39,7 @@ sources_collection = db["sources"]
 
 # Constants
 
+
 MIN_TOKENS = 150
 MAX_TOKENS = 1250
 RECURSION_DEPTH = 2
@@ -164,7 +165,7 @@ def run_agent_logic(agent_config, input_data):
             agent_type,
             endpoint="webhook",
             llm_name=settings.LLM_PROVIDER,
-            gpt_model=settings.LLM_NAME,
+            model_id=settings.LLM_NAME,
             api_key=settings.API_KEY,
             user_api_key=user_api_key,
             prompt=prompt,
@@ -179,7 +180,7 @@ def run_agent_logic(agent_config, input_data):
             prompt=prompt,
             chunks=chunks,
             token_limit=settings.DEFAULT_MAX_HISTORY,
-            gpt_model=settings.LLM_NAME,
+            model_id=settings.LLM_NAME,
             user_api_key=user_api_key,
             decoded_token=decoded_token,
         )
@@ -740,7 +741,13 @@ def remote_worker(
         if os.path.exists(full_path):
             shutil.rmtree(full_path)
     logging.info("remote_worker task completed successfully")
-    return {"urls": source_data, "name_job": name_job, "user": user, "limited": False}
+    return {
+        "id": str(id),
+        "urls": source_data,
+        "name_job": name_job,
+        "user": user,
+        "limited": False,
+    }
 
 
 def sync(

deployment/docker-compose-hub.yaml

@@ -72,4 +72,4 @@ services:
       - mongodb_data_container:/data/db
 
 volumes:
-  mongodb_data_container:
+  mongodb_data_container:

docs/pages/Agents/basics.mdx

@@ -107,3 +107,13 @@ Once an agent is created, you can:
     * Modify any of its configuration settings (name, description, source, prompt, tools, type).
     * **Generate a Public Link:** From the edit screen, you can create a shareable public link that allows others to import and use your agent.
     * **Get a Webhook URL:** You can also obtain a Webhook URL for the agent. This allows external applications or services to trigger the agent and receive responses programmatically, enabling powerful integrations and automations.
+
+## Seeding Premade Agents from YAML
+
+You can bootstrap a fresh DocsGPT deployment with a curated set of agents by seeding them directly into MongoDB.
+
+1. **Customize the configuration** – edit `application/seed/config/premade_agents.yaml` (or copy from `application/seed/config/agents_template.yaml`) to describe the agents you want to provision. Each entry lets you define prompts, tools, and optional data sources.
+2. **Ensure dependencies are running** – MongoDB must be reachable using the credentials in `.env`, and a Celery worker should be available if any agent sources need to be ingested via `ingest_remote`.
+3. **Execute the seeder** – run `python -m application.seed.commands init`. Add `--force` when you need to reseed an existing environment.
+
+The seeder keeps templates under the `system` user so they appear in the UI for anyone to clone or customize. Environment variable placeholders such as `${MY_TOKEN}` inside tool configs are resolved during the seeding process.

docs/pages/Deploying/Development-Environment.mdx

@@ -42,7 +42,7 @@ To run the DocsGPT backend locally, you'll need to set up a Python environment a
 
     *   **Option 1: Using a `.env` file (Recommended):**
         *   If you haven't already, create a file named `.env` in the **root directory** of your DocsGPT project.
-        *   Modify the `.env` file to adjust settings as needed. You can find a comprehensive list of configurable options in [`application/core/settings.py`](application/core/settings.py).
+        *   Modify the `.env` file to adjust settings as needed. You can find a comprehensive list of configurable options in [`application/core/settings.py`](https://github.com/arc53/DocsGPT/blob/main/application/core/settings.py).
 
     *   **Option 2: Exporting Environment Variables:**
         *   Alternatively, you can export environment variables directly in your terminal. However, using a `.env` file is generally more organized for development.
@@ -67,7 +67,7 @@ To run the DocsGPT backend locally, you'll need to set up a Python environment a
 
 3.  **Download Embedding Model:**
 
-    The backend requires an embedding model. Download the `mpnet-base-v2` model and place it in the `model/` directory within the project root. You can use the following script:
+    The backend requires an embedding model. Download the `mpnet-base-v2` model and place it in the `models/` directory within the project root. You can use the following script:
 
     ```bash
     wget https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip
@@ -75,7 +75,7 @@ To run the DocsGPT backend locally, you'll need to set up a Python environment a
     rm mpnet-base-v2.zip
     ```
 
-    Alternatively, you can manually download the zip file from [here](https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip), unzip it, and place the extracted folder in `model/`.
+    Alternatively, you can manually download the zip file from [here](https://d3dg1063dc54p9.cloudfront.net/models/embeddings/mpnet-base-v2.zip), unzip it, and place the extracted folder in `models/`.
 
 4.  **Install Backend Dependencies:**
 
@@ -160,4 +160,4 @@ To run the DocsGPT frontend locally, you'll need Node.js and npm (Node Package M
 
     This command will start the Vite development server. The frontend application will typically be accessible at [http://localhost:5173/](http://localhost:5173/). The terminal will display the exact URL where the frontend is running.
 
-With both the backend and frontend running, you should now have a fully functional DocsGPT development environment. You can access the application in your browser at [http://localhost:5173/](http://localhost:5173/) and start developing!
+With both the backend and frontend running, you should now have a fully functional DocsGPT development environment. You can access the application in your browser at [http://localhost:5173/](http://localhost:5173/) and start developing!

docs/pages/Guides/Customising-prompts.mdx

@@ -1,49 +1,453 @@
 ---
-title: Customizing Prompts 
-description: This guide will explain how to change prompts in DocsGPT and why it might be benefitial. Additionaly this article expains additional variables that can be used in prompts.
+title: Customizing Prompts
+description: This guide explains how to customize prompts in DocsGPT using the new template-based system with dynamic variable injection.
 ---
 
 import Image from 'next/image'
 
-# Customizing the Main Prompt
+# Customizing Prompts in DocsGPT
 
-Customizing the main prompt for DocsGPT gives you the ability to tailor the AI's responses to your specific requirements. By modifying the prompt text, you can achieve more accurate and relevant answers. Here's how you can do it:
+Customizing prompts for DocsGPT gives you powerful control over the AI's behavior and responses. With the new template-based system, you can inject dynamic context through organized namespaces, making prompts flexible and maintainable without hardcoding values.
+
+## Quick Start
 
 1. Navigate to `SideBar -> Settings`.
-
-
-
-
-2.In Settings select the `Active Prompt` now you will be able to see various prompts style.x
-
-
-
-
-3.Click on the `edit icon`  on the prompt of your choice and you will be able to see the current prompt for it,you can now customise  the prompt as per your choice.
+2. In Settings, select the `Active Prompt` to see various prompt styles.
+3. Click on the `edit icon` on your chosen prompt to customize it.
 
 ### Video Demo
 <Image src="/prompts.gif" alt="prompts" width={800} height={500} />
 
+---
 
+## Template-Based Prompt System
 
-## Example Prompt Modification
+DocsGPT now uses **Jinja2 templating** with four organized namespaces for dynamic variable injection:
+
+### Available Namespaces
+
+#### 1. **`system`** - System Metadata
+Access system-level information:
+
+```jinja
+{{ system.date }}         # Current date (YYYY-MM-DD)
+{{ system.time }}         # Current time (HH:MM:SS)
+{{ system.timestamp }}    # ISO 8601 timestamp
+{{ system.request_id }}   # Unique request identifier
+{{ system.user_id }}      # Current user ID
+```
+
+#### 2. **`source`** - Retrieved Documents
+Access RAG (Retrieval-Augmented Generation) document context:
+
+```jinja
+{{ source.content }}      # Concatenated document content
+{{ source.summaries }}    # Alias for content (backward compatible)
+{{ source.documents }}    # List of document objects
+{{ source.count }}        # Number of retrieved documents
+```
+
+#### 3. **`passthrough`** - Request Parameters
+Access custom parameters passed in the API request:
+
+```jinja
+{{ passthrough.company }}     # Custom field from request
+{{ passthrough.user_name }}   # User-provided data
+{{ passthrough.context }}     # Any custom parameter
+```
+
+To use passthrough data, send it in your API request:
+```json
+{
+  "question": "What is the pricing?",
+  "passthrough": {
+    "company": "Acme Corp",
+    "user_name": "Alice",
+    "plan_type": "enterprise"
+  }
+}
+```
+
+#### 4. **`tools`** - Pre-fetched Tool Data
+Access results from tools that run before the agent (like memory tool):
+
+```jinja
+{{ tools.memory.root }}       # Memory tool directory listing
+{{ tools.memory.available }}  # Boolean: is memory available
+```
+
+---
+
+## Example Prompts
+
+### Basic Prompt with Documents
+```jinja
+You are a helpful AI assistant for DocsGPT.
+
+Current date: {{ system.date }}
+
+Use the following documents to answer the question:
+
+{{ source.content }}
+
+Provide accurate, helpful answers with code examples when relevant.
+```
+
+### Advanced Prompt with All Namespaces
+```jinja
+You are an AI assistant for {{ passthrough.company }}.
+
+**System Info:**
+- Date: {{ system.date }}
+- Request ID: {{ system.request_id }}
+
+**User Context:**
+- User: {{ passthrough.user_name }}
+- Role: {{ passthrough.role }}
+
+**Available Documents ({{ source.count }}):**
+{{ source.content }}
+
+**Memory Context:**
+{% if tools.memory.available %}
+{{ tools.memory.root }}
+{% else %}
+No saved context available.
+{% endif %}
+
+Please provide detailed, accurate answers based on the documents above.
+```
+
+### Conditional Logic Example
+```jinja
+You are a DocsGPT assistant.
+
+{% if source.count > 0 %}
+I found {{ source.count }} relevant document(s):
+
+{{ source.content }}
+
+Base your answer on these documents.
+{% else %}
+No documents were found. Please answer based on your general knowledge.
+{% endif %}
+```
+
+---
+
+## Migration Guide
+
+### Legacy Format (Still Supported)
+The old `{summaries}` format continues to work for backward compatibility:
 
-**Original Prompt:**
 ```markdown
-You are a DocsGPT, friendly and helpful AI assistant by Arc53 that provides help with documents. You give thorough answers with code examples if possible.
-Use the following pieces of context to help answer the users question. If it's not relevant to the question, provide friendly responses.
-You have access to chat history, and can use it to help answer the question.
-When using code examples, use the following format:
+You are a helpful assistant.
 
-(code)
+Documents:
 {summaries}
 ```
 
-Note that `{summaries}` allows model to see and respond to your upploaded documents. If you don't want this functionality you can safely remove it from the customized prompt.
+This will automatically substitute `{summaries}` with document content.
 
-Feel free to customize the prompt to align it with your specific use case or the kind of responses you want from the AI. For example, you can focus on specific document types, industries, or topics to get more targeted results.
+### New Template Format (Recommended)
+Migrate to the new template syntax for more flexibility:
+
+```jinja
+You are a helpful assistant.
+
+Documents:
+{{ source.content }}
+```
+
+**Migration mapping:**
+- `{summaries}` → `{{ source.content }}` or `{{ source.summaries }}`
+
+---
+
+## Best Practices
+
+### 1. **Use Descriptive Context**
+```jinja
+**Retrieved Documents:**
+{{ source.content }}
+
+**User Query Context:**
+- Company: {{ passthrough.company }}
+- Department: {{ passthrough.department }}
+```
+
+### 2. **Handle Missing Data Gracefully**
+```jinja
+{% if passthrough.user_name %}
+Hello {{ passthrough.user_name }}!
+{% endif %}
+```
+
+### 3. **Leverage Memory for Continuity**
+```jinja
+{% if tools.memory.available %}
+**Previous Context:**
+{{ tools.memory.root }}
+{% endif %}
+
+**Current Question:**
+Please consider the above context when answering.
+```
+
+### 4. **Add Clear Instructions**
+```jinja
+You are a technical support assistant.
+
+**Guidelines:**
+1. Always reference the documents below
+2. Provide step-by-step instructions
+3. Include code examples when relevant
+
+**Reference Documents:**
+{{ source.content }}
+```
+
+---
+
+## Advanced Features
+
+### Looping Over Documents
+```jinja
+{% for doc in source.documents %}
+**Source {{ loop.index }}:** {{ doc.filename }}
+{{ doc.text }}
+
+{% endfor %}
+```
+
+### Date-Based Behavior
+```jinja
+{% if system.date > "2025-01-01" %}
+Note: This is information from 2025 or later.
+{% endif %}
+```
+
+### Custom Formatting
+```jinja
+**Request Information**
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Request ID: {{ system.request_id }}
+• User: {{ passthrough.user_name | default("Guest") }}
+• Time: {{ system.time }}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+## Tool Pre-Fetching
+
+### Memory Tool Configuration
+Enable memory tool pre-fetching to inject saved context into prompts:
+
+```python
+# In your tool configuration
+{
+  "name": "memory",
+  "config": {
+    "pre_fetch_enabled": true  # Default: true
+  }
+}
+```
+
+Control pre-fetching globally:
+```bash
+# .env file
+ENABLE_TOOL_PREFETCH=true
+```
+
+Or per-request:
+```json
+{
+  "question": "What are the requirements?",
+  "disable_tool_prefetch": false
+}
+```
+
+---
+
+## Debugging Prompts
+
+### View Rendered Prompts in Logs
+Set log level to `INFO` to see the final rendered prompt sent to the LLM:
+
+```bash
+export LOG_LEVEL=INFO
+```
+
+You'll see output like:
+```
+INFO - Rendered system prompt for agent (length: 1234 chars):
+================================================================================
+You are a helpful assistant for Acme Corp.
+
+Current date: 2025-10-30
+Request ID: req_abc123
+
+Documents:
+Technical documentation about...
+================================================================================
+```
+
+### Template Validation
+Test your template syntax before saving:
+```python
+from application.api.answer.services.prompt_renderer import PromptRenderer
+
+renderer = PromptRenderer()
+is_valid = renderer.validate_template("Your prompt with {{ variables }}")
+```
+
+---
+
+## Common Use Cases
+
+### 1. Customer Support Bot
+```jinja
+You are a customer support assistant for {{ passthrough.company }}.
+
+**Customer:** {{ passthrough.customer_name }}
+**Ticket ID:** {{ system.request_id }}
+**Date:** {{ system.date }}
+
+**Knowledge Base:**
+{{ source.content }}
+
+**Previous Interactions:**
+{{ tools.memory.root }}
+
+Please provide helpful, friendly support based on the knowledge base above.
+```
+
+### 2. Technical Documentation Assistant
+```jinja
+You are a technical documentation expert.
+
+**Available Documentation ({{ source.count }} documents):**
+{{ source.content }}
+
+**Requirements:**
+- Provide code examples in {{ passthrough.language }}
+- Focus on {{ passthrough.framework }} best practices
+- Include relevant links when possible
+```
+
+### 3. Internal Knowledge Base
+```jinja
+You are an internal AI assistant for {{ passthrough.department }}.
+
+**Employee:** {{ passthrough.employee_name }}
+**Access Level:** {{ passthrough.access_level }}
+
+**Relevant Documents:**
+{{ source.content }}
+
+Provide detailed answers appropriate for {{ passthrough.access_level }} access level.
+```
+
+---
+
+## Template Syntax Reference
+
+### Variables
+```jinja
+{{ variable_name }}              # Output variable
+{{ namespace.field }}            # Access nested field
+{{ variable | default("N/A") }}  # Default value
+```
+
+### Conditionals
+```jinja
+{% if condition %}
+  Content
+{% elif other_condition %}
+  Other content
+{% else %}
+  Default content
+{% endif %}
+```
+
+### Loops
+```jinja
+{% for item in list %}
+  {{ item.field }}
+{% endfor %}
+```
+
+### Comments
+```jinja
+{# This is a comment and won't appear in output #}
+```
+
+---
+
+## Security Considerations
+
+1. **Input Sanitization**: Passthrough data is automatically sanitized to prevent injection attacks
+2. **Type Filtering**: Only primitive types (string, int, float, bool, None) are allowed in passthrough
+3. **Autoescaping**: Jinja2 autoescaping is enabled by default
+4. **Size Limits**: Consider the token budget when including large documents
+
+---
+
+## Troubleshooting
+
+### Problem: Variables Not Rendering
+**Solution:** Ensure you're using the correct namespace:
+```jinja
+❌ {{ company }}
+✅ {{ passthrough.company }}
+```
+
+### Problem: Empty Output for Tool Data
+**Solution:** Check that tool pre-fetching is enabled and the tool is configured correctly.
+
+### Problem: Syntax Errors
+**Solution:** Validate template syntax. Common issues:
+```jinja
+❌ {{ variable }     # Missing closing brace
+❌ {% if x %         # Missing closing %}
+✅ {{ variable }}
+✅ {% if x %}...{% endif %}
+```
+
+### Problem: Legacy Prompts Not Working
+**Solution:** The system auto-detects template syntax. If your prompt uses `{summaries}`, it will work in legacy mode. To use new features, add `{{ }}` syntax.
+
+---
+
+## API Reference
+
+### Render Prompt via API
+```python
+from application.api.answer.services.prompt_renderer import PromptRenderer
+
+renderer = PromptRenderer()
+rendered = renderer.render_prompt(
+    prompt_content="Your template with {{ passthrough.name }}",
+    user_id="user_123",
+    request_id="req_456",
+    passthrough_data={"name": "Alice"},
+    docs_together="Document content here",
+    tools_data={"memory": {"root": "Files: notes.txt"}}
+)
+```
+
+---
 
 ## Conclusion
 
-Customizing the main prompt for DocsGPT allows you to tailor the AI's responses to your unique requirements. Whether you need in-depth explanations, code examples, or specific insights, you can achieve it by modifying the main prompt. Remember to experiment and fine-tune your prompts to get the best results.
+The new template-based prompt system provides powerful flexibility while maintaining backward compatibility. By leveraging namespaces, you can create dynamic, context-aware prompts that adapt to your specific use case.
 
+**Key Benefits:**
+- ✅ Dynamic variable injection
+- ✅ Organized namespaces
+- ✅ Backward compatible
+- ✅ Security built-in
+- ✅ Easy to debug
+
+Start with simple templates and gradually add complexity as needed. Happy prompting! 🚀

docs/pages/quickstart.mdx

@@ -43,7 +43,8 @@ The easiest way to launch DocsGPT is using the provided `setup.sh` script. This
    2) Serve Local (with Ollama)
    3) Connect Local Inference Engine
    4) Connect Cloud API Provider
-   Choose option (1-4):
+   5) Advanced: Build images locally (for developers)
+   Choose option (1-5):
    ```
 
    Let's break down each option:
@@ -56,6 +57,8 @@ The easiest way to launch DocsGPT is using the provided `setup.sh` script. This
 
    * **4) Connect Cloud API Provider:** This option lets you connect DocsGPT to a commercial Cloud API provider such as OpenAI, Google (Vertex AI/Gemini), Anthropic (Claude), Groq, HuggingFace Inference API, or Azure OpenAI. You will need an API key from your chosen provider. Select this if you prefer to use a powerful cloud-based LLM.
 
+   * **5) Modify DocsGPT's source code and rebuild the Docker images locally.** Instead of pulling prebuilt images from Docker Hub or using the hosted/public API, you build the entire backend and frontend from source, customizing how DocsGPT works internally, or run it in an environment without internet access.
+
    After selecting an option and providing any required information (like API keys or model names), the script will configure your `.env` file and start DocsGPT using Docker Compose.
 
 4. **Access DocsGPT in your browser:**
@@ -116,4 +119,4 @@ If you prefer a more manual approach, you can follow our [Docker Deployment docu
 
 For more advanced customization of DocsGPT settings, such as configuring vector stores, embedding models, and other parameters, please refer to the [DocsGPT Settings documentation](/Deploying/DocsGPT-Settings). This guide explains how to modify the `.env` file or `settings.py` for deeper configuration.
 
-Enjoy using DocsGPT!
+Enjoy using DocsGPT!

frontend/.env.development

@@ -1,4 +1,6 @@
 # Please put appropriate value
 VITE_BASE_URL=http://localhost:5173
 VITE_API_HOST=http://127.0.0.1:7091
-VITE_API_STREAMING=true
+VITE_API_STREAMING=true
+VITE_NOTIFICATION_TEXT="What's new in 0.14.0 — Changelog"
+VITE_NOTIFICATION_LINK="https://blog.docsgpt.cloud/docsgpt-0-14-agents-automate-integrate-and-innovate/"

frontend/.eslintignore

@@ -1,17 +0,0 @@
-node_modules/
-dist/
-prettier.config.cjs
-.eslintrc.cjs
-env.d.ts
-public/
-assets/
-vite-env.d.ts
-.prettierignore
-package-lock.json
-package.json
-postcss.config.cjs
-prettier.config.cjs
-tailwind.config.cjs
-tsconfig.json
-tsconfig.node.json
-vite.config.ts

frontend/.eslintrc.cjs

@@ -1,45 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es2021: true,
-    node: true,
-  },
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:react/recommended',
-    'plugin:prettier/recommended',
-  ],
-  overrides: [],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-  },
-  plugins: ['react', 'unused-imports'],
-  rules: {
-    'react/prop-types': 'off',
-    'unused-imports/no-unused-imports': 'error',
-    'react/react-in-jsx-scope': 'off',
-    'prettier/prettier': [
-      'error',
-      {
-        endOfLine: 'auto',
-      },
-    ],
-  },
-  settings: {
-    'import/parsers': {
-      '@typescript-eslint/parser': ['.ts', '.tsx'],
-    },
-    react: {
-      version: 'detect',
-    },
-    'import/resolver': {
-      node: {
-        paths: ['src'],
-        extensions: ['.js', '.jsx', '.ts', '.tsx'],
-      },
-    },
-  },
-};

frontend/eslint.config.js

@@ -0,0 +1,78 @@
+import js from '@eslint/js'
+import tsParser from '@typescript-eslint/parser'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
+import react from 'eslint-plugin-react'
+import unusedImports from 'eslint-plugin-unused-imports'
+import prettier from 'eslint-plugin-prettier'
+import globals from 'globals'
+
+export default [
+  {
+    ignores: [
+      'node_modules/',
+      'dist/',
+      'prettier.config.cjs',
+      '.eslintrc.cjs',
+      'env.d.ts',
+      'public/',
+      'assets/',
+      'vite-env.d.ts',
+      '.prettierignore',
+      'package-lock.json',
+      'package.json',
+      'postcss.config.cjs',
+      'tailwind.config.cjs',
+      'tsconfig.json',
+      'tsconfig.node.json',
+      'vite.config.ts',
+    ],
+  },
+  {
+    files: ['**/*.{js,jsx,ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      parser: tsParser,
+      parserOptions: {
+        ecmaFeatures: {
+          jsx: true,
+        },
+      },
+      globals: {
+        ...globals.browser,
+        ...globals.es2021,
+        ...globals.node,
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      react,
+      'unused-imports': unusedImports,
+      prettier,
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...tsPlugin.configs.recommended.rules,
+      ...react.configs.recommended.rules,
+      ...prettier.configs.recommended.rules,
+      'react/prop-types': 'off',
+      'unused-imports/no-unused-imports': 'error',
+      'react/react-in-jsx-scope': 'off',
+      'no-undef': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': 'warn',
+      '@typescript-eslint/no-unused-expressions': 'warn',
+      'prettier/prettier': [
+        'error',
+        {
+          endOfLine: 'auto',
+        },
+      ],
+    },
+    settings: {
+      react: {
+        version: 'detect',
+      },
+    },
+  },
+]

frontend/package.json

@@ -19,21 +19,21 @@
     ]
   },
   "dependencies": {
-    "@reduxjs/toolkit": "^2.8.2",
+    "@reduxjs/toolkit": "^2.10.1",
     "chart.js": "^4.4.4",
     "clsx": "^2.1.1",
     "copy-to-clipboard": "^3.3.3",
     "i18next": "^25.5.3",
-    "i18next-browser-languagedetector": "^8.0.2",
+    "i18next-browser-languagedetector": "^8.2.0",
     "lodash": "^4.17.21",
-    "mermaid": "^11.6.0",
+    "mermaid": "^11.12.1",
     "prop-types": "^15.8.1",
     "react": "^19.1.0",
     "react-chartjs-2": "^5.3.0",
-    "react-dom": "^19.0.0",
+    "react-dom": "^19.1.1",
     "react-dropzone": "^14.3.8",
     "react-google-drive-picker": "^1.2.2",
-    "react-i18next": "^15.4.0",
+    "react-i18next": "^16.2.4",
     "react-markdown": "^9.0.1",
     "react-redux": "^9.2.0",
     "react-router-dom": "^7.6.1",
@@ -46,30 +46,28 @@
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.10",
     "@types/lodash": "^4.17.20",
-    "@types/mermaid": "^9.1.0",
     "@types/react": "^19.1.8",
-    "@types/react-dom": "^19.0.0",
+    "@types/react-dom": "^19.1.7",
     "@types/react-syntax-highlighter": "^15.5.13",
-    "@typescript-eslint/eslint-plugin": "^5.51.0",
-    "@typescript-eslint/parser": "^5.62.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.3",
+    "@typescript-eslint/parser": "^8.46.3",
     "@vitejs/plugin-react": "^4.3.4",
-    "eslint": "^8.57.1",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.5",
-    "eslint-config-standard-with-typescript": "^34.0.0",
     "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-n": "^15.7.0",
-    "eslint-plugin-prettier": "^5.2.1",
+    "eslint-plugin-n": "^17.23.1",
+    "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-promise": "^6.6.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-unused-imports": "^4.1.4",
-    "husky": "^8.0.0",
+    "husky": "^9.1.7",
     "lint-staged": "^15.3.0",
     "postcss": "^8.4.49",
     "prettier": "^3.5.3",
-    "prettier-plugin-tailwindcss": "^0.6.13",
+    "prettier-plugin-tailwindcss": "^0.7.1",
     "tailwindcss": "^4.1.11",
     "typescript": "^5.8.3",
-    "vite": "^6.3.5",
+    "vite": "^7.2.0",
     "vite-plugin-svgr": "^4.3.0"
   }
 }

frontend/public/toolIcons/tool_todo_list.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e3e3e3"><path d="M240-80q-33 0-56.5-23.5T160-160v-640q0-33 23.5-56.5T240-880h480q33 0 56.5 23.5T800-800v640q0 33-23.5 56.5T720-80H240Zm0-80h480v-640H240v640Zm88-104 56-56-56-56-56 56 56 56Zm0-160 56-56-56-56-56 56 56 56Zm0-160 56-56-56-56-56 56 56 56Zm120 280h232v-80H448v80Zm0-160h232v-80H448v80Zm0-160h232v-80H448v80ZM240-160v-640 640Z"/></svg>

frontend/src/App.tsx

@@ -15,6 +15,7 @@ import useTokenAuth from './hooks/useTokenAuth';
 import Navigation from './Navigation';
 import PageNotFound from './PageNotFound';
 import Setting from './settings';
+import Notification from './components/Notification';
 
 function AuthWrapper({ children }: { children: React.ReactNode }) {
   const { isAuthLoading } = useTokenAuth();
@@ -52,11 +53,27 @@ function MainLayout() {
 }
 export default function App() {
   const [, , componentMounted] = useDarkTheme();
+  const [showNotification, setShowNotification] = useState<boolean>(() => {
+    const saved = localStorage.getItem('showNotification');
+    return saved ? JSON.parse(saved) : true;
+  });
+  const notificationText = import.meta.env.VITE_NOTIFICATION_TEXT;
+  const notificationLink = import.meta.env.VITE_NOTIFICATION_LINK;
   if (!componentMounted) {
     return <div />;
   }
   return (
     <div className="relative h-full overflow-hidden">
+      {notificationLink && notificationText && showNotification && (
+        <Notification
+          notificationText={notificationText}
+          notificationLink={notificationLink}
+          handleCloseNotification={() => {
+            setShowNotification(false);
+            localStorage.setItem('showNotification', 'false');
+          }}
+        />
+      )}
       <Routes>
         <Route
           element={

frontend/src/Hero.tsx

@@ -1,6 +1,8 @@
-import DocsGPT3 from './assets/cute_docsgpt3.svg';
 import { useTranslation } from 'react-i18next';
 
+import DocsGPT3 from './assets/cute_docsgpt3.svg';
+import DropdownModel from './components/DropdownModel';
+
 export default function Hero({
   handleQuestion,
 }: {
@@ -26,6 +28,10 @@ export default function Hero({
           <span className="text-4xl font-semibold">DocsGPT</span>
           <img className="mb-1 inline w-14" src={DocsGPT3} alt="docsgpt" />
         </div>
+        {/* Model Selector */}
+        <div className="relative w-72">
+          <DropdownModel />
+        </div>
       </div>
 
       {/* Demo Buttons Section */}
@@ -38,7 +44,7 @@ export default function Hero({
                 <button
                   key={key}
                   onClick={() => handleQuestion({ question: demo.query })}
-                  className={`border-dark-gray text-just-black hover:bg-cultured dark:border-dim-gray dark:text-chinese-white dark:hover:bg-charleston-green w-full rounded-[66px] border bg-transparent px-6 py-[14px] text-left transition-colors ${key >= 2 ? 'hidden md:block' : ''} // Show only 2 buttons on mobile`}
+                  className={`border-dark-gray text-just-black hover:bg-cultured dark:border-dim-gray dark:text-chinese-white dark:hover:bg-charleston-green w-full rounded-[66px] border bg-transparent px-6 py-[14px] text-left transition-colors ${key >= 2 ? 'hidden md:block' : ''}`}
                 >
                   <p className="text-black-1000 dark:text-bright-gray mb-2 font-semibold">
                     {demo.header}

frontend/src/Navigation.tsx

@@ -9,7 +9,8 @@ import userService from './api/services/userService';
 import Add from './assets/add.svg';
 import DocsGPT3 from './assets/cute_docsgpt3.svg';
 import Discord from './assets/discord.svg';
-import Expand from './assets/expand.svg';
+import PanelLeftClose from './assets/panel-left-close.svg';
+import PanelLeftOpen from './assets/panel-left-open.svg';
 import Github from './assets/git_nav.svg';
 import Hamburger from './assets/hamburger.svg';
 import openNewChat from './assets/openNewChat.svg';
@@ -302,18 +303,20 @@ export default function Navigation({ navOpen, setNavOpen }: NavigationProps) {
       {
         <div className="absolute top-3 left-3 z-20 hidden transition-all duration-300 ease-in-out lg:block">
           <div className="flex items-center gap-3">
-            <button
-              onClick={() => {
-                setNavOpen(!navOpen);
-              }}
-              className="transition-transform duration-200 hover:scale-110"
-            >
-              <img
-                src={Expand}
-                alt="Toggle navigation menu"
-                className="m-auto transition-all duration-300 ease-in-out"
-              />
-            </button>
+            {!navOpen && (
+              <button
+                onClick={() => {
+                  setNavOpen(!navOpen);
+                }}
+                className="transition-transform duration-200 hover:scale-110"
+              >
+                <img
+                  src={PanelLeftOpen}
+                  alt="Open navigation menu"
+                  className="m-auto transition-all duration-300 ease-in-out"
+                />
+              </button>
+            )}
             {queries?.length > 0 && (
               <button
                 onClick={() => {
@@ -363,8 +366,8 @@ export default function Navigation({ navOpen, setNavOpen }: NavigationProps) {
             }}
           >
             <img
-              src={Expand}
-              alt="Toggle navigation menu"
+              src={navOpen ? PanelLeftClose : PanelLeftOpen}
+              alt={navOpen ? 'Collapse sidebar' : 'Expand sidebar'}
               className="m-auto transition-all duration-300 ease-in-out hover:scale-110"
             />
           </button>
@@ -399,7 +402,7 @@ export default function Navigation({ navOpen, setNavOpen }: NavigationProps) {
           {conversations?.loading && !isDeletingConversation && (
             <div className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 transform">
               <img
-                src={isDarkTheme ? SpinnerDark : Spinner}
+                src={isDarkTheme ? Spinner : SpinnerDark}
                 className="animate-spin cursor-pointer bg-transparent"
                 alt="Loading conversations"
               />
@@ -408,7 +411,9 @@ export default function Navigation({ navOpen, setNavOpen }: NavigationProps) {
           {recentAgents?.length > 0 ? (
             <div>
               <div className="mx-4 my-auto mt-2 flex h-6 items-center">
-                <p className="mt-1 ml-4 text-sm font-semibold">Agents</p>
+                <p className="mt-1 ml-4 text-sm font-semibold">
+                  {t('navigation.agents')}
+                </p>
               </div>
               <div className="agents-container">
                 <div>
@@ -562,7 +567,7 @@ export default function Navigation({ navOpen, setNavOpen }: NavigationProps) {
               <div className="flex items-center gap-1 pr-4">
                 <NavLink
                   target="_blank"
-                  to={'https://discord.gg/WHJdfbQDR4'}
+                  to={'https://discord.gg/vN7YFfdMpj'}
                   className={
                     'rounded-full hover:bg-gray-100 dark:hover:bg-[#28292E]'
                   }

frontend/src/PageNotFound.tsx

@@ -1,13 +1,16 @@
 import { Link } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
 
 export default function PageNotFound() {
+  const { t } = useTranslation();
+
   return (
     <div className="dark:bg-raisin-black grid min-h-screen">
       <p className="text-jet dark:bg-outer-space mx-auto my-auto mt-20 flex w-full max-w-6xl flex-col place-items-center gap-6 rounded-3xl bg-gray-100 p-6 lg:p-10 xl:p-16 dark:text-gray-100">
-        <h1>404</h1>
-        <p>The page you are looking for does not exist.</p>
+        <h1>{t('pageNotFound.title')}</h1>
+        <p>{t('pageNotFound.message')}</p>
         <button className="pointer-cursor bg-blue-1000 hover:bg-blue-3000 mr-4 flex cursor-pointer items-center justify-center rounded-full px-4 py-2 text-white transition-colors duration-100">
-          <Link to="/">Go Back Home</Link>
+          <Link to="/">{t('pageNotFound.goHome')}</Link>
         </button>
       </p>
     </div>

frontend/src/agents/AgentCard.tsx

@@ -1,14 +1,22 @@
-import { useRef, useState } from 'react';
+import { SyntheticEvent, useRef, useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { useNavigate } from 'react-router-dom';
 
 import userService from '../api/services/userService';
-import AgentImage from '../components/AgentImage';
+import Duplicate from '../assets/duplicate.svg';
+import Edit from '../assets/edit.svg';
+import Link from '../assets/link-gray.svg';
+import Monitoring from '../assets/monitoring.svg';
+import Pin from '../assets/pin.svg';
+import Trash from '../assets/red-trash.svg';
 import ThreeDots from '../assets/three-dots.svg';
+import UnPin from '../assets/unpin.svg';
+import AgentImage from '../components/AgentImage';
 import ContextMenu, { MenuOption } from '../components/ContextMenu';
 import ConfirmationModal from '../modals/ConfirmationModal';
 import { ActiveState } from '../models/misc';
 import {
+  selectAgents,
   selectToken,
   setAgents,
   setSelectedAgent,
@@ -18,46 +26,205 @@ import { Agent } from './types';
 type AgentCardProps = {
   agent: Agent;
   agents: Agent[];
-  menuOptions?: MenuOption[];
-  onDelete?: (agentId: string) => void;
+  updateAgents?: (agents: Agent[]) => void;
+  section: string;
 };
 
 export default function AgentCard({
   agent,
   agents,
-  menuOptions,
-  onDelete,
+  updateAgents,
+  section,
 }: AgentCardProps) {
   const navigate = useNavigate();
   const dispatch = useDispatch();
   const token = useSelector(selectToken);
+  const userAgents = useSelector(selectAgents);
 
-  const [isMenuOpen, setIsMenuOpen] = useState(false);
+  const [isMenuOpen, setIsMenuOpen] = useState<boolean>(false);
   const [deleteConfirmation, setDeleteConfirmation] =
     useState<ActiveState>('INACTIVE');
 
   const menuRef = useRef<HTMLDivElement>(null);
 
-  const handleCardClick = () => {
-    if (agent.status === 'published') {
-      dispatch(setSelectedAgent(agent));
-      navigate('/');
+  const menuOptionsConfig: Record<string, MenuOption[]> = {
+    template: [
+      {
+        icon: Duplicate,
+        label: 'Duplicate',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          handleDuplicate();
+        },
+        variant: 'primary',
+        iconWidth: 18,
+        iconHeight: 18,
+      },
+    ],
+    user: [
+      {
+        icon: Monitoring,
+        label: 'Logs',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          navigate(`/agents/logs/${agent.id}`);
+        },
+        variant: 'primary',
+        iconWidth: 14,
+        iconHeight: 14,
+      },
+      {
+        icon: Edit,
+        label: 'Edit',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          navigate(`/agents/edit/${agent.id}`);
+        },
+        variant: 'primary',
+        iconWidth: 14,
+        iconHeight: 14,
+      },
+      ...(agent.status === 'published'
+        ? [
+            {
+              icon: agent.pinned ? UnPin : Pin,
+              label: agent.pinned ? 'Unpin' : 'Pin agent',
+              onClick: (e: SyntheticEvent) => {
+                e.stopPropagation();
+                togglePin();
+              },
+              variant: 'primary' as const,
+              iconWidth: 18,
+              iconHeight: 18,
+            },
+          ]
+        : []),
+      {
+        icon: Trash,
+        label: 'Delete',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          setDeleteConfirmation('ACTIVE');
+        },
+        variant: 'danger',
+        iconWidth: 13,
+        iconHeight: 13,
+      },
+    ],
+    shared: [
+      {
+        icon: Link,
+        label: 'Open',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          navigate(`/agents/shared/${agent.shared_token}`);
+        },
+        variant: 'primary',
+        iconWidth: 12,
+        iconHeight: 12,
+      },
+      {
+        icon: agent.pinned ? UnPin : Pin,
+        label: agent.pinned ? 'Unpin' : 'Pin agent',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          togglePin();
+        },
+        variant: 'primary',
+        iconWidth: 18,
+        iconHeight: 18,
+      },
+      {
+        icon: Trash,
+        label: 'Remove',
+        onClick: (e: SyntheticEvent) => {
+          e.stopPropagation();
+          handleHideSharedAgent();
+        },
+        variant: 'danger',
+        iconWidth: 13,
+        iconHeight: 13,
+      },
+    ],
+  };
+  const menuOptions = menuOptionsConfig[section] || [];
+
+  const handleClick = () => {
+    if (section === 'user') {
+      if (agent.status === 'published') {
+        dispatch(setSelectedAgent(agent));
+        navigate(`/`);
+      }
+    }
+    if (section === 'shared') {
+      navigate(`/agents/shared/${agent.shared_token}`);
     }
   };
 
-  const defaultDelete = async (agentId: string) => {
-    const response = await userService.deleteAgent(agentId, token);
-    if (!response.ok) throw new Error('Failed to delete agent');
-    const data = await response.json();
-    dispatch(setAgents(agents.filter((prevAgent) => prevAgent.id !== data.id)));
+  const togglePin = async () => {
+    try {
+      const response = await userService.togglePinAgent(agent.id ?? '', token);
+      if (!response.ok) throw new Error('Failed to pin agent');
+      const updatedAgents = agents.map((prevAgent) => {
+        if (prevAgent.id === agent.id)
+          return { ...prevAgent, pinned: !prevAgent.pinned };
+        return prevAgent;
+      });
+      updateAgents?.(updatedAgents);
+    } catch (error) {
+      console.error('Error:', error);
+    }
   };
 
+  const handleHideSharedAgent = async () => {
+    try {
+      const response = await userService.removeSharedAgent(
+        agent.id ?? '',
+        token,
+      );
+      if (!response.ok) throw new Error('Failed to hide shared agent');
+      const updatedAgents = agents.filter(
+        (prevAgent) => prevAgent.id !== agent.id,
+      );
+      updateAgents?.(updatedAgents);
+    } catch (error) {
+      console.error('Error:', error);
+    }
+  };
+
+  const handleDelete = async () => {
+    try {
+      const response = await userService.deleteAgent(agent.id ?? '', token);
+      if (!response.ok) throw new Error('Failed to delete agent');
+      const updatedAgents = agents.filter(
+        (prevAgent) => prevAgent.id !== agent.id,
+      );
+      updateAgents?.(updatedAgents);
+    } catch (error) {
+      console.error('Error:', error);
+    }
+  };
+
+  const handleDuplicate = async () => {
+    try {
+      const response = await userService.adoptAgent(agent.id ?? '', token);
+      if (!response.ok) throw new Error('Failed to duplicate agent');
+      const data = await response.json();
+      if (userAgents) {
+        const updatedAgents = [...userAgents, data.agent];
+        dispatch(setAgents(updatedAgents));
+      } else dispatch(setAgents([data.agent]));
+    } catch (error) {
+      console.error('Error:', error);
+    }
+  };
   return (
     <div
-      className={`relative flex h-44 w-48 flex-col justify-between rounded-[1.2rem] bg-[#F6F6F6] px-6 py-5 hover:bg-[#ECECEC] dark:bg-[#383838] dark:hover:bg-[#383838]/80 ${
-        agent.status === 'published' ? 'cursor-pointer' : ''
-      }`}
-      onClick={handleCardClick}
+      className={`relative flex h-44 w-full flex-col justify-between rounded-[1.2rem] bg-[#F6F6F6] px-6 py-5 hover:bg-[#ECECEC] md:w-48 dark:bg-[#383838] dark:hover:bg-[#383838]/80 ${agent.status === 'published' && 'cursor-pointer'}`}
+      onClick={(e) => {
+        e.stopPropagation();
+        handleClick();
+      }}
     >
       <div
         ref={menuRef}
@@ -67,19 +234,16 @@ export default function AgentCard({
         }}
         className="absolute top-4 right-4 z-10 cursor-pointer"
       >
-        <img src={ThreeDots} alt="options" className="h-[19px] w-[19px]" />
-        {menuOptions && (
-          <ContextMenu
-            isOpen={isMenuOpen}
-            setIsOpen={setIsMenuOpen}
-            options={menuOptions}
-            anchorRef={menuRef}
-            position="top-right"
-            offset={{ x: 0, y: 0 }}
-          />
-        )}
+        <img src={ThreeDots} alt={'use-agent'} className="h-[19px] w-[19px]" />
+        <ContextMenu
+          isOpen={isMenuOpen}
+          setIsOpen={setIsMenuOpen}
+          options={menuOptions}
+          anchorRef={menuRef}
+          position="bottom-right"
+          offset={{ x: 0, y: 0 }}
+        />
       </div>
-
       <div className="w-full">
         <div className="flex w-full items-center gap-1 px-1">
           <AgentImage
@@ -88,9 +252,7 @@ export default function AgentCard({
             className="h-7 w-7 rounded-full object-contain"
           />
           {agent.status === 'draft' && (
-            <p className="text-xs text-black opacity-50 dark:text-[#E0E0E0]">
-              (Draft)
-            </p>
+            <p className="text-xs text-black opacity-50 dark:text-[#E0E0E0]">{`(Draft)`}</p>
           )}
         </div>
         <div className="mt-2">
@@ -105,14 +267,13 @@ export default function AgentCard({
           </p>
         </div>
       </div>
-
       <ConfirmationModal
         message="Are you sure you want to delete this agent?"
         modalState={deleteConfirmation}
         setModalState={setDeleteConfirmation}
         submitLabel="Delete"
         handleSubmit={() => {
-          onDelete ? onDelete(agent.id || '') : defaultDelete(agent.id || '');
+          handleDelete();
           setDeleteConfirmation('INACTIVE');
         }}
         cancelLabel="Cancel"

frontend/src/agents/AgentLogs.tsx

@@ -1,4 +1,5 @@
 import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
 import { useSelector } from 'react-redux';
 import { useNavigate, useParams } from 'react-router-dom';
 
@@ -11,6 +12,7 @@ import Logs from '../settings/Logs';
 import { Agent } from './types';
 
 export default function AgentLogs() {
+  const { t } = useTranslation();
   const navigate = useNavigate();
   const { agentId } = useParams();
   const token = useSelector(selectToken);
@@ -45,12 +47,12 @@ export default function AgentLogs() {
           <img src={ArrowLeft} alt="left-arrow" className="h-3 w-3" />
         </button>
         <p className="text-eerie-black dark:text-bright-gray mt-px text-sm font-semibold">
-          Back to all agents
+          {t('agents.backToAll')}
         </p>
       </div>
       <div className="mt-5 flex w-full flex-wrap items-center justify-between gap-2 px-4">
         <h1 className="text-eerie-black m-0 text-[32px] font-bold md:text-[40px] dark:text-white">
-          Agent Logs
+          {t('agents.logs.title')}
         </h1>
       </div>
       <div className="mt-6 flex flex-col gap-3 px-4">
@@ -59,9 +61,10 @@ export default function AgentLogs() {
             <p className="text-[#28292E] dark:text-[#E0E0E0]">{agent.name}</p>
             <p className="text-xs text-[#28292E] dark:text-[#E0E0E0]/40">
               {agent.last_used_at
-                ? 'Last used at ' +
+                ? t('agents.logs.lastUsedAt') +
+                  ' ' +
                   new Date(agent.last_used_at).toLocaleString()
-                : 'No usage history'}
+                : t('agents.logs.noUsageHistory')}
             </p>
           </div>
         )}
@@ -79,7 +82,9 @@ export default function AgentLogs() {
           <Spinner />
         </div>
       ) : (
-        agent && <Logs agentId={agent.id} tableHeader="Agent endpoint logs" />
+        agent && (
+          <Logs agentId={agent.id} tableHeader={t('agents.logs.tableHeader')} />
+        )
       )}
     </div>
   );

frontend/src/agents/AgentPreview.tsx

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
 import { useDispatch, useSelector } from 'react-redux';
 
 import MessageInput from '../components/MessageInput';
@@ -17,6 +18,7 @@ import { selectSelectedAgent } from '../preferences/preferenceSlice';
 import { AppDispatch } from '../store';
 
 export default function AgentPreview() {
+  const { t } = useTranslation();
   const dispatch = useDispatch<AppDispatch>();
 
   const queries = useSelector(selectPreviewQueries);
@@ -109,18 +111,18 @@ export default function AgentPreview() {
     } else setLastQueryReturnedErr(false);
   }, [queries]);
   return (
-    <div>
-      <div className="dark:bg-raisin-black flex h-full flex-col items-center justify-between gap-2 overflow-y-hidden">
-        <div className="h-[512px] w-full overflow-y-auto">
-          <ConversationMessages
-            handleQuestion={handleQuestion}
-            handleQuestionSubmission={handleQuestionSubmission}
-            queries={queries}
-            status={status}
-            showHeroOnEmpty={false}
-          />
-        </div>
-        <div className="flex w-[95%] max-w-[1500px] flex-col items-center gap-4 pb-2 md:w-9/12 lg:w-8/12 xl:w-8/12 2xl:w-6/12">
+    <div className="relative h-full w-full">
+      <div className="scrollbar-thin absolute inset-0 bottom-[180px] overflow-hidden px-4 pt-4 [&>div>div]:!w-full [&>div>div]:!max-w-none">
+        <ConversationMessages
+          handleQuestion={handleQuestion}
+          handleQuestionSubmission={handleQuestionSubmission}
+          queries={queries}
+          status={status}
+          showHeroOnEmpty={false}
+        />
+      </div>
+      <div className="absolute right-0 bottom-0 left-0 flex w-full flex-col gap-4 pb-2">
+        <div className="w-full px-4">
           <MessageInput
             onSubmit={(text) => handleQuestionSubmission(text)}
             loading={status === 'loading'}
@@ -128,11 +130,10 @@ export default function AgentPreview() {
             showToolButton={selectedAgent ? false : true}
             autoFocus={false}
           />
-          <p className="text-gray-4000 dark:text-sonic-silver w-full self-center bg-transparent pt-2 text-center text-xs md:inline">
-            This is a preview of the agent. You can publish it to start using it
-            in conversations.
-          </p>
         </div>
+        <p className="text-gray-4000 dark:text-sonic-silver w-full bg-transparent text-center text-xs md:inline">
+          {t('agents.preview.testMessage')}
+        </p>
       </div>
     </div>
   );

frontend/src/agents/AgentsList.tsx

@@ -0,0 +1,138 @@
+import { useEffect, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useDispatch, useSelector } from 'react-redux';
+import { useNavigate } from 'react-router-dom';
+
+import Spinner from '../components/Spinner';
+import {
+  setConversation,
+  updateConversationId,
+} from '../conversation/conversationSlice';
+import {
+  selectSelectedAgent,
+  selectToken,
+  setSelectedAgent,
+} from '../preferences/preferenceSlice';
+import AgentCard from './AgentCard';
+import { agentSectionsConfig } from './agents.config';
+import { Agent } from './types';
+
+export default function AgentsList() {
+  const { t } = useTranslation();
+  const dispatch = useDispatch();
+  const token = useSelector(selectToken);
+  const selectedAgent = useSelector(selectSelectedAgent);
+
+  useEffect(() => {
+    dispatch(setConversation([]));
+    dispatch(
+      updateConversationId({
+        query: { conversationId: null },
+      }),
+    );
+    if (selectedAgent) dispatch(setSelectedAgent(null));
+  }, [token]);
+  return (
+    <div className="p-4 md:p-12">
+      <h1 className="text-eerie-black mb-0 text-[32px] font-bold lg:text-[40px] dark:text-[#E0E0E0]">
+        {t('agents.title')}
+      </h1>
+      <p className="dark:text-gray-4000 mt-5 text-[15px] text-[#71717A]">
+        {t('agents.description')}
+      </p>
+      {agentSectionsConfig.map((sectionConfig) => (
+        <AgentSection key={sectionConfig.id} config={sectionConfig} />
+      ))}
+    </div>
+  );
+}
+
+function AgentSection({
+  config,
+}: {
+  config: (typeof agentSectionsConfig)[number];
+}) {
+  const { t } = useTranslation();
+  const navigate = useNavigate();
+  const dispatch = useDispatch();
+  const token = useSelector(selectToken);
+  const agents = useSelector(config.selectData);
+
+  const [loading, setLoading] = useState(true);
+
+  const updateAgents = (updatedAgents: Agent[]) => {
+    dispatch(config.updateAction(updatedAgents));
+  };
+
+  useEffect(() => {
+    const getAgents = async () => {
+      setLoading(true);
+      try {
+        const response = await config.fetchAgents(token);
+        if (!response.ok)
+          throw new Error(`Failed to fetch ${config.id} agents`);
+        const data = await response.json();
+        dispatch(config.updateAction(data));
+      } catch (error) {
+        console.error(`Error fetching ${config.id} agents:`, error);
+        dispatch(config.updateAction([]));
+      } finally {
+        setLoading(false);
+      }
+    };
+    getAgents();
+  }, [token, config, dispatch]);
+  return (
+    <div className="mt-8 flex flex-col gap-4">
+      <div className="flex w-full items-center justify-between">
+        <div className="flex flex-col gap-2">
+          <h2 className="text-[18px] font-semibold text-[#18181B] dark:text-[#E0E0E0]">
+            {t(`agents.sections.${config.id}.title`)}
+          </h2>
+          <p className="text-[13px] text-[#71717A]">
+            {t(`agents.sections.${config.id}.description`)}
+          </p>
+        </div>
+        {config.showNewAgentButton && (
+          <button
+            className="bg-purple-30 hover:bg-violets-are-blue rounded-full px-4 py-2 text-sm text-white"
+            onClick={() => navigate('/agents/new')}
+          >
+            {t('agents.newAgent')}
+          </button>
+        )}
+      </div>
+      <div>
+        {loading ? (
+          <div className="flex h-72 w-full items-center justify-center">
+            <Spinner />
+          </div>
+        ) : agents && agents.length > 0 ? (
+          <div className="grid grid-cols-1 gap-4 sm:flex sm:flex-wrap">
+            {agents.map((agent) => (
+              <AgentCard
+                key={agent.id}
+                agent={agent}
+                agents={agents}
+                updateAgents={updateAgents}
+                section={config.id}
+              />
+            ))}
+          </div>
+        ) : (
+          <div className="flex h-72 w-full flex-col items-center justify-center gap-3 text-base text-[#18181B] dark:text-[#E0E0E0]">
+            <p>{t(`agents.sections.${config.id}.emptyState`)}</p>
+            {config.showNewAgentButton && (
+              <button
+                className="bg-purple-30 hover:bg-violets-are-blue ml-2 rounded-full px-4 py-2 text-sm text-white"
+                onClick={() => navigate('/agents/new')}
+              >
+                {t('agents.newAgent')}
+              </button>
+            )}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

frontend/src/agents/NewAgent.tsx

@@ -1,8 +1,10 @@
 import isEqual from 'lodash/isEqual';
 import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { useTranslation } from 'react-i18next';
 import { useDispatch, useSelector } from 'react-redux';
 import { useNavigate, useParams } from 'react-router-dom';
 
+import modelService from '../api/services/modelService';
 import userService from '../api/services/userService';
 import ArrowLeft from '../assets/arrow-left.svg';
 import SourceIcon from '../assets/source.svg';
@@ -23,13 +25,15 @@ import PromptsModal from '../preferences/PromptsModal';
 import Prompts from '../settings/Prompts';
 import { UserToolType } from '../settings/types';
 import AgentPreview from './AgentPreview';
-import { Agent } from './types';
+import { Agent, ToolSummary } from './types';
 
+import type { Model } from '../models/types';
 const embeddingsName =
   import.meta.env.VITE_EMBEDDINGS_NAME ||
   'huggingface_sentence-transformers/all-mpnet-base-v2';
 
 export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
+  const { t } = useTranslation();
   const navigate = useNavigate();
   const dispatch = useDispatch();
   const { agentId } = useParams();
@@ -53,18 +57,27 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
     agent_type: 'classic',
     status: '',
     json_schema: undefined,
+    limited_token_mode: false,
+    token_limit: undefined,
+    limited_request_mode: false,
+    request_limit: undefined,
+    models: [],
+    default_model_id: '',
   });
   const [imageFile, setImageFile] = useState<File | null>(null);
   const [prompts, setPrompts] = useState<
     { name: string; id: string; type: string }[]
   >([]);
   const [userTools, setUserTools] = useState<OptionType[]>([]);
+  const [availableModels, setAvailableModels] = useState<Model[]>([]);
   const [isSourcePopupOpen, setIsSourcePopupOpen] = useState(false);
   const [isToolsPopupOpen, setIsToolsPopupOpen] = useState(false);
+  const [isModelsPopupOpen, setIsModelsPopupOpen] = useState(false);
   const [selectedSourceIds, setSelectedSourceIds] = useState<
     Set<string | number>
   >(new Set());
-  const [selectedToolIds, setSelectedToolIds] = useState<Set<string | number>>(
+  const [selectedTools, setSelectedTools] = useState<ToolSummary[]>([]);
+  const [selectedModelIds, setSelectedModelIds] = useState<Set<string>>(
     new Set(),
   );
   const [deleteConfirmation, setDeleteConfirmation] =
@@ -76,16 +89,18 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
   const [publishLoading, setPublishLoading] = useState(false);
   const [jsonSchemaText, setJsonSchemaText] = useState('');
   const [jsonSchemaValid, setJsonSchemaValid] = useState(true);
-  const [isJsonSchemaExpanded, setIsJsonSchemaExpanded] = useState(false);
+  const [isAdvancedSectionExpanded, setIsAdvancedSectionExpanded] =
+    useState(false);
 
   const initialAgentRef = useRef<Agent | null>(null);
   const sourceAnchorButtonRef = useRef<HTMLButtonElement>(null);
   const toolAnchorButtonRef = useRef<HTMLButtonElement>(null);
+  const modelAnchorButtonRef = useRef<HTMLButtonElement>(null);
 
   const modeConfig = {
     new: {
-      heading: 'New Agent',
-      buttonText: 'Publish',
+      heading: t('agents.form.headings.new'),
+      buttonText: t('agents.form.buttons.publish'),
       showDelete: false,
       showSaveDraft: true,
       showLogs: false,
@@ -93,8 +108,8 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       trackChanges: false,
     },
     edit: {
-      heading: 'Edit Agent',
-      buttonText: 'Save',
+      heading: t('agents.form.headings.edit'),
+      buttonText: t('agents.form.buttons.save'),
       showDelete: true,
       showSaveDraft: false,
       showLogs: true,
@@ -102,8 +117,8 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       trackChanges: true,
     },
     draft: {
-      heading: 'New Agent (Draft)',
-      buttonText: 'Publish',
+      heading: t('agents.form.headings.draft'),
+      buttonText: t('agents.form.buttons.publish'),
       showDelete: true,
       showSaveDraft: true,
       showLogs: false,
@@ -113,8 +128,8 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
   };
   const chunks = ['0', '2', '4', '6', '8', '10'];
   const agentTypes = [
-    { label: 'Classic', value: 'classic' },
-    { label: 'ReAct', value: 'react' },
+    { label: t('agents.form.agentTypes.classic'), value: 'classic' },
+    { label: t('agents.form.agentTypes.react'), value: 'react' },
   ];
 
   const isPublishable = () => {
@@ -193,6 +208,22 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
     formData.append('agent_type', agent.agent_type);
     formData.append('status', 'draft');
 
+    if (agent.limited_token_mode && agent.token_limit) {
+      formData.append('limited_token_mode', 'True');
+      formData.append('token_limit', agent.token_limit.toString());
+    } else {
+      formData.append('limited_token_mode', 'False');
+      formData.append('token_limit', '0');
+    }
+
+    if (agent.limited_request_mode && agent.request_limit) {
+      formData.append('limited_request_mode', 'True');
+      formData.append('request_limit', agent.request_limit.toString());
+    } else {
+      formData.append('limited_request_mode', 'False');
+      formData.append('request_limit', '0');
+    }
+
     if (imageFile) formData.append('image', imageFile);
 
     if (agent.tools && agent.tools.length > 0)
@@ -203,6 +234,13 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       formData.append('json_schema', JSON.stringify(agent.json_schema));
     }
 
+    if (agent.models && agent.models.length > 0) {
+      formData.append('models', JSON.stringify(agent.models));
+    }
+    if (agent.default_model_id) {
+      formData.append('default_model_id', agent.default_model_id);
+    }
+
     try {
       setDraftLoading(true);
       const response =
@@ -282,6 +320,30 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       formData.append('json_schema', JSON.stringify(agent.json_schema));
     }
 
+    // Always send the limited mode fields
+    if (agent.limited_token_mode && agent.token_limit) {
+      formData.append('limited_token_mode', 'True');
+      formData.append('token_limit', agent.token_limit.toString());
+    } else {
+      formData.append('limited_token_mode', 'False');
+      formData.append('token_limit', '0');
+    }
+
+    if (agent.limited_request_mode && agent.request_limit) {
+      formData.append('limited_request_mode', 'True');
+      formData.append('request_limit', agent.request_limit.toString());
+    } else {
+      formData.append('limited_request_mode', 'False');
+      formData.append('request_limit', '0');
+    }
+
+    if (agent.models && agent.models.length > 0) {
+      formData.append('models', JSON.stringify(agent.models));
+    }
+    if (agent.default_model_id) {
+      formData.append('default_model_id', agent.default_model_id);
+    }
+
     try {
       setPublishLoading(true);
       const response =
@@ -337,7 +399,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       const data = await response.json();
       const tools: OptionType[] = data.tools.map((tool: UserToolType) => ({
         id: tool.id,
-        label: tool.displayName,
+        label: tool.customName ? tool.customName : tool.displayName,
         icon: `/toolIcons/tool_${tool.name}.svg`,
       }));
       setUserTools(tools);
@@ -350,8 +412,16 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
       const data = await response.json();
       setPrompts(data);
     };
+    const getModels = async () => {
+      const response = await modelService.getModels(null);
+      if (!response.ok) throw new Error('Failed to fetch models');
+      const data = await response.json();
+      const transformed = modelService.transformModels(data.models || []);
+      setAvailableModels(transformed);
+    };
     getTools();
     getPrompts();
+    getModels();
   }, [token]);
 
   // Auto-select default source if none selected
@@ -410,7 +480,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
           setSelectedSourceIds(new Set([data.retriever]));
         }
 
-        if (data.tools) setSelectedToolIds(new Set(data.tools));
+        if (data.tool_details) setSelectedTools(data.tool_details);
         if (data.status === 'draft') setEffectiveMode('draft');
         if (data.json_schema) {
           const jsonText = JSON.stringify(data.json_schema, null, 2);
@@ -424,6 +494,34 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
     }
   }, [agentId, mode, token]);
 
+  useEffect(() => {
+    if (agent.models && agent.models.length > 0 && availableModels.length > 0) {
+      const agentModelIds = new Set(agent.models);
+      if (agentModelIds.size > 0 && selectedModelIds.size === 0) {
+        setSelectedModelIds(agentModelIds);
+      }
+    }
+  }, [agent.models, availableModels.length]);
+
+  useEffect(() => {
+    const modelsArray = Array.from(selectedModelIds);
+    if (modelsArray.length > 0) {
+      setAgent((prev) => ({
+        ...prev,
+        models: modelsArray,
+        default_model_id: modelsArray.includes(prev.default_model_id || '')
+          ? prev.default_model_id
+          : modelsArray[0],
+      }));
+    } else {
+      setAgent((prev) => ({
+        ...prev,
+        models: [],
+        default_model_id: '',
+      }));
+    }
+  }, [selectedModelIds]);
+
   useEffect(() => {
     const selectedSources = Array.from(selectedSourceIds)
       .map((id) =>
@@ -480,16 +578,13 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
   }, [selectedSourceIds]);
 
   useEffect(() => {
-    const selectedTool = Array.from(selectedToolIds).map((id) =>
-      userTools.find((tool) => tool.id === id),
-    );
     setAgent((prev) => ({
       ...prev,
-      tools: selectedTool
+      tools: Array.from(selectedTools)
         .map((tool) => tool?.id)
         .filter((id): id is string => typeof id === 'string'),
     }));
-  }, [selectedToolIds]);
+  }, [selectedTools]);
 
   useEffect(() => {
     if (isPublishable()) dispatch(setSelectedAgent(agent));
@@ -514,7 +609,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
     setHasChanges(isChanged);
   }, [agent, dispatch, effectiveMode, imageFile, jsonSchemaText]);
   return (
-    <div className="p-4 md:p-12">
+    <div className="flex flex-col px-4 pt-4 pb-2 max-[1179px]:min-h-[100dvh] min-[1180px]:h-[100dvh] md:px-12 md:pt-12 md:pb-3">
       <div className="flex items-center gap-3 px-4">
         <button
           className="rounded-full border p-3 text-sm text-gray-400 dark:border-0 dark:bg-[#28292D] dark:text-gray-500 dark:hover:bg-[#2E2F34]"
@@ -523,7 +618,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
           <img src={ArrowLeft} alt="left-arrow" className="h-3 w-3" />
         </button>
         <p className="text-eerie-black dark:text-bright-gray mt-px text-sm font-semibold">
-          Back to all agents
+          {t('agents.backToAll')}
         </p>
       </div>
       <div className="mt-5 flex w-full flex-wrap items-center justify-between gap-2 px-4">
@@ -535,7 +630,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
             className="text-purple-30 dark:text-light-gray mr-4 rounded-3xl py-2 text-sm font-medium dark:bg-transparent"
             onClick={handleCancel}
           >
-            Cancel
+            {t('agents.form.buttons.cancel')}
           </button>
           {modeConfig[effectiveMode].showDelete && agent.id && (
             <button
@@ -543,7 +638,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
               onClick={() => setDeleteConfirmation('ACTIVE')}
             >
               <span className="block h-4 w-4 bg-[url('/src/assets/red-trash.svg')] bg-contain bg-center bg-no-repeat transition-all group-hover:bg-[url('/src/assets/white-trash.svg')]" />
-              Delete
+              {t('agents.form.buttons.delete')}
             </button>
           )}
           {modeConfig[effectiveMode].showSaveDraft && (
@@ -558,7 +653,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 {draftLoading ? (
                   <Spinner size="small" color="#976af3" />
                 ) : (
-                  'Save Draft'
+                  t('agents.form.buttons.saveDraft')
                 )}
               </span>
             </button>
@@ -569,7 +664,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
               onClick={() => navigate(`/agents/logs/${agent.id}`)}
             >
               <span className="block h-5 w-5 bg-[url('/src/assets/monitoring-purple.svg')] bg-contain bg-center bg-no-repeat transition-all group-hover:bg-[url('/src/assets/monitoring-white.svg')]" />
-              Logs
+              {t('agents.form.buttons.logs')}
             </button>
           )}
           {modeConfig[effectiveMode].showAccessDetails && (
@@ -577,7 +672,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
               className="hover:bg-vi</button>olets-are-blue border-violets-are-blue text-violets-are-blue hover:bg-violets-are-blue rounded-3xl border border-solid px-5 py-2 text-sm font-medium transition-colors hover:text-white"
               onClick={() => setAgentDetails('ACTIVE')}
             >
-              Access Details
+              {t('agents.form.buttons.accessDetails')}
             </button>
           )}
           <button
@@ -595,20 +690,22 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
           </button>
         </div>
       </div>
-      <div className="mt-5 flex w-full grid-cols-5 flex-col gap-10 min-[1180px]:grid min-[1180px]:gap-5">
-        <div className="col-span-2 flex flex-col gap-5">
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
-            <h2 className="text-lg font-semibold">Meta</h2>
+      <div className="mt-3 flex w-full flex-1 grid-cols-5 flex-col gap-10 rounded-[30px] bg-[#F6F6F6] p-5 max-[1179px]:overflow-visible min-[1180px]:grid min-[1180px]:gap-5 min-[1180px]:overflow-hidden dark:bg-[#383838]">
+        <div className="scrollbar-thin col-span-2 flex flex-col gap-5 max-[1179px]:overflow-visible min-[1180px]:max-h-full min-[1180px]:overflow-y-auto min-[1180px]:pr-3">
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
+            <h2 className="text-lg font-semibold">
+              {t('agents.form.sections.meta')}
+            </h2>
             <input
               className="border-silver text-jet dark:bg-raisin-black dark:text-bright-gray dark:placeholder:text-silver mt-3 w-full rounded-3xl border bg-white px-5 py-3 text-sm outline-hidden placeholder:text-gray-400 dark:border-[#7E7E7E]"
               type="text"
               value={agent.name}
-              placeholder="Agent name"
+              placeholder={t('agents.form.placeholders.agentName')}
               onChange={(e) => setAgent({ ...agent, name: e.target.value })}
             />
             <textarea
               className="border-silver text-jet dark:bg-raisin-black dark:text-bright-gray dark:placeholder:text-silver mt-3 h-32 w-full rounded-xl border bg-white px-5 py-4 text-sm outline-hidden placeholder:text-gray-400 dark:border-[#7E7E7E]"
-              placeholder="Describe your agent"
+              placeholder={t('agents.form.placeholders.describeAgent')}
               value={agent.description}
               onChange={(e) =>
                 setAgent({ ...agent, description: e.target.value })
@@ -621,17 +718,22 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 onUpload={handleUpload}
                 onRemove={() => setImageFile(null)}
                 uploadText={[
-                  { text: 'Click to upload', colorClass: 'text-[#7D54D1]' },
                   {
-                    text: ' or drag and drop',
+                    text: t('agents.form.upload.clickToUpload'),
+                    colorClass: 'text-[#7D54D1]',
+                  },
+                  {
+                    text: t('agents.form.upload.dragAndDrop'),
                     colorClass: 'text-[#525252]',
                   },
                 ]}
               />
             </div>
           </div>
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
-            <h2 className="text-lg font-semibold">Source</h2>
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
+            <h2 className="text-lg font-semibold">
+              {t('agents.form.sections.source')}
+            </h2>
             <div className="mt-3">
               <div className="flex flex-wrap items-center gap-1">
                 <button
@@ -645,18 +747,20 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 >
                   {selectedSourceIds.size > 0
                     ? Array.from(selectedSourceIds)
-                        .map(
-                          (id) =>
-                            sourceDocs?.find(
-                              (source) =>
-                                source.id === id ||
-                                source.name === id ||
-                                source.retriever === id,
-                            )?.name,
-                        )
+                        .map((id) => {
+                          const matchedDoc = sourceDocs?.find(
+                            (source) =>
+                              source.id === id ||
+                              source.name === id ||
+                              source.retriever === id,
+                          );
+                          return (
+                            matchedDoc?.name || t('agents.form.externalKb')
+                          );
+                        })
                         .filter(Boolean)
                         .join(', ')
-                    : 'Select sources'}
+                    : t('agents.form.placeholders.selectSources')}
                 </button>
                 <MultiSelectPopup
                   isOpen={isSourcePopupOpen}
@@ -700,9 +804,13 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                       setSelectedSourceIds(newSelectedIds);
                     }
                   }}
-                  title="Select Sources"
-                  searchPlaceholder="Search sources..."
-                  noOptionsMessage="No sources available"
+                  title={t('agents.form.sourcePopup.title')}
+                  searchPlaceholder={t(
+                    'agents.form.sourcePopup.searchPlaceholder',
+                  )}
+                  noOptionsMessage={t(
+                    'agents.form.sourcePopup.noOptionsMessage',
+                  )}
                 />
               </div>
               <div className="mt-3">
@@ -717,14 +825,14 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                   border="border"
                   buttonClassName="bg-white dark:bg-[#222327] border-silver dark:border-[#7E7E7E]"
                   optionsClassName="bg-white dark:bg-[#383838] border-silver dark:border-[#7E7E7E]"
-                  placeholder="Chunks per query"
+                  placeholder={t('agents.form.placeholders.chunksPerQuery')}
                   placeholderClassName="text-gray-400 dark:text-silver"
                   contentSize="text-sm"
                 />
               </div>
             </div>
           </div>
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
             <div className="flex flex-wrap items-end gap-1">
               <div className="min-w-20 grow basis-full sm:basis-0">
                 <Prompts
@@ -737,7 +845,7 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                     setAgent({ ...agent, prompt_id: id })
                   }
                   setPrompts={setPrompts}
-                  title="Prompt"
+                  title={t('agents.form.sections.prompt')}
                   titleClassName="text-lg font-semibold dark:text-[#E0E0E0]"
                   showAddButton={false}
                   dropdownProps={{
@@ -757,48 +865,60 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 className="border-violets-are-blue text-violets-are-blue hover:bg-violets-are-blue w-20 shrink-0 basis-full rounded-3xl border-2 border-solid px-5 py-[11px] text-sm transition-colors hover:text-white sm:basis-auto"
                 onClick={() => setAddPromptModal('ACTIVE')}
               >
-                Add
+                {t('agents.form.buttons.add')}
               </button>
             </div>
           </div>
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
-            <h2 className="text-lg font-semibold">Tools</h2>
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
+            <h2 className="text-lg font-semibold">
+              {t('agents.form.sections.tools')}
+            </h2>
             <div className="mt-3 flex flex-wrap items-center gap-1">
               <button
                 ref={toolAnchorButtonRef}
                 onClick={() => setIsToolsPopupOpen(!isToolsPopupOpen)}
                 className={`border-silver dark:bg-raisin-black w-full truncate rounded-3xl border bg-white px-5 py-3 text-left text-sm dark:border-[#7E7E7E] ${
-                  selectedToolIds.size > 0
+                  selectedTools.length > 0
                     ? 'text-jet dark:text-bright-gray'
                     : 'dark:text-silver text-gray-400'
                 }`}
               >
-                {selectedToolIds.size > 0
-                  ? Array.from(selectedToolIds)
-                      .map(
-                        (id) => userTools.find((tool) => tool.id === id)?.label,
-                      )
+                {selectedTools.length > 0
+                  ? selectedTools
+                      .map((tool) => tool.display_name || tool.name)
                       .filter(Boolean)
                       .join(', ')
-                  : 'Select tools'}
+                  : t('agents.form.placeholders.selectTools')}
               </button>
               <MultiSelectPopup
                 isOpen={isToolsPopupOpen}
                 onClose={() => setIsToolsPopupOpen(false)}
                 anchorRef={toolAnchorButtonRef}
                 options={userTools}
-                selectedIds={selectedToolIds}
+                selectedIds={new Set(selectedTools.map((tool) => tool.id))}
                 onSelectionChange={(newSelectedIds: Set<string | number>) =>
-                  setSelectedToolIds(newSelectedIds)
+                  setSelectedTools(
+                    userTools
+                      .filter((tool) => newSelectedIds.has(tool.id))
+                      .map((tool) => ({
+                        id: String(tool.id),
+                        name: tool.label,
+                        display_name: tool.label,
+                      })),
+                  )
                 }
-                title="Select Tools"
-                searchPlaceholder="Search tools..."
-                noOptionsMessage="No tools available"
+                title={t('agents.form.toolsPopup.title')}
+                searchPlaceholder={t(
+                  'agents.form.toolsPopup.searchPlaceholder',
+                )}
+                noOptionsMessage={t('agents.form.toolsPopup.noOptionsMessage')}
               />
             </div>
           </div>
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
-            <h2 className="text-lg font-semibold">Agent type</h2>
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
+            <h2 className="text-lg font-semibold">
+              {t('agents.form.sections.agentType')}
+            </h2>
             <div className="mt-3">
               <Dropdown
                 options={agentTypes}
@@ -816,24 +936,104 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 border="border"
                 buttonClassName="bg-white dark:bg-[#222327] border-silver dark:border-[#7E7E7E]"
                 optionsClassName="bg-white dark:bg-[#383838] border-silver dark:border-[#7E7E7E]"
-                placeholder="Select type"
+                placeholder={t('agents.form.placeholders.selectType')}
                 placeholderClassName="text-gray-400 dark:text-silver"
                 contentSize="text-sm"
               />
             </div>
           </div>
-          <div className="rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
+            <h2 className="text-lg font-semibold">
+              {t('agents.form.sections.models')}
+            </h2>
+            <div className="mt-3 flex flex-col gap-3">
+              <button
+                ref={modelAnchorButtonRef}
+                onClick={() => setIsModelsPopupOpen(!isModelsPopupOpen)}
+                className={`border-silver dark:bg-raisin-black w-full truncate rounded-3xl border bg-white px-5 py-3 text-left text-sm dark:border-[#7E7E7E] ${
+                  selectedModelIds.size > 0
+                    ? 'text-jet dark:text-bright-gray'
+                    : 'dark:text-silver text-gray-400'
+                }`}
+              >
+                {selectedModelIds.size > 0
+                  ? availableModels
+                      .filter((m) => selectedModelIds.has(m.id))
+                      .map((m) => m.display_name)
+                      .join(', ')
+                  : t('agents.form.placeholders.selectModels')}
+              </button>
+              <MultiSelectPopup
+                isOpen={isModelsPopupOpen}
+                onClose={() => setIsModelsPopupOpen(false)}
+                anchorRef={modelAnchorButtonRef}
+                options={availableModels.map((model) => ({
+                  id: model.id,
+                  label: model.display_name,
+                }))}
+                selectedIds={selectedModelIds}
+                onSelectionChange={(newSelectedIds: Set<string | number>) =>
+                  setSelectedModelIds(
+                    new Set(Array.from(newSelectedIds).map(String)),
+                  )
+                }
+                title={t('agents.form.modelsPopup.title')}
+                searchPlaceholder={t(
+                  'agents.form.modelsPopup.searchPlaceholder',
+                )}
+                noOptionsMessage={t('agents.form.modelsPopup.noOptionsMessage')}
+              />
+              {selectedModelIds.size > 0 && (
+                <div>
+                  <label className="mb-2 block text-sm font-medium">
+                    {t('agents.form.labels.defaultModel')}
+                  </label>
+                  <Dropdown
+                    options={availableModels
+                      .filter((m) => selectedModelIds.has(m.id))
+                      .map((m) => ({
+                        label: m.display_name,
+                        value: m.id,
+                      }))}
+                    selectedValue={
+                      availableModels.find(
+                        (m) => m.id === agent.default_model_id,
+                      )?.display_name || null
+                    }
+                    onSelect={(option: { label: string; value: string }) =>
+                      setAgent({ ...agent, default_model_id: option.value })
+                    }
+                    size="w-full"
+                    rounded="3xl"
+                    border="border"
+                    buttonClassName="bg-white dark:bg-[#222327] border-silver dark:border-[#7E7E7E]"
+                    optionsClassName="bg-white dark:bg-[#383838] border-silver dark:border-[#7E7E7E]"
+                    placeholder={t(
+                      'agents.form.placeholders.selectDefaultModel',
+                    )}
+                    placeholderClassName="text-gray-400 dark:text-silver"
+                    contentSize="text-sm"
+                  />
+                </div>
+              )}
+            </div>
+          </div>
+          <div className="dark:bg-raisin-black rounded-[30px] bg-white px-6 py-3 dark:text-[#E0E0E0]">
             <button
-              onClick={() => setIsJsonSchemaExpanded(!isJsonSchemaExpanded)}
+              onClick={() =>
+                setIsAdvancedSectionExpanded(!isAdvancedSectionExpanded)
+              }
               className="flex w-full items-center justify-between text-left focus:outline-none"
             >
               <div>
-                <h2 className="text-lg font-semibold">Advanced</h2>
+                <h2 className="text-lg font-semibold">
+                  {t('agents.form.sections.advanced')}
+                </h2>
               </div>
               <div className="ml-4 flex items-center">
                 <svg
                   className={`h-5 w-5 transform transition-transform duration-200 ${
-                    isJsonSchemaExpanded ? 'rotate-180' : ''
+                    isAdvancedSectionExpanded ? 'rotate-180' : ''
                   }`}
                   fill="none"
                   stroke="currentColor"
@@ -848,12 +1048,14 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                 </svg>
               </div>
             </button>
-            {isJsonSchemaExpanded && (
+            {isAdvancedSectionExpanded && (
               <div className="mt-3">
                 <div>
-                  <h2 className="text-sm font-medium">JSON response schema</h2>
+                  <h2 className="text-sm font-medium">
+                    {t('agents.form.advanced.jsonSchema')}
+                  </h2>
                   <p className="mt-1 text-xs text-gray-600 dark:text-gray-400">
-                    Define a JSON schema to enforce structured output format
+                    {t('agents.form.advanced.jsonSchemaDescription')}
                   </p>
                 </div>
                 <textarea
@@ -887,29 +1089,147 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
                       }`}
                     />
                     {jsonSchemaValid
-                      ? 'Valid JSON'
-                      : 'Invalid JSON - fix to enable saving'}
+                      ? t('agents.form.advanced.validJson')
+                      : t('agents.form.advanced.invalidJson')}
                   </div>
                 )}
+
+                <div className="mt-6">
+                  <div className="flex items-center justify-between">
+                    <div>
+                      <h2 className="text-sm font-medium">
+                        {t('agents.form.advanced.tokenLimiting')}
+                      </h2>
+                      <p className="mt-1 text-xs text-gray-600 dark:text-gray-400">
+                        {t('agents.form.advanced.tokenLimitingDescription')}
+                      </p>
+                    </div>
+                    <button
+                      onClick={() => {
+                        const newTokenMode = !agent.limited_token_mode;
+                        setAgent({
+                          ...agent,
+                          limited_token_mode: newTokenMode,
+                          limited_request_mode: newTokenMode
+                            ? false
+                            : agent.limited_request_mode,
+                        });
+                      }}
+                      className={`relative h-6 w-11 rounded-full transition-colors ${
+                        agent.limited_token_mode
+                          ? 'bg-purple-30'
+                          : 'bg-gray-300 dark:bg-gray-600'
+                      }`}
+                    >
+                      <span
+                        className={`absolute top-0.5 h-5 w-5 transform rounded-full bg-white transition-transform ${
+                          agent.limited_token_mode ? '' : '-translate-x-5'
+                        }`}
+                      />
+                    </button>
+                  </div>
+                  <input
+                    type="number"
+                    min="0"
+                    value={agent.token_limit || ''}
+                    onChange={(e) =>
+                      setAgent({
+                        ...agent,
+                        token_limit: e.target.value
+                          ? parseInt(e.target.value)
+                          : undefined,
+                      })
+                    }
+                    disabled={!agent.limited_token_mode}
+                    placeholder={t('agents.form.placeholders.enterTokenLimit')}
+                    className={`border-silver text-jet dark:bg-raisin-black dark:text-bright-gray dark:placeholder:text-silver mt-2 w-full rounded-3xl border bg-white px-5 py-3 text-sm outline-hidden placeholder:text-gray-400 dark:border-[#7E7E7E] ${
+                      !agent.limited_token_mode
+                        ? 'cursor-not-allowed opacity-50'
+                        : ''
+                    }`}
+                  />
+                </div>
+
+                <div className="mt-6">
+                  <div className="flex items-center justify-between">
+                    <div>
+                      <h2 className="text-sm font-medium">
+                        {t('agents.form.advanced.requestLimiting')}
+                      </h2>
+                      <p className="mt-1 text-xs text-gray-600 dark:text-gray-400">
+                        {t('agents.form.advanced.requestLimitingDescription')}
+                      </p>
+                    </div>
+                    <button
+                      onClick={() => {
+                        const newRequestMode = !agent.limited_request_mode;
+                        setAgent({
+                          ...agent,
+                          limited_request_mode: newRequestMode,
+                          limited_token_mode: newRequestMode
+                            ? false
+                            : agent.limited_token_mode,
+                        });
+                      }}
+                      className={`relative h-6 w-11 rounded-full transition-colors ${
+                        agent.limited_request_mode
+                          ? 'bg-purple-30'
+                          : 'bg-gray-300 dark:bg-gray-600'
+                      }`}
+                    >
+                      <span
+                        className={`absolute top-0.5 h-5 w-5 transform rounded-full bg-white transition-transform ${
+                          agent.limited_request_mode ? '' : '-translate-x-5'
+                        }`}
+                      />
+                    </button>
+                  </div>
+                  <input
+                    type="number"
+                    min="0"
+                    value={agent.request_limit || ''}
+                    onChange={(e) =>
+                      setAgent({
+                        ...agent,
+                        request_limit: e.target.value
+                          ? parseInt(e.target.value)
+                          : undefined,
+                      })
+                    }
+                    disabled={!agent.limited_request_mode}
+                    placeholder={t(
+                      'agents.form.placeholders.enterRequestLimit',
+                    )}
+                    className={`border-silver text-jet dark:bg-raisin-black dark:text-bright-gray dark:placeholder:text-silver mt-2 w-full rounded-3xl border bg-white px-5 py-3 text-sm outline-hidden placeholder:text-gray-400 dark:border-[#7E7E7E] ${
+                      !agent.limited_request_mode
+                        ? 'cursor-not-allowed opacity-50'
+                        : ''
+                    }`}
+                  />
+                </div>
               </div>
             )}
           </div>
         </div>
-        <div className="col-span-3 flex flex-col gap-3 rounded-[30px] bg-[#F6F6F6] px-6 py-3 dark:bg-[#383838] dark:text-[#E0E0E0]">
-          <h2 className="text-lg font-semibold">Preview</h2>
-          <AgentPreviewArea />
+        <div className="col-span-3 flex flex-col gap-2 max-[1179px]:h-auto max-[1179px]:px-0 max-[1179px]:py-0 min-[1180px]:h-full min-[1180px]:py-2 dark:text-[#E0E0E0]">
+          <h2 className="text-lg font-semibold">
+            {t('agents.form.sections.preview')}
+          </h2>
+          <div className="flex-1 max-[1179px]:overflow-visible min-[1180px]:min-h-0 min-[1180px]:overflow-hidden">
+            <AgentPreviewArea />
+          </div>
         </div>
       </div>
       <ConfirmationModal
-        message="Are you sure you want to delete this agent?"
+        message={t('agents.deleteConfirmation')}
         modalState={deleteConfirmation}
         setModalState={setDeleteConfirmation}
-        submitLabel="Delete"
+        submitLabel={t('agents.form.buttons.delete')}
         handleSubmit={() => {
           handleDelete(agent.id || '');
           setDeleteConfirmation('INACTIVE');
         }}
-        cancelLabel="Cancel"
+        cancelLabel={t('agents.form.buttons.cancel')}
         variant="danger"
       />
       <AgentDetailsModal
@@ -932,18 +1252,19 @@ export default function NewAgent({ mode }: { mode: 'new' | 'edit' | 'draft' }) {
 }
 
 function AgentPreviewArea() {
+  const { t } = useTranslation();
   const selectedAgent = useSelector(selectSelectedAgent);
   return (
-    <div className="dark:bg-raisin-black h-full w-full rounded-[30px] border border-[#F6F6F6] bg-white max-[1180px]:h-192 dark:border-[#7E7E7E]">
+    <div className="dark:bg-raisin-black w-full rounded-[30px] border border-[#F6F6F6] bg-white max-[1179px]:h-[600px] min-[1180px]:h-full dark:border-[#7E7E7E]">
       {selectedAgent?.status === 'published' ? (
-        <div className="flex h-full w-full flex-col justify-end overflow-auto rounded-[30px]">
+        <div className="flex h-full w-full flex-col overflow-hidden rounded-[30px]">
           <AgentPreview />
         </div>
       ) : (
         <div className="flex h-full w-full flex-col items-center justify-center gap-2">
           <span className="block h-12 w-12 bg-[url('/src/assets/science-spark.svg')] bg-contain bg-center bg-no-repeat transition-all dark:bg-[url('/src/assets/science-spark-dark.svg')]" />{' '}
           <p className="dark:text-gray-4000 text-xs text-[#18181B]">
-            Published agents can be previewed here
+            {t('agents.form.preview.publishedPreview')}
           </p>
         </div>
       )}

frontend/src/agents/SharedAgent.tsx

@@ -144,7 +144,7 @@ export default function SharedAgent() {
             className="mx-auto mb-6 h-32 w-32"
           />
           <p className="dark:text-gray-4000 text-center text-lg text-[#71717A]">
-            No agent found. Please ensure the agent is shared.
+            {t('agents.shared.notFound')}
           </p>
         </div>
       </div>
@@ -177,13 +177,15 @@ export default function SharedAgent() {
           />
         </div>
         <div className="flex w-[95%] max-w-[1500px] flex-col items-center pb-2 md:w-9/12 lg:w-8/12 xl:w-8/12 2xl:w-6/12">
-          <MessageInput
-            onSubmit={(text) => handleQuestionSubmission(text)}
-            loading={status === 'loading'}
-            showSourceButton={sharedAgent ? false : true}
-            showToolButton={sharedAgent ? false : true}
-            autoFocus={false}
-          />
+          <div className="w-full px-2">
+            <MessageInput
+              onSubmit={(text) => handleQuestionSubmission(text)}
+              loading={status === 'loading'}
+              showSourceButton={sharedAgent ? false : true}
+              showToolButton={sharedAgent ? false : true}
+              autoFocus={false}
+            />
+          </div>
           <p className="text-gray-4000 dark:text-sonic-silver hidden w-screen self-center bg-transparent py-2 text-center text-xs md:inline md:w-full">
             {t('tagline')}
           </p>

frontend/src/agents/SharedAgentCard.tsx

@@ -2,6 +2,12 @@ import AgentImage from '../components/AgentImage';
 import { Agent } from './types';
 
 export default function SharedAgentCard({ agent }: { agent: Agent }) {
+  // Check if shared metadata exists and has properties (type is 'any' so we validate it's a non-empty object)
+  const hasSharedMetadata =
+    agent.shared_metadata &&
+    typeof agent.shared_metadata === 'object' &&
+    agent.shared_metadata !== null &&
+    Object.keys(agent.shared_metadata).length > 0;
   return (
     <div className="border-dark-gray dark:border-grey flex w-full max-w-[720px] flex-col rounded-3xl border p-6 shadow-xs sm:w-fit sm:min-w-[480px]">
       <div className="flex items-center gap-3">
@@ -20,7 +26,7 @@ export default function SharedAgentCard({ agent }: { agent: Agent }) {
           </p>
         </div>
       </div>
-      {agent.shared_metadata && (
+      {hasSharedMetadata && (
         <div className="mt-4 flex items-center gap-8">
           {agent.shared_metadata?.shared_by && (
             <p className="text-eerie-black text-xs font-light sm:text-sm dark:text-[#E0E0E0]">

frontend/src/agents/agentPreviewSlice.ts

@@ -1,19 +1,20 @@
 import { createAsyncThunk, createSlice, PayloadAction } from '@reduxjs/toolkit';
+
+import {
+  handleFetchAnswer,
+  handleFetchAnswerSteaming,
+} from '../conversation/conversationHandlers';
 import {
   Answer,
   ConversationState,
   Query,
   Status,
 } from '../conversation/conversationModels';
-import {
-  handleFetchAnswer,
-  handleFetchAnswerSteaming,
-} from '../conversation/conversationHandlers';
-import {
-  selectCompletedAttachments,
-  clearAttachments,
-} from '../upload/uploadSlice';
 import store from '../store';
+import {
+  clearAttachments,
+  selectCompletedAttachments,
+} from '../upload/uploadSlice';
 
 const initialState: ConversationState = {
   queries: [],
@@ -51,12 +52,16 @@ export const fetchPreviewAnswer = createAsyncThunk<
     }
 
     if (state.preference) {
+      const modelId =
+        state.preference.selectedAgent?.default_model_id ||
+        state.preference.selectedModel?.id;
+
       if (API_STREAMING) {
         await handleFetchAnswerSteaming(
           question,
           signal,
           state.preference.token,
-          state.preference.selectedDocs!,
+          state.preference.selectedDocs,
           null, // No conversation ID for previews
           state.preference.prompt.id,
           state.preference.chunks,
@@ -119,22 +124,23 @@ export const fetchPreviewAnswer = createAsyncThunk<
           indx,
           state.preference.selectedAgent?.id,
           attachmentIds,
-          false, // Don't save preview conversations
+          false,
+          modelId,
         );
       } else {
-        // Non-streaming implementation
         const answer = await handleFetchAnswer(
           question,
           signal,
           state.preference.token,
-          state.preference.selectedDocs!,
-          null, // No conversation ID for previews
+          state.preference.selectedDocs,
+          null,
           state.preference.prompt.id,
           state.preference.chunks,
           state.preference.token_limit,
           state.preference.selectedAgent?.id,
           attachmentIds,
-          false, // Don't save preview conversations
+          false,
+          modelId,
         );
 
         if (answer) {

frontend/src/agents/agents.config.ts

@@ -0,0 +1,42 @@
+import userService from '../api/services/userService';
+import {
+  selectAgents,
+  selectTemplateAgents,
+  selectSharedAgents,
+  setAgents,
+  setTemplateAgents,
+  setSharedAgents,
+} from '../preferences/preferenceSlice';
+
+export const agentSectionsConfig = [
+  {
+    id: 'template',
+    title: 'By DocsGPT',
+    description: 'Agents provided by DocsGPT',
+    showNewAgentButton: false,
+    emptyStateDescription: 'No template agents found.',
+    fetchAgents: (token: string | null) => userService.getTemplateAgents(token),
+    selectData: selectTemplateAgents,
+    updateAction: setTemplateAgents,
+  },
+  {
+    id: 'user',
+    title: 'By me',
+    description: 'Agents created or published by you',
+    showNewAgentButton: true,
+    emptyStateDescription: 'You don’t have any created agents yet.',
+    fetchAgents: (token: string | null) => userService.getAgents(token),
+    selectData: selectAgents,
+    updateAction: setAgents,
+  },
+  {
+    id: 'shared',
+    title: 'Shared with me',
+    description: 'Agents imported by using a public link',
+    showNewAgentButton: false,
+    emptyStateDescription: 'No shared agents found.',
+    fetchAgents: (token: string | null) => userService.getSharedAgents(token),
+    selectData: selectSharedAgents,
+    updateAction: setSharedAgents,
+  },
+];

frontend/src/agents/index.tsx

@@ -1,37 +1,9 @@
-import { SyntheticEvent, useEffect, useRef, useState } from 'react';
-import { useDispatch, useSelector } from 'react-redux';
-import { Route, Routes, useNavigate } from 'react-router-dom';
+import { Route, Routes } from 'react-router-dom';
 
-import userService from '../api/services/userService';
-import Edit from '../assets/edit.svg';
-import Link from '../assets/link-gray.svg';
-import Monitoring from '../assets/monitoring.svg';
-import Pin from '../assets/pin.svg';
-import Trash from '../assets/red-trash.svg';
-import AgentImage from '../components/AgentImage';
-import ThreeDots from '../assets/three-dots.svg';
-import UnPin from '../assets/unpin.svg';
-import ContextMenu, { MenuOption } from '../components/ContextMenu';
-import Spinner from '../components/Spinner';
-import {
-  setConversation,
-  updateConversationId,
-} from '../conversation/conversationSlice';
-import ConfirmationModal from '../modals/ConfirmationModal';
-import { ActiveState } from '../models/misc';
-import {
-  selectAgents,
-  selectSelectedAgent,
-  selectSharedAgents,
-  selectToken,
-  setAgents,
-  setSelectedAgent,
-  setSharedAgents,
-} from '../preferences/preferenceSlice';
 import AgentLogs from './AgentLogs';
+import AgentsList from './AgentsList';
 import NewAgent from './NewAgent';
 import SharedAgent from './SharedAgent';
-import { Agent } from './types';
 
 export default function Agents() {
   return (
@@ -44,427 +16,3 @@ export default function Agents() {
     </Routes>
   );
 }
-
-const sectionConfig = {
-  user: {
-    title: 'By me',
-    description: 'Agents created or published by you',
-    showNewAgentButton: true,
-    emptyStateDescription: 'You don’t have any created agents yet',
-  },
-  shared: {
-    title: 'Shared with me',
-    description: 'Agents imported by using a public link',
-    showNewAgentButton: false,
-    emptyStateDescription: 'No shared agents found',
-  },
-};
-
-function AgentsList() {
-  const dispatch = useDispatch();
-  const token = useSelector(selectToken);
-  const agents = useSelector(selectAgents);
-  const sharedAgents = useSelector(selectSharedAgents);
-  const selectedAgent = useSelector(selectSelectedAgent);
-
-  const [loadingUserAgents, setLoadingUserAgents] = useState<boolean>(true);
-  const [loadingSharedAgents, setLoadingSharedAgents] = useState<boolean>(true);
-
-  const getAgents = async () => {
-    try {
-      setLoadingUserAgents(true);
-      const response = await userService.getAgents(token);
-      if (!response.ok) throw new Error('Failed to fetch agents');
-      const data = await response.json();
-      dispatch(setAgents(data));
-      setLoadingUserAgents(false);
-    } catch (error) {
-      console.error('Error:', error);
-      setLoadingUserAgents(false);
-    }
-  };
-
-  const getSharedAgents = async () => {
-    try {
-      setLoadingSharedAgents(true);
-      const response = await userService.getSharedAgents(token);
-      if (!response.ok) throw new Error('Failed to fetch shared agents');
-      const data = await response.json();
-      dispatch(setSharedAgents(data));
-      setLoadingSharedAgents(false);
-    } catch (error) {
-      console.error('Error:', error);
-      setLoadingSharedAgents(false);
-    }
-  };
-
-  useEffect(() => {
-    getAgents();
-    getSharedAgents();
-    dispatch(setConversation([]));
-    dispatch(
-      updateConversationId({
-        query: { conversationId: null },
-      }),
-    );
-    if (selectedAgent) dispatch(setSelectedAgent(null));
-  }, [token]);
-  return (
-    <div className="p-4 md:p-12">
-      <h1 className="text-eerie-black mb-0 text-[32px] font-bold lg:text-[40px] dark:text-[#E0E0E0]">
-        Agents
-      </h1>
-      <p className="dark:text-gray-4000 mt-5 text-[15px] text-[#71717A]">
-        Discover and create custom versions of DocsGPT that combine
-        instructions, extra knowledge, and any combination of skills
-      </p>
-      {/* Premade agents section */}
-      {/* <div className="mt-6">
-        <h2 className="text-[18px] font-semibold text-[#18181B] dark:text-[#E0E0E0]">
-          Premade by DocsGPT
-        </h2>
-        <div className="mt-4 flex w-full flex-wrap gap-4">
-          {Array.from({ length: 5 }, (_, index) => (
-            <div
-              key={index}
-              className="relative flex h-44 w-48 flex-col justify-between rounded-[1.2rem] bg-[#F6F6F6] px-6 py-5 dark:bg-[#383838]"
-            >
-              <button onClick={() => {}} className="absolute right-4 top-4">
-                <img
-                  src={Copy}
-                  alt={'use-agent'}
-                  className="h-[19px] w-[19px]"
-                />
-              </button>
-              <div className="w-full">
-                <div className="flex w-full items-center px-1">
-                  <AgentImage className="h-7 w-7 rounded-full" />
-                </div>
-                <div className="mt-2">
-                  <p
-                    title={''}
-                    className="truncate px-1 text-[13px] font-semibold capitalize leading-relaxed text-raisin-black-light dark:text-bright-gray"
-                  >
-                    {}
-                  </p>
-                  <p className="mt-1 h-20 overflow-auto px-1 text-[12px] leading-relaxed text-old-silver dark:text-sonic-silver-light">
-                    {}
-                  </p>
-                </div>
-              </div>
-              <div className="absolute bottom-4 right-4"></div>
-            </div>
-          ))}
-        </div>
-      </div> */}
-      <AgentSection
-        agents={agents ?? []}
-        updateAgents={(updatedAgents) => {
-          dispatch(setAgents(updatedAgents));
-        }}
-        loading={loadingUserAgents}
-        section="user"
-      />
-      <AgentSection
-        agents={sharedAgents ?? []}
-        updateAgents={(updatedAgents) => {
-          dispatch(setSharedAgents(updatedAgents));
-        }}
-        loading={loadingSharedAgents}
-        section="shared"
-      />
-    </div>
-  );
-}
-
-function AgentSection({
-  agents,
-  updateAgents,
-  loading,
-  section,
-}: {
-  agents: Agent[];
-  updateAgents?: (agents: Agent[]) => void;
-  loading: boolean;
-  section: keyof typeof sectionConfig;
-}) {
-  const navigate = useNavigate();
-  return (
-    <div className="mt-8 flex flex-col gap-4">
-      <div className="flex w-full items-center justify-between">
-        <div className="flex flex-col gap-2">
-          <h2 className="text-[18px] font-semibold text-[#18181B] dark:text-[#E0E0E0]">
-            {sectionConfig[section].title}
-          </h2>
-          <p className="text-[13px] text-[#71717A]">
-            {sectionConfig[section].description}
-          </p>
-        </div>
-        {sectionConfig[section].showNewAgentButton && (
-          <button
-            className="bg-purple-30 hover:bg-violets-are-blue rounded-full px-4 py-2 text-sm text-white"
-            onClick={() => navigate('/agents/new')}
-          >
-            New Agent
-          </button>
-        )}
-      </div>
-      <div>
-        {loading ? (
-          <div className="flex h-72 w-full items-center justify-center">
-            <Spinner />
-          </div>
-        ) : agents && agents.length > 0 ? (
-          <div className="grid grid-cols-1 gap-4 sm:flex sm:flex-wrap">
-            {agents.map((agent, idx) => (
-              <AgentCard
-                key={agent.id}
-                agent={agent}
-                agents={agents}
-                updateAgents={updateAgents}
-                section={section}
-              />
-            ))}
-          </div>
-        ) : (
-          <div className="flex h-72 w-full flex-col items-center justify-center gap-3 text-base text-[#18181B] dark:text-[#E0E0E0]">
-            <p>{sectionConfig[section].emptyStateDescription}</p>
-            {sectionConfig[section].showNewAgentButton && (
-              <button
-                className="bg-purple-30 hover:bg-violets-are-blue ml-2 rounded-full px-4 py-2 text-sm text-white"
-                onClick={() => navigate('/agents/new')}
-              >
-                New Agent
-              </button>
-            )}
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}
-
-function AgentCard({
-  agent,
-  agents,
-  updateAgents,
-  section,
-}: {
-  agent: Agent;
-  agents: Agent[];
-  updateAgents?: (agents: Agent[]) => void;
-  section: keyof typeof sectionConfig;
-}) {
-  const navigate = useNavigate();
-  const dispatch = useDispatch();
-  const token = useSelector(selectToken);
-
-  const [isMenuOpen, setIsMenuOpen] = useState<boolean>(false);
-  const [deleteConfirmation, setDeleteConfirmation] =
-    useState<ActiveState>('INACTIVE');
-
-  const menuRef = useRef<HTMLDivElement>(null);
-
-  const togglePin = async () => {
-    try {
-      const response = await userService.togglePinAgent(agent.id ?? '', token);
-      if (!response.ok) throw new Error('Failed to pin agent');
-      const updatedAgents = agents.map((prevAgent) => {
-        if (prevAgent.id === agent.id)
-          return { ...prevAgent, pinned: !prevAgent.pinned };
-        return prevAgent;
-      });
-      updateAgents?.(updatedAgents);
-    } catch (error) {
-      console.error('Error:', error);
-    }
-  };
-
-  const handleHideSharedAgent = async () => {
-    try {
-      const response = await userService.removeSharedAgent(
-        agent.id ?? '',
-        token,
-      );
-      if (!response.ok) throw new Error('Failed to hide shared agent');
-      const updatedAgents = agents.filter(
-        (prevAgent) => prevAgent.id !== agent.id,
-      );
-      updateAgents?.(updatedAgents);
-    } catch (error) {
-      console.error('Error:', error);
-    }
-  };
-
-  const menuOptionsConfig: Record<string, MenuOption[]> = {
-    user: [
-      {
-        icon: Monitoring,
-        label: 'Logs',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          navigate(`/agents/logs/${agent.id}`);
-        },
-        variant: 'primary',
-        iconWidth: 14,
-        iconHeight: 14,
-      },
-      {
-        icon: Edit,
-        label: 'Edit',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          navigate(`/agents/edit/${agent.id}`);
-        },
-        variant: 'primary',
-        iconWidth: 14,
-        iconHeight: 14,
-      },
-      ...(agent.status === 'published'
-        ? [
-            {
-              icon: agent.pinned ? UnPin : Pin,
-              label: agent.pinned ? 'Unpin' : 'Pin agent',
-              onClick: (e: SyntheticEvent) => {
-                e.stopPropagation();
-                togglePin();
-              },
-              variant: 'primary' as const,
-              iconWidth: 18,
-              iconHeight: 18,
-            },
-          ]
-        : []),
-      {
-        icon: Trash,
-        label: 'Delete',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          setDeleteConfirmation('ACTIVE');
-        },
-        variant: 'danger',
-        iconWidth: 13,
-        iconHeight: 13,
-      },
-    ],
-    shared: [
-      {
-        icon: Link,
-        label: 'Open',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          navigate(`/agents/shared/${agent.shared_token}`);
-        },
-        variant: 'primary',
-        iconWidth: 12,
-        iconHeight: 12,
-      },
-      {
-        icon: agent.pinned ? UnPin : Pin,
-        label: agent.pinned ? 'Unpin' : 'Pin agent',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          togglePin();
-        },
-        variant: 'primary',
-        iconWidth: 18,
-        iconHeight: 18,
-      },
-      {
-        icon: Trash,
-        label: 'Remove',
-        onClick: (e: SyntheticEvent) => {
-          e.stopPropagation();
-          handleHideSharedAgent();
-        },
-        variant: 'danger',
-        iconWidth: 13,
-        iconHeight: 13,
-      },
-    ],
-  };
-
-  const menuOptions = menuOptionsConfig[section] || [];
-
-  const handleClick = () => {
-    if (section === 'user') {
-      if (agent.status === 'published') {
-        dispatch(setSelectedAgent(agent));
-        navigate(`/`);
-      }
-    }
-    if (section === 'shared') {
-      navigate(`/agents/shared/${agent.shared_token}`);
-    }
-  };
-
-  const handleDelete = async (agentId: string) => {
-    const response = await userService.deleteAgent(agentId, token);
-    if (!response.ok) throw new Error('Failed to delete agent');
-    const data = await response.json();
-    dispatch(setAgents(agents.filter((prevAgent) => prevAgent.id !== data.id)));
-  };
-  return (
-    <div
-      className={`relative flex h-44 w-full flex-col justify-between rounded-[1.2rem] bg-[#F6F6F6] px-6 py-5 hover:bg-[#ECECEC] md:w-48 dark:bg-[#383838] dark:hover:bg-[#383838]/80 ${agent.status === 'published' && 'cursor-pointer'}`}
-      onClick={(e) => {
-        e.stopPropagation();
-        handleClick();
-      }}
-    >
-      <div
-        ref={menuRef}
-        onClick={(e) => {
-          e.stopPropagation();
-          setIsMenuOpen(true);
-        }}
-        className="absolute top-4 right-4 z-10 cursor-pointer"
-      >
-        <img src={ThreeDots} alt={'use-agent'} className="h-[19px] w-[19px]" />
-        <ContextMenu
-          isOpen={isMenuOpen}
-          setIsOpen={setIsMenuOpen}
-          options={menuOptions}
-          anchorRef={menuRef}
-          position="bottom-right"
-          offset={{ x: 0, y: 0 }}
-        />
-      </div>
-      <div className="w-full">
-        <div className="flex w-full items-center gap-1 px-1">
-          <AgentImage
-            src={agent.image}
-            alt={`${agent.name}`}
-            className="h-7 w-7 rounded-full object-contain"
-          />
-          {agent.status === 'draft' && (
-            <p className="text-xs text-black opacity-50 dark:text-[#E0E0E0]">{`(Draft)`}</p>
-          )}
-        </div>
-        <div className="mt-2">
-          <p
-            title={agent.name}
-            className="truncate px-1 text-[13px] leading-relaxed font-semibold text-[#020617] capitalize dark:text-[#E0E0E0]"
-          >
-            {agent.name}
-          </p>
-          <p className="dark:text-sonic-silver-light mt-1 h-20 overflow-auto px-1 text-[12px] leading-relaxed text-[#64748B]">
-            {agent.description}
-          </p>
-        </div>
-      </div>
-      <ConfirmationModal
-        message="Are you sure you want to delete this agent?"
-        modalState={deleteConfirmation}
-        setModalState={setDeleteConfirmation}
-        submitLabel="Delete"
-        handleSubmit={() => {
-          handleDelete(agent.id || '');
-          setDeleteConfirmation('INACTIVE');
-        }}
-        cancelLabel="Cancel"
-        variant="danger"
-      />
-    </div>
-  );
-}

frontend/src/agents/types/index.ts

@@ -28,4 +28,10 @@ export type Agent = {
   updated_at?: string;
   last_used_at?: string;
   json_schema?: object;
+  limited_token_mode?: boolean;
+  token_limit?: number;
+  limited_request_mode?: boolean;
+  request_limit?: number;
+  models?: string[];
+  default_model_id?: string;
 };