Merge branch 'development' into testing

.dockerignore

@@ -5,9 +5,10 @@
 # Large / generated data
 memory/**
 
-# Logs & tmp
+# Logs, tmp, usr
 logs/*
 tmp/*
+usr/*
 
 # Knowledge directory – keep only default/
 knowledge/**

.gitignore

@@ -2,10 +2,12 @@
 **/.DS_Store
 **/.env
 **/__pycache__/
+*.py[cod]
 **/.conda/
 
-#Ignore cursor rules
+#Ignore IDE files
 .cursor/
+.windsurf/
 
 # ignore test files in root dir
 /*.test.py
@@ -20,8 +22,9 @@ memory/**
 # Handle logs directory
 logs/*
 
-# Handle tmp directory
+# Handle tmp and usr directory
 tmp/*
+usr/*
 
 # Handle knowledge directory
 knowledge/**
@@ -39,4 +42,7 @@ instruments/**
 
 # Global rule to include .gitkeep files anywhere
 !**/.gitkeep
-agent_history.gif
+
+# for browser-use
+agent_history.gif
+

agent.py

@@ -11,7 +11,7 @@ from enum import Enum
 import uuid
 import models
 
-from python.helpers import extract_tools, files, errors, history, tokens
+from python.helpers import extract_tools, files, errors, history, tokens, context as context_helper
 from python.helpers import dirty_json
 from python.helpers.print_style import PrintStyle
 
@@ -53,12 +53,24 @@ class AgentContext:
         created_at: datetime | None = None,
         type: AgentContextType = AgentContextType.USER,
         last_message: datetime | None = None,
+        data: dict | None = None,
+        output_data: dict | None = None,
+        set_current: bool = False,
     ):
-        # build context
+        # initialize context
         self.id = id or AgentContext.generate_id()
+        existing = self._contexts.get(self.id, None)
+        if existing:
+            AgentContext.remove(self.id)
+        self._contexts[self.id] = self
+        if set_current:
+            AgentContext.set_current(self.id)
+
+        # initialize state
         self.name = name
         self.config = config
         self.log = log or Log.Log()
+        self.log.context = self
         self.agent0 = agent0 or Agent(0, self.config, self)
         self.paused = paused
         self.streaming_agent = streaming_agent
@@ -67,18 +79,36 @@ class AgentContext:
         self.type = type
         AgentContext._counter += 1
         self.no = AgentContext._counter
-        # set to start of unix epoch
         self.last_message = last_message or datetime.now(timezone.utc)
+        self.data = data or {}
+        self.output_data = output_data or {}
+
 
-        existing = self._contexts.get(self.id, None)
-        if existing:
-            AgentContext.remove(self.id)
-        self._contexts[self.id] = self
 
     @staticmethod
     def get(id: str):
         return AgentContext._contexts.get(id, None)
 
+    @staticmethod
+    def use(id: str):
+        context = AgentContext.get(id)
+        if context:
+            AgentContext.set_current(id)
+        else:
+            AgentContext.set_current("")
+        return context
+
+    @staticmethod
+    def current():
+        ctxid = context_helper.get_context_data("agent_context_id","")
+        if not ctxid:
+            return None
+        return AgentContext.get(ctxid)
+
+    @staticmethod
+    def set_current(ctxid: str):
+        context_helper.set_context_data("agent_context_id", ctxid)
+
     @staticmethod
     def first():
         if not AgentContext._contexts:
@@ -112,7 +142,23 @@ class AgentContext:
             context.task.kill()
         return context
 
-    def serialize(self):
+    def get_data(self, key: str, recursive: bool = True):
+        # recursive is not used now, prepared for context hierarchy
+        return self.data.get(key, None)
+
+    def set_data(self, key: str, value: Any, recursive: bool = True):
+        # recursive is not used now, prepared for context hierarchy
+        self.data[key] = value
+
+    def get_output_data(self, key: str, recursive: bool = True):
+        # recursive is not used now, prepared for context hierarchy
+        return self.output_data.get(key, None)
+
+    def set_output_data(self, key: str, value: Any, recursive: bool = True):
+        # recursive is not used now, prepared for context hierarchy
+        self.output_data[key] = value
+
+    def output(self):
         return {
             "id": self.id,
             "name": self.name,
@@ -132,6 +178,7 @@ class AgentContext:
                 else Localization.get().serialize_datetime(datetime.fromtimestamp(0))
             ),
             "type": self.type.value,
+            **self.output_data,
         }
 
     @staticmethod
@@ -260,6 +307,7 @@ class LoopData:
         self.last_response = ""
         self.params_temporary: dict = {}
         self.params_persistent: dict = {}
+        self.current_tool = None
 
         # override values with kwargs
         for key, value in kwargs.items():
@@ -671,7 +719,7 @@ class Agent:
         response, _reasoning = await call_data["model"].unified_call(
             system_message=call_data["system"],
             user_message=call_data["message"],
-            response_callback=stream_callback,
+            response_callback=stream_callback if call_data["callback"] else None,
             rate_limiter_callback=self.rate_limiter_callback if not call_data["background"] else None,
         )
 
@@ -714,6 +762,13 @@ class Agent:
         ):  # if there is an intervention message, but not yet processed
             msg = self.intervention
             self.intervention = None  # reset the intervention message
+            # If a tool was running, save its progress to history
+            last_tool = self.loop_data.current_tool
+            if last_tool:
+                tool_progress = last_tool.progress.strip()
+                if tool_progress:
+                    self.hist_add_tool_result(last_tool.name, tool_progress)
+                    last_tool.set_progress(None)
             if progress.strip():
                 self.hist_add_ai_response(progress)
             # append the intervention message
@@ -766,27 +821,30 @@ class Agent:
                 )
 
             if tool:
-                await self.handle_intervention()
-
-
-                # Call tool hooks for compatibility
-                await tool.before_execution(**tool_args)
-                await self.handle_intervention()
-
-                # Allow extensions to preprocess tool arguments
-                await self.call_extensions("tool_execute_before", tool_args=tool_args or {}, tool_name=tool_name)
-
-                response = await tool.execute(**tool_args)
-                await self.handle_intervention()
-
-                # Allow extensions to postprocess tool response
-                await self.call_extensions("tool_execute_after", response=response, tool_name=tool_name)
-                
-                await tool.after_execution(response)
-                await self.handle_intervention()
-
-                if response.break_loop:
-                    return response.message
+                self.loop_data.current_tool = tool # type: ignore
+                try:
+                    await self.handle_intervention()
+
+                    # Call tool hooks for compatibility
+                    await tool.before_execution(**tool_args)
+                    await self.handle_intervention()
+
+                    # Allow extensions to preprocess tool arguments
+                    await self.call_extensions("tool_execute_before", tool_args=tool_args or {}, tool_name=tool_name)
+
+                    response = await tool.execute(**tool_args)
+                    await self.handle_intervention()
+
+                    # Allow extensions to postprocess tool response
+                    await self.call_extensions("tool_execute_after", response=response, tool_name=tool_name)
+                    
+                    await tool.after_execution(response)
+                    await self.handle_intervention()
+
+                    if response.break_loop:
+                        return response.message
+                finally:
+                    self.loop_data.current_tool = None
             else:
                 error_detail = (
                     f"Tool '{raw_tool_name}' not found or could not be initialized."

conf/model_providers.yaml

@@ -110,6 +110,15 @@ embedding:
   azure:
     name: OpenAI Azure
     litellm_provider: azure
+  # TODO: OpenRouter not yet supported by LiteLLM, replace with native litellm_provider openrouter and remove api_base when ready
+  openrouter:
+    name: OpenRouter
+    litellm_provider: openai
+    kwargs:
+      api_base: https://openrouter.ai/api/v1
+      extra_headers:
+        "HTTP-Referer": "https://agent-zero.ai/"
+        "X-Title": "Agent Zero"
   other:
     name: Other OpenAI compatible
     litellm_provider: openai

conf/projects.default.gitignore

@@ -0,0 +1,13 @@
+# A0 project meta folder
+.a0proj/
+
+# Python environments & cache
+venv/
+**/__pycache__/
+
+# Node.js dependencies
+**/node_modules/
+**/.npm/
+
+# Version control metadata
+**/.git/

docker/run/fs/ins/install_A0.sh

@@ -36,6 +36,8 @@ fi
 
 # Install remaining A0 python packages
 uv pip install -r /git/agent-zero/requirements.txt
+# override for packages that have unnecessarily strict dependencies
+uv pip install -r /git/agent-zero/requirements2.txt
 
 # install playwright
 bash /ins/install_playwright.sh "$@"

models.py

@@ -41,6 +41,7 @@ from langchain_core.messages import (
 )
 from langchain.embeddings.base import Embeddings
 from sentence_transformers import SentenceTransformer
+from pydantic import ConfigDict
 
 
 # disable extra logging, must be done repeatedly, otherwise browser-use will turn it back on for some reason
@@ -106,17 +107,17 @@ class ChatGenerationResult:
     def add_chunk(self, chunk: ChatChunk) -> ChatChunk:
         if chunk["reasoning_delta"]:
             self.native_reasoning = True
-        
+
         # if native reasoning detection works, there's no need to worry about thinking tags
         if self.native_reasoning:
             processed_chunk = ChatChunk(response_delta=chunk["response_delta"], reasoning_delta=chunk["reasoning_delta"])
         else:
             # if the model outputs thinking tags, we ned to parse them manually as reasoning
             processed_chunk = self._process_thinking_chunk(chunk)
-        
+
         self.reasoning += processed_chunk["reasoning_delta"]
         self.response += processed_chunk["response_delta"]
-        
+
         return processed_chunk
 
     def _process_thinking_chunk(self, chunk: ChatChunk) -> ChatChunk:
@@ -145,7 +146,7 @@ class ChatGenerationResult:
                     response = response[len(opening_tag):]
                     self.thinking = True
                     self.thinking_tag = closing_tag
-                    
+
                     close_pos = response.find(closing_tag)
                     if close_pos != -1:
                         reasoning += response[:close_pos]
@@ -164,7 +165,7 @@ class ChatGenerationResult:
                     self.unprocessed = response
                     response = ""
                     break
-        
+
         return ChatChunk(response_delta=response, reasoning_delta=reasoning)
 
     def _is_partial_opening_tag(self, text: str, opening_tag: str) -> bool:
@@ -191,7 +192,7 @@ class ChatGenerationResult:
             else:
                 response += self.unprocessed
         return ChatChunk(response_delta=response, reasoning_delta=reasoning)
-        
+
 
 rate_limiters: dict[str, RateLimiter] = {}
 api_keys_round_robin: dict[str, int] = {}
@@ -293,10 +294,11 @@ class LiteLLMChatWrapper(SimpleChatModel):
     provider: str
     kwargs: dict = {}
 
-    class Config:
-        arbitrary_types_allowed = True
-        extra = "allow"  # Allow extra attributes
-        validate_assignment = False  # Don't validate on assignment
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="allow",
+        validate_assignment=False,
+    )
 
     def __init__(
         self,
@@ -487,6 +489,7 @@ class LiteLLMChatWrapper(SimpleChatModel):
         call_kwargs: dict[str, Any] = {**self.kwargs, **kwargs}
         max_retries: int = int(call_kwargs.pop("a0_retry_attempts", 2))
         retry_delay_s: float = float(call_kwargs.pop("a0_retry_delay_seconds", 1.5))
+        stream = reasoning_callback is not None or response_callback is not None or tokens_callback is not None
 
         # results
         result = ChatGenerationResult()
@@ -499,48 +502,59 @@ class LiteLLMChatWrapper(SimpleChatModel):
                 _completion = await acompletion(
                     model=self.model_name,
                     messages=msgs_conv,
-                    stream=True,
+                    stream=stream,
                     **call_kwargs,
                 )
 
-                # iterate over chunks
-                async for chunk in _completion:  # type: ignore
-                    got_any_chunk = True
-                    # parse chunk
-                    parsed = _parse_chunk(chunk)
+                if stream:
+                    # iterate over chunks
+                    async for chunk in _completion:  # type: ignore
+                        got_any_chunk = True
+                        # parse chunk
+                        parsed = _parse_chunk(chunk)
+                        output = result.add_chunk(parsed)
+
+                        # collect reasoning delta and call callbacks
+                        if output["reasoning_delta"]:
+                            if reasoning_callback:
+                                await reasoning_callback(output["reasoning_delta"], result.reasoning)
+                            if tokens_callback:
+                                await tokens_callback(
+                                    output["reasoning_delta"],
+                                    approximate_tokens(output["reasoning_delta"]),
+                                )
+                            # Add output tokens to rate limiter if configured
+                            if limiter:
+                                limiter.add(output=approximate_tokens(output["reasoning_delta"]))
+                        # collect response delta and call callbacks
+                        if output["response_delta"]:
+                            if response_callback:
+                                await response_callback(output["response_delta"], result.response)
+                            if tokens_callback:
+                                await tokens_callback(
+                                    output["response_delta"],
+                                    approximate_tokens(output["response_delta"]),
+                                )
+                            # Add output tokens to rate limiter if configured
+                            if limiter:
+                                limiter.add(output=approximate_tokens(output["response_delta"]))
+
+                # non-stream response
+                else:
+                    parsed = _parse_chunk(_completion)
                     output = result.add_chunk(parsed)
-
-                    # collect reasoning delta and call callbacks
-                    if output["reasoning_delta"]:
-                        if reasoning_callback:
-                            await reasoning_callback(output["reasoning_delta"], result.reasoning)
-                        if tokens_callback:
-                            await tokens_callback(
-                                output["reasoning_delta"],
-                                approximate_tokens(output["reasoning_delta"]),
-                            )
-                        # Add output tokens to rate limiter if configured
-                        if limiter:
-                            limiter.add(output=approximate_tokens(output["reasoning_delta"]))
-                    # collect response delta and call callbacks
-                    if output["response_delta"]:
-                        if response_callback:
-                            await response_callback(output["response_delta"], result.response)
-                        if tokens_callback:
-                            await tokens_callback(
-                                output["response_delta"],
-                                approximate_tokens(output["response_delta"]),
-                            )
-                        # Add output tokens to rate limiter if configured
-                        if limiter:
+                    if limiter:
+                        if output["response_delta"]:
                             limiter.add(output=approximate_tokens(output["response_delta"]))
+                        if output["reasoning_delta"]:
+                            limiter.add(output=approximate_tokens(output["reasoning_delta"]))
 
                 # Successful completion of stream
                 return result.response, result.reasoning
 
             except Exception as e:
                 import asyncio
-                
+
                 # Retry only if no chunks received and error is transient
                 if got_any_chunk or not _is_transient_litellm_error(e) or attempt >= max_retries:
                     raise
@@ -804,6 +818,10 @@ def _parse_chunk(chunk: Any) -> ChatChunk:
         delta.get("reasoning_content", "")
         if isinstance(delta, dict)
         else getattr(delta, "reasoning_content", "")
+    ) or (
+        message.get("reasoning_content", "")
+        if isinstance(message, dict)
+        else getattr(message, "reasoning_content", "")
     )
 
     return ChatChunk(reasoning_delta=reasoning_delta, response_delta=response_delta)

