dev merge

python/api/import_knowledge.py

@@ -2,7 +2,7 @@ from python.helpers.api import ApiHandler
 from flask import Request, Response
 
 from python.helpers.file_browser import FileBrowser
-from python.helpers import files
+from python.helpers import files, memory
 import os
 from werkzeug.utils import secure_filename
 
@@ -12,8 +12,14 @@ class ImportKnowledge(ApiHandler):
         if "files[]" not in request.files:
             raise Exception("No files part")
 
+        ctxid = request.form.get("ctxid", "")
+        if not ctxid:
+            raise Exception("No context id provided")
+
+        context = self.get_context(ctxid)
+
         file_list = request.files.getlist("files[]")
-        KNOWLEDGE_FOLDER = files.get_abs_path("knowledge/custom/main")
+        KNOWLEDGE_FOLDER = files.get_abs_path(memory.get_custom_knowledge_subdir_abs(context.agent0),"main")
 
         saved_filenames = []
 
@@ -23,4 +29,11 @@ class ImportKnowledge(ApiHandler):
                 file.save(os.path.join(KNOWLEDGE_FOLDER, filename))
                 saved_filenames.append(filename)
 
-        return {"message": "Knowledge Imported", "filenames": saved_filenames}
+        #reload memory to re-import knowledge
+        await memory.Memory.reload(context.agent0)
+        context.log.set_initial_progress()
+
+        return {
+            "message": "Knowledge Imported",
+            "filenames": saved_filenames[:5]
+        }

python/api/nudge.py

@@ -1,8 +1,6 @@
 from python.helpers.api import ApiHandler
 from flask import Request, Response
 
-from python.helpers import persist_chat
-
 class Nudge(ApiHandler):
     async def process(self, input: dict, request: Request) -> dict | Response:
         ctxid = input.get("ctxid", "")

python/api/poll.py

@@ -35,5 +35,6 @@ class Poll(ApiHandler):
             "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,
         }

python/extensions/message_loop_prompts/_50_recall_memories.py

@@ -1,29 +1,36 @@
+import asyncio
 from python.helpers.extension import Extension
 from python.helpers.memory import Memory
 from agent import LoopData
 
+DATA_NAME_TASK = "_recall_memories_task"
 
 class RecallMemories(Extension):
 
     INTERVAL = 3
-    HISTORY = 5 # TODO cleanup
+    HISTORY = 5  # TODO cleanup
     RESULTS = 3
     THRESHOLD = 0.6
 
     async def execute(self, loop_data: LoopData = LoopData(), **kwargs):
 
-        if (
-            loop_data.iteration % RecallMemories.INTERVAL == 0
-        ):  # every 3 iterations (or the first one) recall memories
-            await self.search_memories(loop_data=loop_data, **kwargs)
+        # every 3 iterations (or the first one) recall memories
+        if loop_data.iteration % RecallMemories.INTERVAL == 0:
+            task = asyncio.create_task(self.search_memories(loop_data=loop_data, **kwargs))
+        else:
+            task = None
+
+        # set to agent to be able to wait for it
+        self.agent.set_data(DATA_NAME_TASK, task)
+            
 
     async def search_memories(self, loop_data: LoopData, **kwargs):
 
-        #cleanup
+        # cleanup
         extras = loop_data.extras_temporary
         if "memories" in extras:
             del extras["memories"]
