From 75381f5f11abeeac981e9f5a0242787fd40892ab Mon Sep 17 00:00:00 2001 From: cyclop-bot <178948048+cyclop-bot@users.noreply.github.com> Date: Mon, 2 Jun 2025 16:35:08 -0500 Subject: [PATCH] Refactor: Make system_prompt_path and content configurable in BaseTelegramInferenceBot --- base_telegram_inference_bot.py | 72 +++++++++++++++++++++++----------- 1 file changed, 49 insertions(+), 23 deletions(-) diff --git a/base_telegram_inference_bot.py b/base_telegram_inference_bot.py index 6751e67..568046d 100644 --- a/base_telegram_inference_bot.py +++ b/base_telegram_inference_bot.py @@ -7,26 +7,47 @@ from abc import ABC, abstractmethod from tools.base_tool import BaseTool class BaseTelegramInferenceBot(ABC): - def __init__(self): + def __init__(self, system_prompt_content: str | None = None, system_prompt_path: str | None = None): # MODIFIED self.conversation_history = {} self.processing_status = {} - self.system_prompt = self.load_system_prompt() + # MODIFIED to pass arguments + self.system_prompt = self.load_system_prompt( + direct_content=system_prompt_content, + file_path=system_prompt_path + ) self.tools, self.functions = self.load_functions() - logging.info(f'System Prompt: {os.environ.get("SYSTEM_PROMPT_PATH")}') + # Logging the actual source of the system prompt might be more complex now, + # but we can log the final prompt or indicate if it's custom/default. + # We'll also log the source of the prompt inside load_system_prompt. + logging.info(f'System Prompt (effective): {"Custom" if self.system_prompt != "You are a helpful AI assistant." else "Default"}') logging.info(f'Github Repository: {os.environ.get("GITHUB_REPOSITORY")}') - def load_system_prompt(self): - system_prompt_path = os.getenv("SYSTEM_PROMPT_PATH") - if system_prompt_path and os.path.isfile(system_prompt_path): - try: - with open(system_prompt_path, "r", encoding="utf-8") as file: - return file.read().strip() - except IOError as e: - logging.warning(f"Could not read system prompt file {system_prompt_path}: {e}") - return "You are a helpful AI assistant." + def load_system_prompt(self, direct_content: str | None = None, file_path: str | None = None) -> str: # MODIFIED + default_prompt = "You are a helpful AI assistant." + + if direct_content: + logging.info("Using direct content for system prompt.") + return direct_content.strip() + + prompt_path_to_try = file_path or os.getenv("SYSTEM_PROMPT_PATH") + + if prompt_path_to_try: + if os.path.isfile(prompt_path_to_try): + try: + with open(prompt_path_to_try, "r", encoding="utf-8") as file: + content = file.read().strip() + logging.info(f"Successfully loaded system prompt from {prompt_path_to_try}.") + return content + except IOError as e: + logging.warning(f"Could not read system prompt file {prompt_path_to_try}: {e}. Using default.") + return default_prompt + else: + # This condition now also covers if 'file_path' argument was given but invalid + logging.warning(f"System prompt file {prompt_path_to_try} not found. Using default system prompt.") + return default_prompt else: - logging.warning("SYSTEM_PROMPT_PATH is not set or file does not exist. Using default system prompt.") - return "You are a helpful AI assistant." + logging.info("No system prompt path provided (argument or ENV) or direct content. Using default system prompt.") + return default_prompt def load_functions(self): tools = [] @@ -44,7 +65,7 @@ class BaseTelegramInferenceBot(ABC): for name, obj in inspect.getmembers(module): if inspect.isclass(obj) and issubclass(obj, BaseTool) and obj != BaseTool: try: - tools.append(obj()) + tools.append(obj()) # This instantiation might be an issue for tools needing config except Exception as e: logging.error(f"Error instantiating tool {name} from {filename}: {e}") except Exception as e: @@ -87,9 +108,9 @@ class BaseTelegramInferenceBot(ABC): except json.JSONDecodeError as e: logging.error(f"Error decoding function call arguments (string) for {function_call_name}: {e}. Arguments: {function_call_arguments}") return f"Error: Malformed arguments for tool call: {e}" - else: # Handle cases where arguments might be None or other unexpected types + else: if function_call_arguments is None: - function_args = {} # Default to empty dict if arguments are None + function_args = {} else: logging.error(f"Unexpected type for function_call_arguments for {function_call_name}: {type(function_call_arguments)}. Arguments: {function_call_arguments}") return f"Error: Invalid argument type for tool call: {type(function_call_arguments)}" @@ -98,7 +119,6 @@ class BaseTelegramInferenceBot(ABC): for function in tool.get_functions(): if function["function"]["name"] == function_name: try: - # Ensure function_args is a dictionary before unpacking if not isinstance(function_args, dict): logging.error(f"Internal error: function_args not a dict for {function_name} before execution. Args: {function_args}") return f"Internal error preparing arguments for tool {function_name}." @@ -110,16 +130,23 @@ class BaseTelegramInferenceBot(ABC): return f"Error: Tool function {function_name} not found." def get_system_prompt_description(self) -> str: - """Returns a description of the system prompt being used.""" - return f"System Prompt: {'Custom' if os.getenv('SYSTEM_PROMPT_PATH') else 'Default'}" + # This method could be updated to be more specific about the prompt source if needed. + # For now, it still reflects custom vs default based on the original ENV var logic's spirit. + # A more accurate reflection would require storing how the prompt was loaded. + # For simplicity, let's assume if it's not the default, it's "Custom". + if self.system_prompt != "You are a helpful AI assistant.": + return "System Prompt: Custom" + # Check original ENV var for backward compatibility in description only + elif os.getenv('SYSTEM_PROMPT_PATH'): + return "System Prompt: Custom (via ENV)" + return "System Prompt: Default" + @abstractmethod def get_llm_description(self) -> str: - """Returns a description of the LLM being used.""" pass async def get_bot_status(self) -> str: - """Provides a status message including prompt and LLM information.""" prompt_desc = self.get_system_prompt_description() llm_desc = self.get_llm_description() return f"{prompt_desc}\n{llm_desc}" @@ -134,5 +161,4 @@ class BaseTelegramInferenceBot(ABC): @abstractmethod async def switch_model(self): - """Switches the underlying model if supported by the bot.""" pass