prompts/agent.extras.project.file_structure.md

@@ -0,0 +1,9 @@
+# File structure of project {{project_name}}
+- this is filtered overview not full scan
+- list yourself if needed
+- maximum depth: {{max_depth}}
+- ignored:
+{{gitignore}}
+
+## file tree
+{{file_structure}}

prompts/agent.system.main.tips.md

@@ -7,7 +7,7 @@ never assume success
 memory refers memory tools not own knowledge
 
 ## Files
-save files in /root
+when not in project save files in /root
 don't use spaces in file names
 
 ## Instruments

prompts/agent.system.projects.active.md

@@ -0,0 +1,12 @@
+## Active project
+Path: {{project_path}}
+Title: {{project_name}}
+Description: {{project_description}}
+
+
+### Important project instructions MUST follow
+- always work inside {{project_path}} directory
+- do not rename project directory do not change meta files in .a0proj folder
+- cleanup when code accidentaly creates files outside move them
+
+{{project_instructions}}

prompts/agent.system.projects.inactive.md

@@ -0,0 +1 @@
+no project currently activated

prompts/agent.system.projects.main.md

@@ -0,0 +1,5 @@
+# Projects
+- user can create and activate projects
+- projects have work folder in /usr/projects/<name> and instructions and config in /usr/projects/<name>/.a0proj
+- when activated agent works in project follows project instructions
+- agent cannot manipulate or switch projects

prompts/agent.system.tool.document_query.md

@@ -1,60 +1,62 @@
-### document_query:
-This tool can be used to read or analyze remote and local documents.
-It can be used to:
- *  Get webpage or remote document text content
- *  Get local document text content
- *  Answer queries about a webpage, remote or local document
-By default, when the "queries" argument is empty, this tool returns the text content of the document retrieved using OCR.
-Additionally, you can pass a list of "queries" - in this case, the tool returns the answers to all the passed queries about the document.
-!!! This is a universal document reader qnd query tool
-!!! Supported document formats: HTML, PDF, Office Documents (word,excel, powerpoint), Textfiles and many more.
+### document_query
+read and analyze remote/local documents get text content or answer questions
+pass a single url/path or a list for multiple documents in "document"
+for web documents use "http://" or "https://"" prefix
+for local files "file://" prefix is optional but full path is required
+if "queries" is empty tool returns document content
+if "queries" is a list of strings tool returns answers
+supports various formats HTML PDF Office Text etc
+usage:
 
-#### Arguments:
- *  "document" (string) : The web address or local path to the document in question. Webdocuments need "http://" or "https://" protocol prefix. For local files the "file:" protocol prefix is optional. Local files MUST be passed with full filesystem path.
- *  "queries" (Optional, list[str]) : Optionally, here you can pass one or more queries to be answered (using and/or about) the document
-
-#### Usage example 1:
-##### Request:
-```json
+1 get content
+~~~json
 {
     "thoughts": [
-        "...",
+        "I need to read..."
     ],
-    "headline": "Reading web document content",
+    "headline": "...",
     "tool_name": "document_query",
     "tool_args": {
-        "document": "https://...somexample",
+        "document": "https://.../document"
     }
 }
-```
-##### Response:
-```plaintext
-... Here is the entire content of the web document requested ...
-```
+~~~
 
-#### Usage example 2:
-##### Request:
-```json
+2 query document
+~~~json
 {
     "thoughts": [
-        "...",
+        "I need to answer..."
     ],
-    "headline": "Analyzing document to answer specific questions",
+    "headline": "...",
     "tool_name": "document_query",
     "tool_args": {
-        "document": "https://...somexample",
+        "document": "https://.../document",
         "queries": [
-            "What is the topic?",
-            "Who is the audience?"
+            "What is...",
+            "Who is..."
         ]
     }
 }
-```
-##### Response:
-```plaintext
-# What is the topic?
-... Description of the document topic ...
+~~~
 
-# Who is the audience?
-... The intended document audience list with short descriptions ...
-```
+3 query multiple documents
+~~~json
+{
+    "thoughts": [
+        "I need to compare..."
+    ],
+    "headline": "...",
+    "tool_name": "document_query",
+    "tool_args": {
+        "document": [
+            "https://.../document-one",
+            "file:///path/to/document-two"
+        ],
+        "queries": [
+            "Compare the main conclusions...",
+            "What are the key differences..."
+        ]
+    }
+}
+~~~

prompts/agent.system.tool.wait.md