-        
+
         # try:
         # show temp info message
         self.agent.context.log.log(
@@ -51,7 +58,9 @@ class RecallMemories(Extension):
 
         # call util llm to summarize conversation
         query = await self.agent.call_utility_llm(
-            system=system, msg=loop_data.user_message.output_text() if loop_data.user_message else "", callback=log_callback
+            system=system,
+            msg=loop_data.user_message.output_text() if loop_data.user_message else "",
+            callback=log_callback,
         )
 
         # get solutions database
@@ -91,7 +100,7 @@ class RecallMemories(Extension):
 
         # append to prompt
         extras["memories"] = memories_prompt
-        
+
     # except Exception as e:
     #     err = errors.format_error(e)
     #     self.agent.context.log.log(

python/extensions/message_loop_prompts/_51_recall_solutions.py

@@ -1,7 +1,9 @@
+import asyncio
 from python.helpers.extension import Extension
 from python.helpers.memory import Memory
 from agent import LoopData
 
+DATA_NAME_TASK = "_recall_solutions_task"
 
 class RecallSolutions(Extension):
 
@@ -13,10 +15,14 @@ class RecallSolutions(Extension):
 
     async def execute(self, loop_data: LoopData = LoopData(), **kwargs):
 
-        if (
-            loop_data.iteration % RecallSolutions.INTERVAL == 0
-        ):  # every 3 iterations (or the first one) recall solution memories
-            await self.search_solutions(loop_data=loop_data, **kwargs)
+        # every 3 iterations (or the first one) recall memories
+        if loop_data.iteration % RecallSolutions.INTERVAL == 0:
+            task = asyncio.create_task(self.search_solutions(loop_data=loop_data, **kwargs))
+        else:
+            task = None
+
+        # set to agent to be able to wait for it
+        self.agent.set_data(DATA_NAME_TASK, task)
 
     async def search_solutions(self, loop_data: LoopData, **kwargs):
 

python/extensions/message_loop_prompts/_90_organize_history_wait.py

@@ -15,7 +15,7 @@ class OrganizeHistoryWait(Extension):
             # Check if the task is already done
             if task:
                 if not task.done():
-                    self.log()
+                    self.agent.context.log.set_progress("Compressing history...")
 
                 # Wait for the task to complete
                 await task
@@ -24,11 +24,6 @@ class OrganizeHistoryWait(Extension):
                 self.agent.set_data(DATA_NAME_TASK, None)
             else:
                 # no task running, start and wait
-                self.log()
+                self.agent.context.log.set_progress("Compressing history...")
                 await self.agent.history.compress()
 
-    def log(self):
-        if not hasattr(self, 'log_item') or not self.log_item:
-            self.log_item = self.agent.context.log.log(
-                type="util", heading="Waiting for history to be compressed..."
-            )

python/extensions/message_loop_prompts/_91_recall_wait.py

@@ -0,0 +1,19 @@
+from python.helpers.extension import Extension
+from agent import LoopData
+from python.extensions.message_loop_prompts._50_recall_memories import DATA_NAME_TASK as DATA_NAME_TASK_MEMORIES
+from python.extensions.message_loop_prompts._51_recall_solutions import DATA_NAME_TASK as DATA_NAME_TASK_SOLUTIONS
+
+
+class RecallWait(Extension):
+    async def execute(self, loop_data: LoopData = LoopData(), **kwargs):
+
+            task = self.agent.get_data(DATA_NAME_TASK_MEMORIES)
+            if task and not task.done():
+                self.agent.context.log.set_progress("Recalling memories...")
+                await task
+
+            task = self.agent.get_data(DATA_NAME_TASK_SOLUTIONS)
+            if task and not task.done():
+                self.agent.context.log.set_progress("Recalling solutions...")
+                await task
+

python/extensions/monologue_end/_90_waiting_for_input_msg.py

@@ -6,7 +6,5 @@ class WaitingForInputMsg(Extension):
     async def execute(self, loop_data: LoopData = LoopData(), **kwargs):
         # show temp info message
         if self.agent.number == 0:
-            self.agent.context.log.log(
-                type="util", heading="Waiting for input", temp=True
-            )
+            self.agent.context.log.set_initial_progress()
 

python/helpers/log.py

@@ -5,165 +5,172 @@ import uuid
 from collections import OrderedDict  # Import OrderedDict
 
 Type = Literal[
-  "agent",
-  "code_exe",
-  "error",
-  "hint",
-  "info",
-  "progress",
-  "response",
-  "tool",
-  "user",
-  "util",
-  "warning",
+    "agent",
+    "code_exe",
+    "error",
+    "hint",
+    "info",
+    "progress",
+    "response",
+    "tool",
+    "input",
+    "user",
+    "util",
+    "warning",
 ]
 
 @dataclass
 class LogItem:
-  log: "Log"
-  no: int
-  type: str
-  heading: str
-  content: str
-  temp: bool
-  kvps: Optional[OrderedDict] = None  # Use OrderedDict for kvps
-  id: Optional[str] = None  # Add id field
-  guid: str = ""
-
-  def __post_init__(self):
-      self.guid = self.log.guid
-
-  def update(
-      self,
-      type: Type | None = None,
-      heading: str | None = None,
-      content: str | None = None,
-      kvps: dict | None = None,
-      temp: bool | None = None,
-      **kwargs,
-  ):
-      if self.guid == self.log.guid:
-          self.log.update_item(
-              self.no,
-              type=type,
-              heading=heading,
-              content=content,
-              kvps=kvps,
-              temp=temp,
-              **kwargs,
-          )
-
-  def stream(self, heading: str | None = None, content: str | None = None, **kwargs):
-      if heading is not None:
-          self.update(heading=self.heading + heading)
-      if content is not None:
-          self.update(content=self.content + content)
-
-      for k, v in kwargs.items():
-          prev = self.kvps.get(k, "") if self.kvps else ""
-          self.update(**{k: prev + v})
-
-  def output(self):
-      return {
-          "no": self.no,
-          "id": self.id,  # Include id in output
-          "type": self.type,
-          "heading": self.heading,
-          "content": self.content,
-          "temp": self.temp,
-          "kvps": self.kvps,
-      }
+    log: "Log"
+    no: int
+    type: str
+    heading: str
+    content: str
+    temp: bool
+    kvps: Optional[OrderedDict] = None  # Use OrderedDict for kvps
+    id: Optional[str] = None  # Add id field
+    guid: str = ""
+
+    def __post_init__(self):
+        self.guid = self.log.guid
+
+    def update(
+        self,
+        type: Type | None = None,
+        heading: str | None = None,
+        content: str | None = None,
+        kvps: dict | None = None,
+        temp: bool | None = None,
+        **kwargs,
+    ):
+        if self.guid == self.log.guid:
+            self.log.update_item(
+                self.no,
+                type=type,
+                heading=heading,
+                content=content,
+                kvps=kvps,
+                temp=temp,
+                **kwargs,
+            )
+
+    def stream(self, heading: str | None = None, content: str | None = None, **kwargs):
+        if heading is not None:
+            self.update(heading=self.heading + heading)
+        if content is not None:
+            self.update(content=self.content + content)
+
+        for k, v in kwargs.items():
+            prev = self.kvps.get(k, "") if self.kvps else ""
+            self.update(**{k: prev + v})
+
+    def output(self):
+        return {
+            "no": self.no,
+            "id": self.id,  # Include id in output
+            "type": self.type,
+            "heading": self.heading,
+            "content": self.content,
+            "temp": self.temp,
+            "kvps": self.kvps,
+        }
 
 class Log:
 
-  def __init__(self):
-      self.guid: str = str(uuid.uuid4())
-      self.updates: list[int] = []
-      self.logs: list[LogItem] = []
-      self.progress = ""
-      self.progress_no = 0
-
-  def log(
-      self,
-      type: Type,
-      heading: str | None = None,
-      content: str | None = None,
-      kvps: dict | None = None,
-      temp: bool | None = None,
-      id: Optional[str] = None,  # Add id parameter
-  ) -> LogItem:
-      # Use OrderedDict if kvps is provided
-      if kvps is not None:
-          kvps = OrderedDict(kvps)
-      item = LogItem(
-          log=self,
-          no=len(self.logs),
-          type=type,
-          heading=heading or "",
-          content=content or "",
-          kvps=kvps,
-          temp=temp or False,
-          id=id,  # Pass id to LogItem
-      )
-      self.logs.append(item)
-      self.updates += [item.no]
-      if heading and item.no >= self.progress_no:
-          self.progress = heading
-          self.progress_no = item.no
-      return item
-
-  def update_item(
-      self,
-      no: int,
-      type: str | None = None,
-      heading: str | None = None,
-      content: str | None = None,
-      kvps: dict | None = None,
-      temp: bool | None = None,
-      **kwargs,
-  ):
-      item = self.logs[no]
-      if type is not None:
-          item.type = type
-      if heading is not None:
-          item.heading = heading
-          if no >= self.progress_no:
-              self.progress = heading
-              self.progress_no = no
-      if content is not None:
-          item.content = content
-      if kvps is not None:
-          item.kvps = OrderedDict(kvps)  # Use OrderedDict to keep the order
-
-      if temp is not None:
-          item.temp = temp
-
-      if kwargs:
-          if item.kvps is None:
-              item.kvps = OrderedDict()  # Ensure kvps is an OrderedDict
-          for k, v in kwargs.items():
-              item.kvps[k] = v
-
-      self.updates += [item.no]
-
-  def output(self, start=None, end=None):        
-      if start is None:
-          start = 0
-      if end is None:
-          end = len(self.updates)
-
-      out = []
-      seen = set()
-      for update in self.updates[start:end]:
-          if update not in seen:
-              out.append(self.logs[update].output())
-              seen.add(update)
-
-      return out
-
-  def reset(self):
-      self.guid = str(uuid.uuid4())
-      self.updates = []
-      self.logs = []
-      self.progress = ""
-      self.progress_no = 0
+    def __init__(self):
+        self.guid: str = str(uuid.uuid4())
+        self.updates: list[int] = []
+        self.logs: list[LogItem] = []
+        self.set_initial_progress()
+
+    def log(
+        self,
+        type: Type,
+        heading: str | None = None,
+        content: str | None = None,
+        kvps: dict | None = None,
+        temp: bool | None = None,
+        id: Optional[str] = None,  # Add id parameter
+    ) -> LogItem:
+        # Use OrderedDict if kvps is provided
+        if kvps is not None:
+            kvps = OrderedDict(kvps)
+        item = LogItem(
+            log=self,
+            no=len(self.logs),
+            type=type,
+            heading=heading or "",
+            content=content or "",
+            kvps=kvps,
+            temp=temp or False,
+            id=id,  # Pass id to LogItem
+        )
+        self.logs.append(item)
+        self.updates += [item.no]
+        if heading and item.no >= self.progress_no:
+            self.set_progress(heading, item.no)
+        return item
+
+    def update_item(
+        self,
+        no: int,
+        type: str | None = None,
+        heading: str | None = None,
+        content: str | None = None,
+        kvps: dict | None = None,
+        temp: bool | None = None,
+        **kwargs,
+    ):
+        item = self.logs[no]
+        if type is not None:
+            item.type = type
+        if heading is not None:
+            item.heading = heading
+            if no >= self.progress_no:
+                self.set_progress(heading, no)
+        if content is not None:
+            item.content = content
+        if kvps is not None:
+            item.kvps = OrderedDict(kvps)  # Use OrderedDict to keep the order
+
+        if temp is not None:
+            item.temp = temp
+
+        if kwargs:
+            if item.kvps is None:
+                item.kvps = OrderedDict()  # Ensure kvps is an OrderedDict
+            for k, v in kwargs.items():
+                item.kvps[k] = v
+
+        self.updates += [item.no]
+
+    def set_progress(self, progress: str, no: int = 0, active: bool = True):
+        self.progress = progress
+        if not no:
+            no = len(self.logs)
+        self.progress_no = no
+        self.progress_active = active
+
+    def set_initial_progress(self):
+        self.set_progress("Waiting for input", 0, False)
+
+    def output(self, start=None, end=None):
+        if start is None:
+            start = 0
+        if end is None:
+            end = len(self.updates)
+
+        out = []
+        seen = set()
+        for update in self.updates[start:end]:
+            if update not in seen:
+                out.append(self.logs[update].output())
+                seen.add(update)
+
+        return out
+
+    def reset(self):
+        self.guid = str(uuid.uuid4())
+        self.updates = []
+        self.logs = []
+        self.set_initial_progress()

python/helpers/memory.py

@@ -72,6 +72,13 @@ class Memory:
                 memory_subdir=memory_subdir,
             )
 
