symbolicai 0.21.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

symai/backend/settings.py

@@ -1,5 +1,4 @@
 import json
-import os
 import sys
 from pathlib import Path
 
@@ -15,57 +14,96 @@ class SymAIConfig:
     def __init__(self):
         """Initialize configuration paths based on current Python environment."""
         self._env_path = Path(sys.prefix)
-        self._env_config_dir = self._env_path / '.symai'
-        self._home_config_dir = Path.home() / '.symai'
+        self._env_config_dir = self._env_path / ".symai"
+        self._home_config_dir = Path.home() / ".symai"
         self._debug_dir = Path.cwd()  # Current working directory for debug mode
+        self._active_paths: dict[str, Path] = {}
+
+    def _canonical_key(self, filename: str | Path) -> str:
+        """Return a canonical identifier for config files regardless of input type."""
+        path = Path(filename)
+        if path.is_absolute() or path.parent != Path():
+            return str(path)
+        return path.name or str(path)
+
+    def _remove_legacy_path_keys(self, key: str) -> None:
+        """Drop legacy Path keys that collide with the canonical key."""
+        target_path = Path(key)
+        target_name = target_path.name or key
+        stale_keys: list[Path] = [
+            existing_key
+            for existing_key in self._active_paths
+            if isinstance(existing_key, Path)
+            and (existing_key.name == target_name or str(existing_key) == key)
+        ]
+        for stale_key in stale_keys:
+            self._active_paths.pop(stale_key, None)
 
     @property
     def config_dir(self) -> Path:
         """Returns the active configuration directory based on priority system."""
         # Debug mode takes precedence
-        if (self._debug_dir / 'symai.config.json').exists():
-            return self._debug_dir / '.symai'
+        if (self._debug_dir / "symai.config.json").exists():
+            return self._debug_dir / ".symai"
         # Then environment config
         if self._env_config_dir.exists():
             return self._env_config_dir
         # Finally home directory
         return self._home_config_dir
 
-    def get_config_path(self, filename: str, fallback_to_home: bool = False) -> Path:
+    def get_config_path(self, filename: str | Path, fallback_to_home: bool = False) -> Path:
         """Gets the config path using the priority system or forces fallback to home."""
-        debug_config = self._debug_dir / filename
-        env_config   = self._env_config_dir / filename
-        home_config  = self._home_config_dir / filename
+        input_path = Path(filename)
+        if input_path.is_absolute() or input_path.parent != Path():
+            return input_path
+
+        normalized_filename = self._canonical_key(filename)
+        # Only use the basename for managed directories
+        normalized_filename = Path(normalized_filename).name
+        debug_config = self._debug_dir / normalized_filename
+        env_config = self._env_config_dir / normalized_filename
+        home_config = self._home_config_dir / normalized_filename
 
         # Check debug first (only valid for symai.config.json)
-        if filename == 'symai.config.json' and debug_config.exists():
+        if normalized_filename == "symai.config.json" and debug_config.exists():
             return debug_config
 
         # If forced to fallback, return home config if it exists, otherwise environment
         if fallback_to_home:
-            return home_config if home_config.exists() else env_config
+            if home_config.exists():
+                return home_config
+            return env_config
 
         # Normal priority-based resolution
-        # If environment config doesn't exist, return that path (for creation)
-        if not env_config.exists():
+        if env_config.exists():
             return env_config
-        # Otherwise use environment config
+        if home_config.exists():
+            return home_config
         return env_config
 
-    def load_config(self, filename: str, fallback_to_home: bool = False) -> dict:
+    def load_config(self, filename: str | Path, fallback_to_home: bool = False) -> dict:
         """Loads JSON data from the determined config location."""
         config_path = self.get_config_path(filename, fallback_to_home=fallback_to_home)
+        key = self._canonical_key(filename)
         if not config_path.exists():
+            self._remove_legacy_path_keys(key)
+            self._active_paths.pop(key, None)
             return {}