@@ -0,0 +1,34 @@
+### wait
+pause execution for a set time or until a timestamp
+use args "seconds" "minutes" "hours" "days" for duration
+use "until" with ISO timestamp for a specific time
+usage:
+
+1 wait duration
+~~~json
+{
+    "thoughts": [
+        "I need to wait..."
+    ],
+    "headline": "...",
+    "tool_name": "wait",
+    "tool_args": { 
+        "minutes": 1, 
+        "seconds": 30 
+    }
+}
+~~~
+
+2 wait timestamp
+~~~json
+{
+    "thoughts": [
+        "I will wait until..."
+    ],
+    "headline": "...",
+    "tool_name": "wait",
+    "tool_args": { 
+        "until": "2025-10-20T10:00:00Z" 
+    }
+}
+~~~

prompts/fw.code.running.md

@@ -0,0 +1 @@
+Terminal session {{session}} is still running. Decide to wait for more 'output', 'reset', or use another session number based on situation.

prompts/fw.wait_complete.md

@@ -0,0 +1 @@
+Wait complete. Reached {{target_time}}.

python/api/api_log_get.py

@@ -32,7 +32,7 @@ class ApiLogGet(ApiHandler):
             return Response('{"error": "context_id is required"}', status=400, mimetype="application/json")
 
         # Get context
-        context = AgentContext.get(context_id)
+        context = AgentContext.use(context_id)
         if not context:
             return Response('{"error": "Context not found"}', status=404, mimetype="application/json")
 

python/api/api_message.py

@@ -68,12 +68,13 @@ class ApiMessage(ApiHandler):
 
         # Get or create context
         if context_id:
-            context = AgentContext.get(context_id)
+            context = AgentContext.use(context_id)
             if not context:
                 return Response('{"error": "Context not found"}', status=404, mimetype="application/json")
         else:
             config = initialize_agent()
             context = AgentContext(config=config, type=AgentContextType.USER)
+            AgentContext.use(context.id)
             context_id = context.id
 
         # Update chat lifetime

python/api/api_reset_chat.py

@@ -35,7 +35,7 @@ class ApiResetChat(ApiHandler):
                 )
 
             # Check if context exists
-            context = AgentContext.get(context_id)
+            context = AgentContext.use(context_id)
             if not context:
                 return Response(
                     '{"error": "Chat context not found"}',

python/api/api_terminate_chat.py

@@ -35,7 +35,7 @@ class ApiTerminateChat(ApiHandler):
                 )
 
             # Check if context exists