+    @staticmethod
+    async def reload(agent: Agent):
+        memory_subdir = agent.config.memory_subdir or "default"
+        if Memory.index.get(memory_subdir):
+            del Memory.index[memory_subdir]
+        return await Memory.get(agent)
+
     @staticmethod
     def initialize(
         log_item: LogItem | None,
@@ -151,6 +158,9 @@ class Memory:
     async def preload_knowledge(
         self, log_item: LogItem | None, kn_dirs: list[str], memory_subdir: str
     ):
+        if log_item:
+            log_item.update(heading="Preloading knowledge...")
+
         # db abs path
         db_dir = Memory._abs_db_dir(memory_subdir)
 
@@ -351,5 +361,12 @@ class Memory:
     def get_timestamp():
         return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
+
 def get_memory_subdir_abs(agent: Agent) -> str:
-    return files.get_abs_path("memory", agent.config.memory_subdir or "default")
+    return files.get_abs_path("memory", agent.config.memory_subdir or "default")
+
+def get_custom_knowledge_subdir_abs(agent: Agent) -> str:
+    for dir in agent.config.knowledge_subdirs:
+        if dir != "default":    
+            return files.get_abs_path("knowledge", dir)
+    raise Exception("No custom knowledge subdir set")

python/helpers/persist_chat.py

@@ -166,8 +166,7 @@ def _deserialize_agents(
 def _deserialize_log(data: dict[str, Any]) -> "Log":
     log = Log()
     log.guid = data.get("guid", str(uuid.uuid4()))
-    log.progress = ""  # data.get("progress", "")
-    log.progress_no = data.get("progress_no", 0)
+    log.set_initial_progress()
 
     # Deserialize the list of LogItem objects
     i = 0

python/helpers/settings.py

@@ -703,7 +703,7 @@ def get_default_settings() -> Settings:
         chat_model_temperature=0,
         chat_model_kwargs={},
         chat_model_ctx_length=8192,
-        chat_model_ctx_history=0.65,
+        chat_model_ctx_history=0.7,
         util_model_provider=ModelProvider.OPENAI.name,
         util_model_name="gpt-4o-mini",
         util_model_temperature=0,

webui/index.js

@@ -269,6 +269,8 @@ window.loadKnowledge = async function () {
             formData.append('files[]', file);
         }
 
+        formData.append('ctxid', getContext());
+
         const response = await fetch('/import_knowledge', {
             method: 'POST',
             body: formData,
@@ -357,7 +359,7 @@ async function poll() {
             afterMessagesUpdate(response.logs)
         }
 
-        updateProgress(response.log_progress)
+        updateProgress(response.log_progress, response.log_progress_active)
 
         //set ui model vars from backend
         const inputAD = Alpine.$data(inputSection);
@@ -400,11 +402,30 @@ function speakMessages(logs) {
     }
 }
 
-function updateProgress(progress) {
-    const defaultText = "Waiting for input"
-    if (!progress) progress = defaultText
+function afterMessagesUpdate(logs) {
+    if (localStorage.getItem('speech') == 'true') {
+        speakMessages(logs)
+    }
+}
+
+function speakMessages(logs) {
+    // log.no, log.type, log.heading, log.content
+    for (let i = logs.length - 1; i >= 0; i--) {
+        const log = logs[i]
+        if (log.type == "response") {
+            if (log.no > lastSpokenNo) {
+                lastSpokenNo = log.no
+                speech.speak(log.content)
+                return
+            }
+        }
+    }
+}
+
+function updateProgress(progress, active) {
+    if (!progress) progress = ""
 
-    if (progress == defaultText) {
+    if (!active) {
         removeClassFromElement(progressBar, "shiny-text")
     } else {
         addClassToElement(progressBar, "shiny-text")