-        with open(config_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
+        with config_path.open(encoding="utf-8") as f:
+            config = json.load(f)
+        self._remove_legacy_path_keys(key)
+        self._active_paths[key] = config_path
+        return config
 
-    def save_config(self, filename: str, data: dict, fallback_to_home: bool = False) -> None:
+    def save_config(self, filename: str | Path, data: dict, fallback_to_home: bool = False) -> None:
         """Saves JSON data to the determined config location."""
         config_path = self.get_config_path(filename, fallback_to_home=fallback_to_home)
-        os.makedirs(config_path.parent, exist_ok=True)
-        with open(config_path, 'w', encoding='utf-8') as f:
+        key = self._canonical_key(filename)
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with config_path.open("w", encoding="utf-8") as f:
             json.dump(data, f, indent=4)
+        self._remove_legacy_path_keys(key)
+        self._active_paths[key] = config_path
 
     def migrate_config(self, filename: str, updates: dict) -> None:
         """Updates existing configuration with new fields."""
@@ -73,6 +111,35 @@ class SymAIConfig:
         config.update(updates)
         self.save_config(filename, config)
 
+    def get_active_path(self, filename: str | Path) -> Path:
+        """Returns the last path used to read or write the given config file."""
+        key = self._canonical_key(filename)
+        cached = self._active_paths.get(key)
+        if cached is not None:
+            return cached
+        for legacy_key, cached_path in list(self._active_paths.items()):
+            if isinstance(legacy_key, Path) and (legacy_key.name == key or str(legacy_key) == key):
+                self._active_paths.pop(legacy_key, None)
+                self._active_paths[key] = cached_path
+                return cached_path
+        return self.get_config_path(filename)
+
+    def get_active_config_dir(self) -> Path:
+        """Returns the directory backing the active symai configuration."""
+        symai_key = self._canonical_key("symai.config.json")
+        cached = self._active_paths.get(symai_key)
+        if cached is not None:
+            return cached.parent
+        for legacy_key, cached_path in list(self._active_paths.items()):
+            if isinstance(legacy_key, Path) and (
+                legacy_key.name == symai_key or str(legacy_key) == symai_key
+            ):
+                self._active_paths.pop(legacy_key, None)
+                self._active_paths[symai_key] = cached_path
+                return cached_path.parent
+        return self.config_dir
+
+
 SYMAI_CONFIG = {}
 SYMSH_CONFIG = {}
 SYMSERVER_CONFIG = {}

symai/chat.py

@@ -1,6 +1,5 @@
 import logging
 import re
-from typing import Optional
 
 from loguru import logger
 
@@ -13,22 +12,23 @@ from .post_processors import ConsolePostProcessor, StripPostProcessor
 from .pre_processors import ConsoleInputPreProcessor
 from .prompts import MemoryCapabilities, SymbiaCapabilities
 from .symbol import Expression, Symbol
+from .utils import UserMessage
 
-logging.getLogger('charset_normalizer').setLevel(logging.ERROR)
+logging.getLogger("charset_normalizer").setLevel(logging.ERROR)
 
 
 class ChatBot(Expression):
-    _symai_chat: str = '''This is a conversation between a chatbot (Symbia:) and a human (User:). The chatbot follows a narrative structure, primarily relying on the provided instructions. It uses the user's input as a conditioning factor to generate its responses. Whenever Symbia retrieves any long-term memories, it checks the user's query and incorporates information from the long-term memory buffer into its response. If the long-term memories cannot provide a suitable answer, Symbia then checks its short-term memory to be aware of the topics discussed in the recent conversation rounds. Your primary task is to reply to the user's question or statement by generating a relevant and contextually appropriate response. Do not focus on filling the scratchpad with narration, long-term memory recall, short-term memory recall, or reflections. Always consider any follow-up questions or relevant information from the user to generate a response that is contextually relevant. Endeavor to reply to the greatest possible effort.'''
+    _symai_chat: str = """This is a conversation between a chatbot (Symbia:) and a human (User:). The chatbot follows a narrative structure, primarily relying on the provided instructions. It uses the user's input as a conditioning factor to generate its responses. Whenever Symbia retrieves any long-term memories, it checks the user's query and incorporates information from the long-term memory buffer into its response. If the long-term memories cannot provide a suitable answer, Symbia then checks its short-term memory to be aware of the topics discussed in the recent conversation rounds. Your primary task is to reply to the user's question or statement by generating a relevant and contextually appropriate response. Do not focus on filling the scratchpad with narration, long-term memory recall, short-term memory recall, or reflections. Always consider any follow-up questions or relevant information from the user to generate a response that is contextually relevant. Endeavor to reply to the greatest possible effort."""
 
     def __init__(
         self,
         value: str | None = None,
-        name: str = 'Symbia',
+        name: str = "Symbia",
         verbose: bool = False,
         short_term_mem_window_size: int = 10,
         long_term_mem_top_k: int = 10,
-        index_name: str = 'symbia_index',
-        **kwargs
+        index_name: str = "symbia_index",
+        **kwargs,
     ):
         super().__init__(value, **kwargs)
         self.sym_return_type = ChatBot
@@ -38,55 +38,75 @@ class ChatBot(Expression):
         self.interfaces = cfg_to_interface()
         self.short_term_memory = SlidingWindowListMemory(window_size=short_term_mem_window_size)
         self.long_term_mem_top_k = long_term_mem_top_k
-        self.long_term_memory = self.interfaces['indexing']
+        self.long_term_memory = self.interfaces["indexing"]
         self._preprocessor = ChatBot._init_custom_input_preprocessor(name=name, that=self)
         self._postprocessor = ChatBot._init_custom_input_postprocessor(that=self)
         self.detect_capability = InContextClassification(SymbiaCapabilities())
         self.detect_memory_usage = InContextClassification(MemoryCapabilities())
-        self._last_user_input: str = ''
+        self._last_user_input: str = ""
 
-    def repeat(self, query, **kwargs):
-        return self.narrate('Symbia does not understand and asks to repeat and give more context.', prompt=query)
-
-    def narrate(self, message: str, context: str = None, category: str = None, end: bool = False, **kwargs) -> Symbol:
-        reflection = context if context is not None else ''
-        ltmem_recall = 'No memories retrieved.'
-        stmem_recall = '\n'.join(self.short_term_memory.recall())
-        stmem_recall = stmem_recall if len(stmem_recall) > 0 else 'No memories retrieved.'
-        ltmem_recall = 'No memories retrieved.'
+    def repeat(self, query, **_kwargs):
+        return self.narrate(
+            "Symbia does not understand and asks to repeat and give more context.", prompt=query
+        )
 
-        if category == 'RECALL':
-            if (HOME_PATH / 'localdb' / f'{self.index_name}.pkl').exists():
-                ltmem_recall = '\n'.join(self.long_term_memory(reflection, operation='search', index_name=self.index_name))
+    def narrate(
+        self,
+        message: str,
+        context: str | None = None,
+        category: str | None = None,
+        end: bool = False,
+        **kwargs,
+    ) -> Symbol:
+        reflection = context if context is not None else ""
+        ltmem_recall = "No memories retrieved."
+        stmem_recall = "\n".join(self.short_term_memory.recall())
+        stmem_recall = stmem_recall if len(stmem_recall) > 0 else "No memories retrieved."
+        ltmem_recall = "No memories retrieved."
+
+        if category == "RECALL":
+            if (HOME_PATH / "localdb" / f"{self.index_name}.pkl").exists():
+                ltmem_recall = "\n".join(
+                    self.long_term_memory(
+                        reflection, operation="search", index_name=self.index_name
+                    )
+                )
             scratchpad = self._memory_scratchpad(reflection, stmem_recall, ltmem_recall)
             memory_usage = str(self.detect_memory_usage(scratchpad))
 
             if self.verbose:
-                logger.debug(f'Scratchpad:\n{scratchpad}\n')
-                logger.debug(f'Memory usage:\n{memory_usage}\n')
-                logger.debug(f'Retrieved from short-term memory:\n{stmem_recall}\n')
-                logger.debug(f'Retrieved from long-term memory:\n{ltmem_recall}\n')
+                logger.debug(f"Scratchpad:\n{scratchpad}\n")
+                logger.debug(f"Memory usage:\n{memory_usage}\n")
+                logger.debug(f"Retrieved from short-term memory:\n{stmem_recall}\n")
+                logger.debug(f"Retrieved from long-term memory:\n{ltmem_recall}\n")
 
             do = self._extract_category(memory_usage)
             reflection = self._extract_reflection(memory_usage)
 
-            if do == 'SAVE':
-                self.long_term_memory(f'{self.name}: {reflection}', operation='add', top_k=self.long_term_mem_top_k, index_name=self.index_name)
-                self.long_term_memory('save', operation='config', index_name=self.index_name)
-                if self.verbose: logger.debug(f'Store new long-term memory:\n{reflection}\n')
-                message = f'{self.name} inform the user that the memory was stored.'
-            elif do == 'DUPLICATE':
-                message = f'{self.name} engages the user in a conversation about the duplicate topic, showing the user she remembered the past interaction.'
-            elif do == 'IRRELEVANT':
-                message = f'{self.name} discusses the topic with the user.'
+            if do == "SAVE":
+                self.long_term_memory(
+                    f"{self.name}: {reflection}",
+                    operation="add",
+                    top_k=self.long_term_mem_top_k,
+                    index_name=self.index_name,
+                )
+                self.long_term_memory("save", operation="config", index_name=self.index_name)
+                if self.verbose:
+                    logger.debug(f"Store new long-term memory:\n{reflection}\n")
+                message = f"{self.name} inform the user that the memory was stored."
+            elif do == "DUPLICATE":
+                message = f"{self.name} engages the user in a conversation about the duplicate topic, showing the user she remembered the past interaction."
+            elif do == "IRRELEVANT":
+                message = f"{self.name} discusses the topic with the user."
 
         if self.verbose:
-            logger.debug(f'Storing new short-term memory:\nUser: {self._last_user_input}\n')
-            logger.debug(f'Storing new short-term memory:\n{self.name}: {reflection}\n')
+            logger.debug(f"Storing new short-term memory:\nUser: {self._last_user_input}\n")
+            logger.debug(f"Storing new short-term memory:\n{self.name}: {reflection}\n")
 
-        reply = f'{self.name}: {self._narration(message, self._last_user_input, reflection, context, ltmem_recall, stmem_recall, **kwargs)}'
+        reply = f"{self.name}: {self._narration(message, self._last_user_input, reflection, context, ltmem_recall, stmem_recall, **kwargs)}"
 
-        if end: print('\n\n', reply)
+        if end:
+            UserMessage(f"\n\n{reply}", text="extensity")
 
         return Symbol(reply)
 
@@ -94,10 +114,11 @@ class ChatBot(Expression):
         @core.userinput(
             pre_processors=[self._preprocessor()],
             post_processors=[StripPostProcessor(), self._postprocessor()],
-            **kwargs
+            **kwargs,
         )
         def _func(_, message) -> str:
             pass
+
         return Symbol(_func(self, message))
 
     @property
@@ -108,23 +129,34 @@ class ChatBot(Expression):
     def _init_custom_input_preprocessor(name, that):
         class CustomInputPreProcessor(ConsoleInputPreProcessor):
             def __call__(self, argument):
-                msg = re.sub(f'{name}:\s*', '', str(argument.args[0]))
-                console = f'\n{name}: {msg}\n$> '
+                msg = re.sub(f"{name}:\s*", "", str(argument.args[0]))
+                console = f"\n{name}: {msg}\n$> "
                 if len(msg) > 0:
-                    that.short_term_memory.store(f'{name}: ' + msg)
+                    that.short_term_memory.store(f"{name}: " + msg)
                 return console
+
         return CustomInputPreProcessor
 
     @staticmethod
     def _init_custom_input_postprocessor(that):
         class CustomInputPostProcessor(ConsolePostProcessor):
-            def __call__(self, rsp, argument):
-                that.short_term_memory.store(f'User: {str(rsp)}')
+            def __call__(self, rsp, _argument):
+                that.short_term_memory.store(f"User: {rsp!s}")
                 return rsp
+
         return CustomInputPostProcessor
 
-    def _narration(self, msg: str, query: str, reflection: str, context: str, ltmem_recall: str, stmem_recall: str, **kwargs):
-        prompt = f'''
+    def _narration(
+        self,
+        msg: str,
+        query: str,
+        reflection: str,
+        context: str,
+        ltmem_recall: str,
+        stmem_recall: str,
+        **kwargs,
+    ):
+        prompt = f"""
 {self._symai_chat.format(self.name)}
 
     [NARRATION](
@@ -153,112 +185,172 @@ class ChatBot(Expression):
 
 The chatbot always reply in the following format
 {self.name}: <reply>
-'''
+"""
+
         @core.zero_shot(prompt=prompt, **kwargs)
         def _func(_) -> str:
             pass
-        if self.verbose: logger.debug(f'Narration:\n{prompt}\n')
-        res = _func(self)
-        res = res.replace(f'{self.name}: ', '').strip()
-        return res
+
+        if self.verbose:
+            logger.debug(f"Narration:\n{prompt}\n")
+        return _func(self).replace(f"{self.name}: ", "").strip()
+
 
 class SymbiaChat(ChatBot):
-    def __init__(self, name: str = 'Symbia', verbose: bool = False, **kwargs):
+    def __init__(self, name: str = "Symbia", verbose: bool = False, **kwargs):
         super().__init__(name=name, verbose=verbose, **kwargs)
-        self.message = self.narrate(f'{self.name} introduces herself, writes a greeting message and asks how to help.', context=None)
+        self.message = self.narrate(
+            f"{self.name} introduces herself, writes a greeting message and asks how to help.",
+            context=None,
+        )
 
-    def forward(self, usr: Optional[str] = None) -> Symbol:
+    def forward(self, usr: str | None = None) -> Symbol:
         loop = True
         ask_input = True
         if usr:
             ask_input = False
             usr = self._to_symbol(usr)
 
-        # added step-by-step interaction with the user if input is provided
         while loop:
-            # if no input is provided, ask for input
-            if ask_input:
-                usr = self.input(self.message)
-            else:
-                loop = False # break the loop after the first iteration
-
+            usr, loop = self._resolve_user_input(usr, loop, ask_input)
             self._last_user_input = usr
-            if self.verbose: logger.debug(f'User:\n{usr}\n')
+            self._log_verbose("User", usr)
 
-            if len(str(usr)) > 0:
-                ctxt = str(self.detect_capability(usr))
-            else:
-                ctxt = '[DK]'
-
-            if self.verbose: logger.debug(f'In-context:\n{ctxt}\n')
+            ctxt = self._context_from_user(usr)
+            self._log_verbose("In-context", ctxt)
 
-            if '[EXIT]' in ctxt:
-                self.message = self.narrate(f'{self.name} writes friendly goodbye message.', context=None, end=True)
+            if self._handle_exit_context(ctxt):
                 break
-            elif '[HELP]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                self.message = self.narrate(f'{self.name} ', context=reflection)
-            elif '[RECALL]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                category = self._extract_category(ctxt)
-                self.message = self.narrate(f'{self.name} uses replies based on what has been recovered from the memory.', context=ctxt, category=category)
-            elif '[DK]' in ctxt:
-                reflection = self._extract_reflection(ctxt)
-                self.message = self.narrate(f'{self.name} is not sure about the message and references and asks the user for more context.', context=reflection)
 
-            else:
-                try:
-                    if '[SYMBOLIC]' in ctxt:
-                        q = usr.extract("mathematical formula that WolframAlpha can solve")
-                        rsp = self.interfaces['symbolic'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and provides the solution of the math problem.', context=rsp)
-                    elif '[SEARCH]' in ctxt:
-                        q = usr.extract('user query request')
-                        rsp = self.interfaces['search'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user based on the online search results.', context=rsp)
-                    elif '[SCRAPER]' in ctxt:
-                        q = usr.extract('URL from text')
-                        q = q.convert('proper URL, example: https://www.google.com')
-                        rsp = self.interfaces['scraper'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and narrates its findings.', context=rsp)
-                    elif '[SPEECH-TO-TEXT]' in ctxt:
-                        q = usr.extract('extract file path')
-                        rsp = self.interfaces['stt'](q)
-                        self.message = self.narrate(f'{self.name} replies to the user and transcribes the content of the audio file.', context=rsp)
-                    elif '[TEXT-TO-IMAGE]' in ctxt:
-                        q = usr.extract('text for image creation')
-                        rsp = self.interfaces['drawing'](q)
-                        self.message = self.narrate('Symbia replies to the user and provides the image URL.', context=rsp)
-                    elif '[FILE]' in ctxt:
-                        file_path = usr.extract('extract file path')
-                        q = usr.extract('user question')
-                        rsp = self.interfaces['file'](file_path)
-                        self.message = self.narrate(f'{self.name} replies to the user and outlines and relies to the user query.', context=rsp)
-                    else:
-                        q = usr.extract('user query request')
-                        reflection = self._extract_reflection(ctxt)
-                        self.message = self.narrate(f'{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.', context=reflection)
-
-                except Exception as e:
-                    reflection = self._extract_reflection(ctxt)
-                    self.message = self.narrate(f'{self.name} apologizes and explains the user what went wrong.', context=str(e))
+            if self._handle_reflection_context(ctxt):
+                continue
+
+            self._handle_interface_context(usr, ctxt)
 
         return self.message
 
+    def _resolve_user_input(
+        self, usr: Symbol | None, loop: bool, ask_input: bool
+    ) -> tuple[Symbol, bool]:
+        if ask_input:
+            usr = self.input(self.message)
+        else:
+            loop = False
+        return usr, loop
+
+    def _log_verbose(self, title: str, content) -> None:
+        if self.verbose:
+            logger.debug(f"{title}:\n{content}\n")
+
+    def _context_from_user(self, usr: Symbol) -> str:
+        text = str(usr)
+        if len(text) == 0:
+            return "[DK]"
+        return str(self.detect_capability(usr))
+
+    def _handle_exit_context(self, ctxt: str) -> bool:
+        if "[EXIT]" in ctxt:
+            self.message = self.narrate(
+                f"{self.name} writes friendly goodbye message.", context=None, end=True
+            )
+            return True
+        return False
+
+    def _handle_reflection_context(self, ctxt: str) -> bool:
+        if "[HELP]" in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(f"{self.name} ", context=reflection)
+            return True
+        if "[RECALL]" in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            category = self._extract_category(ctxt)
+            self.message = self.narrate(
+                f"{self.name} uses replies based on what has been recovered from the memory.",
+                context=ctxt,
+                category=category,
+            )
+            return True
+        if "[DK]" in ctxt:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(
+                f"{self.name} is not sure about the message and references and asks the user for more context.",
+                context=reflection,
+            )
+            return True
+        return False
+
+    def _handle_interface_context(self, usr: Symbol, ctxt: str) -> None:
+        try:
+            if "[SYMBOLIC]" in ctxt:
+                q = usr.extract("mathematical formula that WolframAlpha can solve")
+                rsp = self.interfaces["symbolic"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and provides the solution of the math problem.",
+                    context=rsp,
+                )
+            elif "[SEARCH]" in ctxt:
+                q = usr.extract("user query request")
+                rsp = self.interfaces["search"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user based on the online search results.",
+                    context=rsp,
+                )
+            elif "[SCRAPER]" in ctxt:
+                q = usr.extract("URL from text")
+                q = q.convert("proper URL, example: https://www.google.com")
+                rsp = self.interfaces["scraper"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and narrates its findings.", context=rsp
+                )
+            elif "[SPEECH-TO-TEXT]" in ctxt:
+                q = usr.extract("extract file path")
+                rsp = self.interfaces["stt"](q)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and transcribes the content of the audio file.",
+                    context=rsp,
+                )
+            elif "[TEXT-TO-IMAGE]" in ctxt:
+                q = usr.extract("text for image creation")
+                rsp = self.interfaces["drawing"](q)
+                self.message = self.narrate(
+                    "Symbia replies to the user and provides the image URL.", context=rsp
+                )
+            elif "[FILE]" in ctxt:
+                file_path = usr.extract("extract file path")
+                q = usr.extract("user question")
+                rsp = self.interfaces["file"](file_path)
+                self.message = self.narrate(
+                    f"{self.name} replies to the user and outlines and relies to the user query.",
+                    context=rsp,
+                )
+            else:
+                q = usr.extract("user query request")
+                reflection = self._extract_reflection(ctxt)
+                self.message = self.narrate(
+                    f"{self.name} tries to interpret the response, and if unclear asks the user to restate the statement or add more context.",
+                    context=reflection,
+                )
+
+        except Exception as e:
+            reflection = self._extract_reflection(ctxt)
+            self.message = self.narrate(
+                f"{self.name} apologizes and explains the user what went wrong.", context=str(e)
+            )
+
     def _extract_reflection(self, msg: str) -> str:
-        res = re.findall(r'\(([^)]+)\)', msg)
+        res = re.findall(r"\(([^)]+)\)", msg)
         if len(res) > 0:
             return res.pop()
-        return
+        return None
 
     def _extract_category(self, msg: str) -> str:
-        res = re.findall(r'\[([^]]+)\]', msg)
+        res = re.findall(r"\[([^]]+)\]", msg)
         if len(res) > 0:
             return res.pop()
-        return
+        return None
 
     def _memory_scratchpad(self, context, short_term_memory, long_term_memory):
-        scratchpad = f'''
+        return f"""
     [REFLECT](
 Query:      {self._last_user_input}
 Reflection: {self._extract_reflection(context)}
@@ -271,12 +363,13 @@ Reflection: {self._extract_reflection(context)}
     [LONG-TERM MEMORY RECALL](
 {long_term_memory}
 )
-'''
-        return scratchpad
+"""
+
 
 def run() -> None:
     chat = SymbiaChat()
     chat()
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     run()

symai/collect/__init__.py

@@ -1,2 +1,8 @@
+from .dynamic import create_object_from_string
 from .pipeline import CollectionRepository, rec_serialize
-from .dynamic import create_object_from_string
+
+__all__ = [
+    "CollectionRepository",
+    "create_object_from_string",
+    "rec_serialize",
+]