-            context = AgentContext.get(context_id)
+            context = AgentContext.use(context_id)
             if not context:
                 return Response(
                     '{"error": "Chat context not found"}',

python/api/chat_create.py

@@ -0,0 +1,32 @@
+from python.helpers.api import ApiHandler, Input, Output, Request, Response
+
+
+from python.helpers import projects, guids
+from agent import AgentContext
+
+
+class CreateChat(ApiHandler):
+    async def process(self, input: Input, request: Request) -> Output:
+        current_ctxid = input.get("current_context", "") # current context id
+        new_ctxid = input.get("new_context", guids.generate_id()) # given or new guid
+
+        # context instance - get or create
+        current_context = AgentContext.get(current_ctxid)
+        
+        # get/create new context
+        new_context = self.use_context(new_ctxid)
+
+        # copy selected data from current to new context
+        if current_context:
+            current_data_1 = current_context.get_data(projects.CONTEXT_DATA_KEY_PROJECT)
+            if current_data_1:
+                new_context.set_data(projects.CONTEXT_DATA_KEY_PROJECT, current_data_1)
+            current_data_2 = current_context.get_output_data(projects.CONTEXT_DATA_KEY_PROJECT)
+            if current_data_2:
+                new_context.set_output_data(projects.CONTEXT_DATA_KEY_PROJECT, current_data_2)
+
+        return {
+            "ok": True,
+            "ctxid": new_context.id,
+            "message": "Context created.",
+        }

python/api/chat_export.py

@@ -8,7 +8,7 @@ class ExportChat(ApiHandler):
         if not ctxid:
             raise Exception("No context id provided")
 
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
         content = persist_chat.export_json_chat(context)
         return {
             "message": "Chats exported.",

python/api/chat_files_path_get.py

@@ -0,0 +1,23 @@
+from python.helpers.api import ApiHandler, Request, Response
+from python.helpers import files, memory, notification, projects, notification, runtime
+import os
+from werkzeug.utils import secure_filename
+
+
+class GetChatFilesPath(ApiHandler):
+    async def process(self, input: dict, request: Request) -> dict | Response:
+        ctxid = input.get("ctxid", "")
+        if not ctxid:
+            raise Exception("No context id provided")
+        context = self.use_context(ctxid)
+
+        project_name = projects.get_context_project_name(context)
+        if project_name:
+            folder = files.normalize_a0_path(projects.get_project_folder(project_name))
+        else:
+            folder = "/root" # root in container
+
+        return {
+            "ok": True,
+            "path": folder,
+        }

python/api/chat_remove.py

@@ -8,7 +8,7 @@ class RemoveChat(ApiHandler):
     async def process(self, input: Input, request: Request) -> Output:
         ctxid = input.get("context", "")
 
-        context = AgentContext.get(ctxid)
+        context = AgentContext.use(ctxid)
         if context:
             # stop processing any tasks
             context.reset()

python/api/chat_reset.py

@@ -9,7 +9,7 @@ class Reset(ApiHandler):
         ctxid = input.get("context", "")
 
         # context instance - get or create
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
         context.reset()
         persist_chat.save_tmp_chat(context)
         persist_chat.remove_msg_files(ctxid)

python/api/csrf_token.py

@@ -1,4 +1,5 @@
 import secrets
+from urllib.parse import urlparse
 from python.helpers.api import (
     ApiHandler,
     Input,
@@ -7,7 +8,9 @@ from python.helpers.api import (
     Response,
     session,
 )
-from python.helpers import runtime
+from python.helpers import runtime, dotenv, login
+import fnmatch
+
 
 class GetCsrfToken(ApiHandler):
 
@@ -20,6 +23,90 @@ class GetCsrfToken(ApiHandler):
         return False
 
     async def process(self, input: Input, request: Request) -> Output:
+
+        # check for allowed origin to prevent dns rebinding attacks
+        origin_check = await self.check_allowed_origin(request)
+        if not origin_check["ok"]:
+            return {
+                "ok": False,
+                "error": f"Origin {self.get_origin_from_request(request)} not allowed when login is disabled. Set login and password or add your URL to ALLOWED_ORIGINS env variable. Currently allowed origins: {",".join(origin_check['allowed_origins'])}",
+            }
+
+        # generate a csrf token if it doesn't exist
         if "csrf_token" not in session:
             session["csrf_token"] = secrets.token_urlsafe(32)
-        return {"token": session["csrf_token"], "runtime_id": runtime.get_runtime_id()}
+
+        # return the csrf token and runtime id
+        return {
+            "ok": True,
+            "token": session["csrf_token"],
+            "runtime_id": runtime.get_runtime_id(),
+        }
+
+    async def check_allowed_origin(self, request: Request):
+        # if login is required, this che
+        if login.is_login_required():
+            return {"ok": True, "origin": "", "allowed_origins": ""}
+        # otherwise, check if the origin is allowed
+        return await self.is_allowed_origin(request)
+
+    async def is_allowed_origin(self, request: Request):
+        # get the origin from the request
+        origin = self.get_origin_from_request(request)
+        if not origin:
+            return {"ok": False, "origin": "", "allowed_origins": ""}
+
+        # list of allowed origins
+        allowed_origins = await self.get_allowed_origins()
+
+        # check if the origin is allowed
+        match = any(
+            fnmatch.fnmatch(origin, allowed_origin)
+            for allowed_origin in allowed_origins
+        )
+        return {"ok": match, "origin": origin, "allowed_origins": allowed_origins}
+
+    def get_origin_from_request(self, request: Request):
+        # get from origin
+        r = request.headers.get("Origin") or request.environ.get("HTTP_ORIGIN")
+        if not r:
+            # try referer if origin not present
+            r = (
+                request.headers.get("Referer")
+                or request.referrer
+                or request.environ.get("HTTP_REFERER")
+            )
+        if not r:
+            return None
+        # parse and normalize
+        p = urlparse(r)
+        if not p.scheme or not p.hostname:
+            return None
+        return f"{p.scheme}://{p.hostname}" + (f":{p.port}" if p.port else "")
+
+    async def get_allowed_origins(self) -> list[str]:
+        # get the allowed origins from the environment
+        allowed_origins = [
+            origin.strip()
+            for origin in (dotenv.get_dotenv_value("ALLOWED_ORIGINS") or "").split(",")
+            if origin.strip()
+        ]
+
+        # if there are no allowed origins, allow default localhosts
+        if not allowed_origins:
+            allowed_origins = self.get_default_allowed_origins()
+
+        # always allow tunnel url if running
+        try:
+            from python.api.tunnel_proxy import process as tunnel_api_process
+
+            tunnel = await tunnel_api_process({"action": "get"})
+            if tunnel and isinstance(tunnel, dict) and tunnel["success"]:
+                allowed_origins.append(tunnel["tunnel_url"])
+        except Exception:
+            pass
+
+        return allowed_origins
+
+    def get_default_allowed_origins(self) -> list[str]:
+        return ["*://localhost:*", "*://127.0.0.1:*", "*://0.0.0.0:*"]

python/api/ctx_window_get.py

@@ -6,7 +6,7 @@ from python.helpers import tokens
 class GetCtxWindow(ApiHandler):
     async def process(self, input: Input, request: Request) -> Output:
         ctxid = input.get("context", [])
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
         agent = context.streaming_agent or context.agent0
         window = agent.get_data(agent.DATA_NAME_CTX_WINDOW)
         if not window or not isinstance(window, dict):

python/api/get_work_dir_files.py

@@ -1,6 +1,6 @@
 from python.helpers.api import ApiHandler, Request, Response
 from python.helpers.file_browser import FileBrowser
-from python.helpers import runtime
+from python.helpers import runtime, files
 
 class GetWorkDirFiles(ApiHandler):
 
@@ -15,7 +15,7 @@ class GetWorkDirFiles(ApiHandler):
             #     current_path = "work_dir"
             # else:
             #     current_path = "root"
-            current_path = "root"
+            current_path = "/a0"
 
         # browser = FileBrowser()
         # result = browser.get_files(current_path)

python/api/history_get.py

@@ -4,7 +4,7 @@ from python.helpers.api import ApiHandler, Request, Response
 class GetHistory(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
         ctxid = input.get("context", [])
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
         agent = context.streaming_agent or context.agent0
         history = agent.history.output_text()
         size = agent.history.get_tokens()

python/api/import_knowledge.py

@@ -13,7 +13,7 @@ class ImportKnowledge(ApiHandler):
         if not ctxid:
             raise Exception("No context id provided")
 
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
 
         file_list = request.files.getlist("files[]")
         KNOWLEDGE_FOLDER = files.get_abs_path(memory.get_custom_knowledge_subdir_abs(context.agent0), "main")

python/api/knowledge_path_get.py

@@ -0,0 +1,25 @@
+from python.helpers.api import ApiHandler, Request, Response
+from python.helpers import files, memory, notification, projects, notification
+import os
+from werkzeug.utils import secure_filename
+
+
+class GetKnowledgePath(ApiHandler):
+    async def process(self, input: dict, request: Request) -> dict | Response:
+        ctxid = input.get("ctxid", "")
+        if not ctxid:
+            raise Exception("No context id provided")
+        context = self.use_context(ctxid)
+
+        project_name = projects.get_context_project_name(context)
+        if project_name:
+            knowledge_folder = projects.get_project_meta_folder(project_name, "knowledge")
+        else:
+            knowledge_folder = memory.get_custom_knowledge_subdir_abs(context.agent0)
+
+        knowledge_folder = files.normalize_a0_path(knowledge_folder)
+
+        return {
+            "ok": True,
+            "path": knowledge_folder,
+        }

python/api/knowledge_reindex.py

@@ -0,0 +1,21 @@
+from python.helpers.api import ApiHandler, Request, Response
+from python.helpers import files, memory, notification, projects, notification
+import os
+from werkzeug.utils import secure_filename
+
+
+class ReindexKnowledge(ApiHandler):
+    async def process(self, input: dict, request: Request) -> dict | Response:
+        ctxid = input.get("ctxid", "")
+        if not ctxid:
+            raise Exception("No context id provided")
+        context = self.use_context(ctxid)
+
+        # reload memory to re-import knowledge
+        await memory.Memory.reload(context.agent0)
+        context.log.set_initial_progress()
+
+        return {
+            "ok": True,
+            "message": "Knowledge re-indexed",
+        }

python/api/memory_dashboard.py

@@ -1,8 +1,9 @@
 from python.helpers.api import ApiHandler, Request, Response
-from python.helpers.memory import Memory
+from python.helpers.memory import Memory, get_existing_memory_subdirs, get_context_memory_subdir
 from python.helpers import files
 from models import ModelConfig, ModelType
 from langchain_core.documents import Document
+from agent import AgentContext
 
 
 class MemoryDashboard(ApiHandler):
@@ -113,21 +114,13 @@ class MemoryDashboard(ApiHandler):
                 # Fallback to default if no context available
                 return {"success": True, "memory_subdir": "default"}
 
-            # Import AgentContext here to avoid circular imports
-            from agent import AgentContext
-
-            # Get the context and extract memory subdirectory
-            context = AgentContext.get(context_id)
-            if (
-                context
-                and hasattr(context, "config")
-                and hasattr(context.config, "memory_subdir")
-            ):
-                memory_subdir = context.config.memory_subdir or "default"
-                return {"success": True, "memory_subdir": memory_subdir}
-            else:
+            context = AgentContext.use(context_id)
+            if not context:
                 return {"success": True, "memory_subdir": "default"}
 
+            memory_subdir = get_context_memory_subdir(context)
+            return {"success": True, "memory_subdir": memory_subdir or "default"}
+
         except Exception:
             return {
                 "success": True,  # Still success, just fallback to default
@@ -138,12 +131,7 @@ class MemoryDashboard(ApiHandler):
         """Get available memory subdirectories."""
         try:
             # Get subdirectories from memory folder
-            subdirs = files.get_subdirectories("memory", exclude="embeddings")
-
-            # Ensure 'default' is always available
-            if "default" not in subdirs:
-                subdirs.insert(0, "default")
-
+            subdirs = get_existing_memory_subdirs()
             return {"success": True, "subdirs": subdirs}
         except Exception as e:
             return {

python/api/message.py

@@ -53,7 +53,7 @@ class Message(ApiHandler):
         message = text
 
         # Obtain agent context
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
 
         # Store attachments in agent data
         # context.agent0.set_data("attachments", attachment_paths)

python/api/nudge.py

@@ -6,7 +6,7 @@ class Nudge(ApiHandler):
         if not ctxid:
             raise Exception("No context id provided")
 
-        context = self.get_context(ctxid)
+        context = self.use_context(ctxid)
         context.nudge()
 
         msg = "Process reset, agent nudged."

python/api/pause.py

@@ -8,7 +8,7 @@ class Pause(ApiHandler):
             ctxid = input.get("context", "")
 
             # context instance - get or create
-            context = self.get_context(ctxid)
+            context = self.use_context(ctxid)
 
             context.paused = paused
 

python/api/poll.py

@@ -18,10 +18,17 @@ class Poll(ApiHandler):
         timezone = input.get("timezone", get_dotenv_value("DEFAULT_USER_TIMEZONE", "UTC"))
         Localization.get().set_timezone(timezone)
 
-        # context instance - get or create
-        context = self.get_context(ctxid)
-
-        logs = context.log.output(start=from_no)
+        # context instance - get or create only if ctxid is provided
+        if ctxid:
+            try:
+                context = self.use_context(ctxid, create_if_not_exists=False)
+            except Exception as e:
+                context = None
+        else:
+            context = None
+
+        # Get logs only if we have a context
+        logs = context.log.output(start=from_no) if context else []
 
         # Get notifications from global notification manager
         notification_manager = AgentContext.get_notification_manager()
@@ -54,7 +61,7 @@ class Poll(ApiHandler):
                 continue
 
             # Create the base context data that will be returned
-            context_data = ctx.serialize()
+            context_data = ctx.output()
 
             context_task = scheduler.get_task_by_uuid(ctx.id)
             # Determine if this is a task-dedicated context by checking if a task with this UUID exists
@@ -102,15 +109,16 @@ class Poll(ApiHandler):
 
         # data from this server
         return {
-            "context": context.id,
+            "deselect_chat": ctxid and not context,
+            "context": context.id if context else "",
             "contexts": ctxs,
             "tasks": tasks,
             "logs": logs,
-            "log_guid": context.log.guid,
-            "log_version": len(context.log.updates),
-            "log_progress": context.log.progress,
-            "log_progress_active": context.log.progress_active,
-            "paused": context.paused,
+            "log_guid": context.log.guid if context else "",
+            "log_version": len(context.log.updates) if context else 0,
+            "log_progress": context.log.progress if context else 0,
+            "log_progress_active": context.log.progress_active if context else False,
+            "paused": context.paused if context else False,
             "notifications": notifications,
             "notifications_guid": notification_manager.guid,
             "notifications_version": len(notification_manager.updates),

python/api/projects.py

@@ -0,0 +1,91 @@
+from python.helpers.api import ApiHandler, Input, Output, Request, Response
+from python.helpers import projects
+
+
+class Projects(ApiHandler):
+    async def process(self, input: Input, request: Request) -> Output:
+        action = input.get("action", "")
+        ctxid = input.get("context_id", None)
+
+        if ctxid:
+            _context = self.use_context(ctxid)
+
+        try:
+            if action == "list":
+                data = self.get_active_projects_list()
+            elif action == "load":
+                data = self.load_project(input.get("name", None))
+            elif action == "create":
+                data = self.create_project(input.get("project", None))
+            elif action == "update":
+                data = self.update_project(input.get("project", None))
+            elif action == "delete":
+                data = self.delete_project(input.get("name", None))
+            elif action == "activate":
+                data = self.activate_project(ctxid, input.get("name", None))
+            elif action == "deactivate":
+                data = self.deactivate_project(ctxid)
+            elif action == "file_structure":
+                data = self.get_file_structure(input.get("name", None), input.get("settings"))
+            else:
+                raise Exception("Invalid action")
+
+            return {
+                "ok": True,
+                "data": data,
+            }
+        except Exception as e:
+            return {
+                "ok": False,
+                "error": str(e),
+            }
+
+    def get_active_projects_list(self):
+        return projects.get_active_projects_list()
+
+    def create_project(self, project: dict|None):
+        if project is None:
+            raise Exception("Project data is required")
+        data = projects.BasicProjectData(**project)
+        name = projects.create_project(project["name"], data)
+        return projects.load_edit_project_data(name)
+
+    def load_project(self, name: str|None):
+        if name is None:
+            raise Exception("Project name is required")
+        return projects.load_edit_project_data(name)
+
+    def update_project(self, project: dict|None):
+        if project is None:
+            raise Exception("Project data is required")
+        data = projects.EditProjectData(**project)
+        name = projects.update_project(project["name"], data)
+        return projects.load_edit_project_data(name)
+
+    def delete_project(self, name: str|None):
+        if name is None:
+            raise Exception("Project name is required")
+        return projects.delete_project(name)
+
+    def activate_project(self, context_id: str|None, name: str|None):
+        if not context_id:
+            raise Exception("Context ID is required")
+        if not name:
+            raise Exception("Project name is required") 
+        return projects.activate_project(context_id, name)
+
+    def deactivate_project(self, context_id: str|None):
+        if not context_id:
+            raise Exception("Context ID is required")
+        return projects.deactivate_project(context_id)
+
+    def get_file_structure(self, name: str|None, settings: dict|None):
+        if not name:
+            raise Exception("Project name is required")
+        # project data
+        basic_data = projects.load_basic_project_data(name)
+        # override file structure settings
+        if settings:
+            basic_data["file_structure"] = settings # type: ignore
+        # get structure
+        return projects.get_file_structure(name, basic_data)

python/api/scheduler_task_create.py

@@ -3,6 +3,7 @@ from python.helpers.task_scheduler import (
     TaskScheduler, ScheduledTask, AdHocTask, PlannedTask, TaskSchedule,
     serialize_task, parse_task_schedule, parse_task_plan, TaskType
 )
+from python.helpers.projects import load_basic_project_data
 from python.helpers.localization import Localization
 from python.helpers.print_style import PrintStyle
 import random
@@ -27,7 +28,26 @@ class SchedulerTaskCreate(ApiHandler):
         system_prompt = input.get("system_prompt", "")
         prompt = input.get("prompt")
         attachments = input.get("attachments", [])
-        context_id = input.get("context_id", None)
+
+        requested_project_slug = input.get("project_name")
+        if isinstance(requested_project_slug, str):
+            requested_project_slug = requested_project_slug.strip() or None
+        else:
+            requested_project_slug = None
+
+        project_slug = requested_project_slug
+        project_color = None
+
+        if project_slug:
+            try:
+                metadata = load_basic_project_data(requested_project_slug)
+                project_color = metadata.get("color") or None
+            except Exception as exc:
+                printer.error(f"SchedulerTaskCreate: failed to load project '{project_slug}': {exc}")
+                return {"error": f"Saving project failed: {project_slug}"}
+
+        # Always dedicated context for scheduler tasks created by ui
+        task_context_id = None
 
         # Check if schedule is provided (for ScheduledTask)
         schedule = input.get("schedule", {})
@@ -77,8 +97,10 @@ class SchedulerTaskCreate(ApiHandler):
                 prompt=prompt,
                 schedule=task_schedule,
                 attachments=attachments,
-                context_id=context_id,
-                timezone=timezone
+                context_id=task_context_id,
+                timezone=timezone,
+                project_name=project_slug,
+                project_color=project_color,
             )
         elif plan:
             # Create a planned task
@@ -94,7 +116,9 @@ class SchedulerTaskCreate(ApiHandler):
                 prompt=prompt,
                 plan=task_plan,
                 attachments=attachments,
-                context_id=context_id
+                context_id=task_context_id,
+                project_name=project_slug,
+                project_color=project_color,
             )
         else:
             # Create an ad-hoc task
@@ -105,7 +129,9 @@ class SchedulerTaskCreate(ApiHandler):
                 prompt=prompt,
                 token=token,
                 attachments=attachments,
-                context_id=context_id
+                context_id=task_context_id,
+                project_name=project_slug,
+                project_color=project_color,
             )
             # Verify token after creation
             if isinstance(task, AdHocTask):
@@ -132,5 +158,6 @@ class SchedulerTaskCreate(ApiHandler):
             printer.print(f"Serialized adhoc task, token in response: '{task_dict.get('token')}'")
 
         return {
+            "ok": True,
             "task": task_dict
         }

python/api/scheduler_task_delete.py

@@ -30,7 +30,7 @@ class SchedulerTaskDelete(ApiHandler):
 
         context = None
         if task.context_id:
-            context = self.get_context(task.context_id)
+            context = self.use_context(task.context_id)
 
         # If the task is running, update its state to IDLE first
         if task.state == TaskState.RUNNING:

python/api/scheduler_task_update.py

@@ -48,6 +48,9 @@ class SchedulerTaskUpdate(ApiHandler):
         if "attachments" in input:
             update_params["attachments"] = input.get("attachments", [])
 
+        if "project_name" in input or "project_color" in input:
+            return {"error": "Project changes are not allowed"}
+
         # Update schedule if this is a scheduled task and schedule is provided
         if isinstance(task, ScheduledTask) and "schedule" in input:
             schedule_data = input.get("schedule", {})
@@ -85,5 +88,6 @@ class SchedulerTaskUpdate(ApiHandler):
         task_dict = serialize_task(updated_task)
 
         return {
+            "ok": True,
             "task": task_dict
         }

python/api/scheduler_tasks_list.py

@@ -22,8 +22,8 @@ class SchedulerTasksList(ApiHandler):
             # Use the scheduler's convenience method for task serialization
             tasks_list = scheduler.serialize_all_tasks()
 
-            return {"tasks": tasks_list}
+            return {"ok": True, "tasks": tasks_list}
 
         except Exception as e:
             PrintStyle.error(f"Failed to list tasks: {str(e)} {traceback.format_exc()}")
-            return {"error": f"Failed to list tasks: {str(e)} {traceback.format_exc()}", "tasks": []}
+            return {"ok": False, "error": f"Failed to list tasks: {str(e)} {traceback.format_exc()}", "tasks": []}

python/api/synthesize.py

@@ -7,9 +7,11 @@ from python.helpers import runtime, settings, kokoro_tts
 class Synthesize(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
         text = input.get("text", "")
-        # ctxid = input.get("ctxid", "")
+        ctxid = input.get("ctxid", "")
         
-        # context = self.get_context(ctxid)
+        if ctxid:
+            context = self.use_context(ctxid)
+
         # if not await kokoro_tts.is_downloaded():
         #     context.log.log(type="info", content="Kokoro TTS model is currently being initialized, please wait...")
 

python/api/transcribe.py

@@ -5,9 +5,11 @@ from python.helpers import runtime, settings, whisper
 class Transcribe(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
         audio = input.get("audio")
-        # ctxid = input.get("ctxid", "")
+        ctxid = input.get("ctxid", "")
+
+        if ctxid:
+            context = self.use_context(ctxid)
 
-        # context = self.get_context(ctxid)
         # if not await whisper.is_downloaded():
         #     context.log.log(type="info", content="Whisper STT model is currently being initialized, please wait...")
 

python/api/tunnel.py

@@ -4,48 +4,51 @@ from python.helpers.tunnel_manager import TunnelManager
 
 class Tunnel(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
-        action = input.get("action", "get")
-        
-        tunnel_manager = TunnelManager.get_instance()
+        return await process(input)
 
-        if action == "health":
-            return {"success": True}
-        
-        if action == "create":
-            port = runtime.get_web_ui_port()
-            provider = input.get("provider", "serveo")  # Default to serveo
-            tunnel_url = tunnel_manager.start_tunnel(port, provider)
-            if tunnel_url is None:
-                # Add a little delay and check again - tunnel might be starting
-                import time
-                time.sleep(2)
-                tunnel_url = tunnel_manager.get_tunnel_url()
-            
-            return {
-                "success": tunnel_url is not None,
-                "tunnel_url": tunnel_url,
-                "message": "Tunnel creation in progress" if tunnel_url is None else "Tunnel created successfully"
-            }
-        
-        elif action == "stop":
-            return self.stop()
-        
-        elif action == "get":
+async def process(input: dict) -> dict | Response:
+    action = input.get("action", "get")
+    
+    tunnel_manager = TunnelManager.get_instance()
+
+    if action == "health":
+        return {"success": True}
+    
+    if action == "create":
+        port = runtime.get_web_ui_port()
+        provider = input.get("provider", "serveo")  # Default to serveo
+        tunnel_url = tunnel_manager.start_tunnel(port, provider)
+        if tunnel_url is None:
+            # Add a little delay and check again - tunnel might be starting
+            import time
+            time.sleep(2)
             tunnel_url = tunnel_manager.get_tunnel_url()
-            return {
-                "success": tunnel_url is not None,
-                "tunnel_url": tunnel_url,
-                "is_running": tunnel_manager.is_running
-            }
         
         return {
-            "success": False,
-            "error": "Invalid action. Use 'create', 'stop', or 'get'."
-        } 
-
-    def stop(self):
-        tunnel_manager = TunnelManager.get_instance()
-        tunnel_manager.stop_tunnel()
+            "success": tunnel_url is not None,
+            "tunnel_url": tunnel_url,
+            "message": "Tunnel creation in progress" if tunnel_url is None else "Tunnel created successfully"
+        }
+    
+    elif action == "stop":
+        return stop()
+    
+    elif action == "get":
+        tunnel_url = tunnel_manager.get_tunnel_url()
         return {
-            "success": True
+            "success": tunnel_url is not None,
+            "tunnel_url": tunnel_url,
+            "is_running": tunnel_manager.is_running
         }
+    
+    return {
+        "success": False,
+        "error": "Invalid action. Use 'create', 'stop', or 'get'."
+    } 
+
+def stop():
+    tunnel_manager = TunnelManager.get_instance()
+    tunnel_manager.stop_tunnel()
+    return {
+        "success": True
+    }

python/api/tunnel_proxy.py

@@ -6,30 +6,33 @@ import requests
 
 class TunnelProxy(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
-        # Get configuration from environment
-        tunnel_api_port = (
-            runtime.get_arg("tunnel_api_port")
-            or int(dotenv.get_dotenv_value("TUNNEL_API_PORT", 0))
-            or 55520
-        )
+        return await process(input)
 
-        # first verify the service is running:
+async def process(input: dict) -> dict | Response:
+    # Get configuration from environment
+    tunnel_api_port = (
+        runtime.get_arg("tunnel_api_port")
+        or int(dotenv.get_dotenv_value("TUNNEL_API_PORT", 0))
+        or 55520
+    )
+
+    # first verify the service is running:
+    service_ok = False
+    try:
+        response = requests.post(f"http://localhost:{tunnel_api_port}/", json={"action": "health"})
+        if response.status_code == 200:
+            service_ok = True
+    except Exception as e:
         service_ok = False
+
+    # forward this request to the tunnel service if OK
+    if service_ok:
         try:
-            response = requests.post(f"http://localhost:{tunnel_api_port}/", json={"action": "health"})
-            if response.status_code == 200:
-                service_ok = True
+            response = requests.post(f"http://localhost:{tunnel_api_port}/", json=input)
+            return response.json()
         except Exception as e:
-            service_ok = False
-
-        # forward this request to the tunnel service if OK
-        if service_ok:
-            try:
-                response = requests.post(f"http://localhost:{tunnel_api_port}/", json=input)
-                return response.json()
-            except Exception as e:
-                return {"error": str(e)}
-        else:
-            # forward to API handler directly
-            from python.api.tunnel import Tunnel
-            return await Tunnel(self.app, self.thread_lock).process(input, request)
+            return {"error": str(e)}
+    else:
+        # forward to API handler directly
+        from python.api.tunnel import process as local_process
+        return await local_process(input)

python/extensions/error_format/_10_mask_errors.py

@@ -1,5 +1,5 @@
 from python.helpers.extension import Extension
-from python.helpers.secrets import SecretsManager
+from python.helpers.secrets import get_secrets_manager
 
 
 class MaskErrorSecrets(Extension):
@@ -10,7 +10,7 @@ class MaskErrorSecrets(Extension):
         if not msg:
             return
 
-        secrets_mgr = SecretsManager.get_instance()
+        secrets_mgr = get_secrets_manager(self.agent.context)
 
         # Mask the error message
         if "message" in msg:

python/extensions/hist_add_before/_10_mask_content.py

@@ -1,4 +1,5 @@
 from python.helpers.extension import Extension
+from python.helpers.secrets import get_secrets_manager
 
 
 class MaskHistoryContent(Extension):
@@ -10,8 +11,7 @@ class MaskHistoryContent(Extension):
             return
 
         try:
-            from python.helpers.secrets import SecretsManager
-            secrets_mgr = SecretsManager.get_instance()
+            secrets_mgr = get_secrets_manager(self.agent.context)
 
             # Mask the content before adding to history
             content_data["content"] = self._mask_content(content_data["content"], secrets_mgr)

python/extensions/message_loop_prompts_after/_75_include_project_extras.py

@@ -0,0 +1,47 @@
+from python.helpers.extension import Extension
+from agent import LoopData
+from python.helpers import projects
+
+
+class IncludeProjectExtras(Extension):
+    async def execute(self, loop_data: LoopData = LoopData(), **kwargs):
+
+        # active project
+        project_name = projects.get_context_project_name(self.agent.context)
+        if not project_name:
+            return
+
+        # project config
+        project = projects.load_basic_project_data(project_name)
+
+        # load file structure if enabled
+        if project["file_structure"]["enabled"]:
+            file_structure = projects.get_file_structure(project_name)
+            gitignore = cleanup_gitignore(project["file_structure"]["gitignore"])
+
+            # read prompt
+            file_structure_prompt = self.agent.read_prompt(
+                "agent.extras.project.file_structure.md",
+                max_depth=project["file_structure"]["max_depth"],
+                gitignore=gitignore,
+                project_name=project_name,
+                file_structure=file_structure,
+            )
+            # add file structure to the prompt
+            loop_data.extras_temporary["project_file_structure"] = file_structure_prompt
+
+
+def cleanup_gitignore(gitignore_raw: str) -> str:
+    """Process gitignore: split lines, strip, remove comments, remove empty lines."""
+    gitignore_lines = []
+    for line in gitignore_raw.split('\n'):
+        # Strip whitespace
+        line = line.strip()
+        # Remove inline comments (everything after #)
+        if '#' in line:
+            line = line.split('#')[0].strip()
+        # Keep only non-empty lines
+        if line:
+            gitignore_lines.append(line)
+    
+    return '\n'.join(gitignore_lines) if gitignore_lines else "nothing ignored"