xgae 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

xgae/engine/xga_base.py

@@ -2,7 +2,9 @@ from typing import Union, Optional, Dict, List, Any, Literal
 from dataclasses import dataclass
 from abc import ABC, abstractmethod
 
-
+class XGAError(Exception):
+    """Custom exception for errors in the XGA system."""
+    pass
 
 @dataclass
 class XGAMessage:
@@ -20,7 +22,8 @@ class XGAToolSchema:
     tool_name: str
     server_name: str
     description: str
-    input_schema: Optional[str]
+    input_schema: Dict[str, Any]
+    metadata: Optional[Dict[str, Any]]
 
 
 @dataclass

xgae/engine/xga_engine.py

@@ -2,46 +2,74 @@
 from typing import List, Any, Dict, Optional, AsyncGenerator
 from uuid import uuid4
 
-from xgae.engine.xga_base import XGAMessage, XGAToolSchema, XGAToolBox
+from xgae.engine.xga_base import XGAMessage, XGAToolBox
 from xgae.utils.llm_client import LLMClient
 from xgae.utils.setup_env import langfuse
 from xga_prompt_builder import XGAPromptBuilder
 from xga_mcp_tool_box import XGAMcpToolBox
 
-class XGAEngine():
+
+class XGATaskEngine():
     def __init__(self,
                  session_id: Optional[str] = None,
-                 trace_id: Optional[str] = None,
+                 task_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
+                 trace_id: Optional[str] = None,
+                 system_prompt: Optional[str] = None,
                  llm_config: Optional[Dict[str, Any]] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
         self.session_id = session_id if session_id else f"xga_sid_{uuid4()}"
+        self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
         self.agent_id = agent_id
+        self.trace_id = trace_id if trace_id else langfuse.create_trace_id()
 
         self.messages: List[XGAMessage] = []
         self.llm_client = LLMClient(llm_config)
         self.model_name = self.llm_client.model_name
         self.is_stream = self.llm_client.is_stream
 
-        self.prompt_builder = prompt_builder or XGAPromptBuilder()
+        self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
         self.tool_box = tool_box or XGAMcpToolBox()
 
-        self.task_id = None
-        self.trace_id = trace_id if trace_id else langfuse.create_trace_id()
+
+    async def __async_init__(self, general_tools:List[str], custom_tools: List[str]) -> None:
+        await  self.tool_box.load_mcp_tools_schema()
+        await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
+        general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+
+        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+
+    @classmethod
+    async def create(cls,
+                     session_id: Optional[str] = None,
+                     task_id: Optional[str] = None,
+                     agent_id: Optional[str] = None,
+                     trace_id: Optional[str] = None,
+                     system_prompt: Optional[str] = None,
+                     general_tools: Optional[List[str]] = None,
+                     custom_tools: Optional[List[str]] = None,
+                     llm_config: Optional[Dict[str, Any]] = None,
+                     prompt_builder: Optional[XGAPromptBuilder] = None,
+                     tool_box: Optional[XGAToolBox] = None) -> 'XGATaskEngine':
+        engine: XGATaskEngine = cls(session_id=session_id,
+                                    task_id=task_id,
+                                    agent_id=agent_id,
+                                    trace_id=trace_id,
+                                    system_prompt=system_prompt,
+                                    llm_config=llm_config,
+                                    prompt_builder=prompt_builder,
+                                    tool_box=tool_box)
+        general_tools = general_tools or ["*"]
+        custom_tools = custom_tools or []
+        await engine.__async_init__(general_tools, custom_tools)
+        return engine
 
 
-    async def run_task(self,
-                       task_messages: List[Dict[str, Any]],
-                       task_id: Optional[str],
-                       prompt_template: Optional[str] = None,
-                       general_tools: Optional[List[str]] = ["*"],
-                       custom_tools: Optional[List[str]] = []) -> AsyncGenerator:
+    async def run_task(self, task_messages: List[Dict[str, Any]]) -> AsyncGenerator:
         try:
-            self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
-            await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
-            system_prompt = await self._build_system_prompt(prompt_template, general_tools, custom_tools)
-            yield system_prompt
+            yield self.task_prompt
 
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
@@ -50,20 +78,22 @@ class XGAEngine():
     def _run_task_once(self):
         pass
 
-    async def _build_system_prompt(self, prompt_template: str, general_tools: List[str], custom_tools: List[str]) -> str:
-        self.task_tool_schemas: Dict[str, XGAToolSchema] = {}
-        system_prompt = self.prompt_builder.build_system_prompt(self.model_name, prompt_template)
-
-        tool_schemas = await self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
-        system_prompt = self.prompt_builder.build_general_tool_prompt(self.model_name, system_prompt, tool_schemas)
-
-        tool_schemas = await self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
-        system_prompt = self.prompt_builder.build_custom_tool_prompt(self.model_name, system_prompt, tool_schemas)
-
-        return system_prompt
 
     def add_message(self, message: XGAMessage):
         message.message_id = f"xga_msg_{uuid4()}"
         message.session_id = self.session_id
         message.agent_id = self.agent_id
         self.messages.append(message)
+
+if __name__ == "__main__":
+    import asyncio
+
+    async def main():
+        tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        engine = await XGATaskEngine.create(tool_box=tool_box, custom_tools=["bomc_fault.*"])
+        # engine = await XGATaskEngine.create()
+
+        async for chunk in engine.run_task(task_messages=[{}]):
+             print(chunk)
+
+    asyncio.run(main())

xgae/engine/xga_mcp_tool_box.py

@@ -1,21 +1,22 @@
 import json
 import logging
 import os
+
 from typing import List, Any, Dict, Optional, Literal, override
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_mcp_adapters.tools import load_mcp_tools
 
-from xgae.engine.xga_base import XGAToolSchema, XGAToolBox, XGAToolResult
-from xgae.utils.setup_env import XGAError
-
+from xgae.engine.xga_base import XGAError, XGAToolSchema, XGAToolBox, XGAToolResult
+from xgae.utils.setup_env import langfuse
 
 class XGAMcpToolBox(XGAToolBox):
     GENERAL_MCP_SERVER_NAME = "xga_general"
 
     def __init__(self,
-                 custom_mcp_server_config: Optional[Dict[str, Any]] = None,
-                 custom_mcp_server_file: Optional[str] = None):
+                 custom_mcp_server_file: Optional[str] = None,
+                 custom_mcp_server_config: Optional[Dict[str, Any]] = None
+        ):
         general_mcp_server_config = self._load_mcp_servers_config("mcpservers/xga_server.json")
         tool_box_mcp_server_config = general_mcp_server_config.get("mcpServers", {})
 
@@ -31,6 +32,8 @@ class XGAMcpToolBox(XGAToolBox):
         self.mcp_tool_schemas: Dict[str, List[XGAToolSchema]] = {}
         self.task_tool_schemas: Dict[str, Dict[str,XGAToolSchema]] = {}
 
+        self.is_loaded_tool_schemas = False
+
     @override
     async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
         task_tool_schemas = {}
@@ -41,7 +44,7 @@ class XGAMcpToolBox(XGAToolBox):
             for tool_schema in general_tool_schemas:
                 if tool_schema.tool_name in general_tools:
                     task_tool_schemas[tool_schema.tool_name] = tool_schema
-        task_tool_schemas.pop("end_task")
+        task_tool_schemas.pop("end_task", None)
 
         for server_tool_name in custom_tools:
             parts = server_tool_name.split(".")
@@ -122,20 +125,35 @@ class XGAMcpToolBox(XGAToolBox):
 
             return result
 
+
     async def load_mcp_tools_schema(self)-> None:
-        for server_name in self.mcp_server_names:
-            self.mcp_tool_schemas[server_name] = []
-            mcp_tools = await self._mcp_client.get_tools(server_name=server_name)
-            for tool in mcp_tools:
-                input_schema = tool.args_schema
-                if server_name == self.GENERAL_MCP_SERVER_NAME:
-                    input_schema = str(tool.args_schema) # @todo remove task_id param
-                input_schema_str = str(input_schema) # @todo convert input tool.args_schema
-                tool_schema = XGAToolSchema(tool_name=tool.name,
-                                            server_name=server_name,
-                                            description=tool.description,
-                                            input_schema=input_schema_str)
-                self.mcp_tool_schemas[server_name].append(tool_schema)
+        if not self.is_loaded_tool_schemas:
+            for server_name in self.mcp_server_names:
+                self.mcp_tool_schemas[server_name] = []
+                mcp_tools = await self._mcp_client.get_tools(server_name=server_name)
+
+                for tool in mcp_tools:
+                    input_schema = tool.args_schema
+                    if server_name == self.GENERAL_MCP_SERVER_NAME:
+                        input_schema['properties'].pop("task_id", None)
+                        if 'task_id' in input_schema['required']:
+                            input_schema['required'].remove('task_id')
+                        params_properties = input_schema.get("properties", {})
+                        for param_properties in params_properties.values():
+                            param_properties.pop("title", None)
+
+                    metadata = tool.metadata or {}
+                    tool_schema = XGAToolSchema(tool_name=tool.name,
+                                                server_name=server_name,
+                                                description=tool.description,
+                                                input_schema=input_schema,
+                                                metadata=metadata)
+                    self.mcp_tool_schemas[server_name].append(tool_schema)
+            self.is_loaded_tool_schemas = True
+
+    async def reload_mcp_tools_schema(self) -> None:
+        self.is_loaded_tool_schemas = False
+        await self.load_mcp_tools_schema()
 
     @staticmethod
     def _load_mcp_servers_config(mcp_config_path: str) -> Dict[str, Any]:
@@ -164,10 +182,11 @@ class XGAMcpToolBox(XGAToolBox):
 if __name__ == "__main__":
     import asyncio
     from dataclasses import asdict
+
     async def main():
         task_id = "task1"
-        mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
-        #mcp_tool_box = XGAMcpToolBox()
+        #mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        mcp_tool_box = XGAMcpToolBox()
         await mcp_tool_box.load_mcp_tools_schema()
         await mcp_tool_box.creat_task_tool_box(task_id=task_id, general_tools=["*"], custom_tools=["bomc_fault.*"])
         tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "general_tool")
@@ -189,4 +208,5 @@ if __name__ == "__main__":
         print(f"call complete result: {result}")
 
         await mcp_tool_box.destroy_task_tool_box(task_id)
+
     asyncio.run(main())

xgae/engine/xga_prompt_builder.py

@@ -1,38 +1,97 @@
+import json
 import datetime
-
 from typing import Optional, List
 
-from xga_base import XGAToolSchema
-from xgae.utils.setup_env import read_file, XGAError
+from xga_base import XGAToolSchema, XGAError
+from xgae.utils.utils import read_file, format_file_with_args
 
 
 class XGAPromptBuilder():
-    def __init__(self,
-                 prompt_template: Optional[str] = None,
-                 prompt_template_file: Optional[str] = None):
-        self.system_prompt_template = None
-        if prompt_template:
-            self.system_prompt_template = prompt_template
-        elif prompt_template_file:
-            self.system_prompt_template = read_file(prompt_template_file)
-        else:
-            _system_prompt_template = read_file("templates/system_prompt_template.txt")
-            self.system_prompt_template = _system_prompt_template.format(
-                current_date=datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d'),
-                current_time=datetime.datetime.now(datetime.timezone.utc).strftime('%H:%M:%S'),
-                current_year=datetime.datetime.now(datetime.timezone.utc).strftime('%Y')
-            )
+    def __init__(self, system_prompt: Optional[str] = None):
+        self.system_prompt = system_prompt
 
+    def build_task_prompt(self, model_name: str, general_tool_schemas: List[XGAToolSchema], custom_tool_schemas: List[XGAToolSchema])-> str:
+        if self.system_prompt is None:
+            self.system_prompt = self._load_default_system_prompt(model_name)
 
-    def build_system_prompt(self, model_name:str, prompt_template: Optional[str]=None)-> str:
-        system_prompt = prompt_template if prompt_template else self.system_prompt_template
+        task_prompt = self.system_prompt
 
-        return system_prompt
+        tool_prompt = self.build_general_tool_prompt(general_tool_schemas)
+        task_prompt = task_prompt + "\n" + tool_prompt
+
+        tool_prompt = self.build_custom_tool_prompt(custom_tool_schemas)
+        task_prompt = task_prompt + "\n" + tool_prompt
+
+        return task_prompt
+
+    def build_general_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
+        tool_prompt = ""
+        tool_schemas = tool_schemas or []
+        if len(tool_schemas) > 0:
+            tool_prompt = read_file("templates/general_tool_prompt_template.txt")
+            example_prompt = ""
+            openai_schemas = []
+            for tool_schema in tool_schemas:
+                openai_schema = {}
+                openai_schema["type"] = "function"
+                openai_function = {}
+                openai_schema["function"] = openai_function
+
+                openai_function["name"] = tool_schema.tool_name
+                openai_function["description"] = tool_schema.description if tool_schema.description else 'No description available'
+
+                openai_parameters = {}
+                input_schema = tool_schema.input_schema
+                openai_function["parameters"] = openai_parameters
+                openai_parameters["type"] = input_schema["type"]
+                openai_parameters["properties"] = input_schema.get("properties", {})
+                openai_parameters["required"] = input_schema["required"]
+
+                openai_schemas.append(openai_schema)
+
+                metadata = tool_schema.metadata or {}
+                example = metadata.get("example", None)
+                if example:
+                    example_prompt += f"\n{example}\n"
 
+            schema_prompt = json.dumps(openai_schemas, ensure_ascii=False, indent=2)
+            tool_prompt = tool_prompt.format(tool_schemas=schema_prompt, tool_examples=example_prompt)
+        return tool_prompt
 
-    def build_general_tool_prompt(self, model_name:str, prompt_template: str, tool_schemas:List[XGAToolSchema])-> str:
-        pass
+
+    def build_custom_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
+        tool_prompt = ""
+        tool_schemas = tool_schemas or []
+        if len(tool_schemas) > 0:
+            tool_prompt = read_file("templates/custom_tool_prompt_template.txt")
+            tool_info = ""
+            for tool_schema in tool_schemas:
+                description = tool_schema.description if tool_schema.description else 'No description available'
+                tool_info += f"- **{tool_schema.tool_name}**: {description}\n"
+                parameters = tool_schema.input_schema.get("properties", {})
+                tool_info += f"  Parameters: {parameters}\n"
+            tool_prompt = tool_prompt.replace("{tool_schemas}", tool_info)
+
+        return tool_prompt
+
+    def _load_default_system_prompt(self, model_name) -> Optional[str]:
+        if "gemini-2.5-flash" in model_name.lower() and "gemini-2.5-pro" not in model_name.lower():
+            system_prompt_template = read_file("templates/gemini_system_prompt_template.txt")
+        else:
+            system_prompt_template = read_file("templates/system_prompt_template.txt")
+
+        system_prompt = format_file_with_args(system_prompt_template, {"datetime": datetime})
+
+        system_prompt = system_prompt.format(
+            current_date=datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d'),
+            current_time=datetime.datetime.now(datetime.timezone.utc).strftime('%H:%M:%S'),
+            current_year=datetime.datetime.now(datetime.timezone.utc).strftime('%Y')
+        )
+
+        if "anthropic" not in model_name.lower():
+            sample_response = read_file("templates/system_prompt_response_sample.txt")
+            system_prompt = system_prompt + "\n\n <sample_assistant_response>" + sample_response + "</sample_assistant_response>"
+
+        return system_prompt
 
 
-    def build_custom_tool_prompt(self, model_name:str, prompt_template: str, tool_schemas:List[XGAToolSchema])-> str:
-        pass

xgae/utils/llm_client.py

@@ -9,8 +9,6 @@ from typing import Union, Dict, Any, Optional, List
 from litellm.utils import ModelResponse, CustomStreamWrapper
 from openai import OpenAIError
 
-from setup_env import setup_xga_env
-
 
 class LLMError(Exception):
     """Base exception for LLM-related errors."""
@@ -20,7 +18,7 @@ class LLMClient:
     RATE_LIMIT_DELAY = 30
     RETRY_DELAY = 0.1
 
-    def __init__(self, llm_config: Optional[Dict[str, Any]]={}) -> None:
+    def __init__(self, llm_config: Optional[Dict[str, Any]]=None) -> None:
         """
         Arg: llm_config (Optional[Dict[str, Any]], optional)
             model: Override default model to use, default set by .env LLM_MODEL
@@ -36,6 +34,7 @@ class LLMClient:
             reasoning_effort: Optional level of reasoning effort, default is  ‘low’
             top_p: Optional Top-p sampling parameter, default is None
         """
+        llm_config = llm_config or {}
         litellm.modify_params = True
         litellm.drop_params = True
 
@@ -214,8 +213,6 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
-    setup_xga_env()
-
     async def llm_completion():
         llm_client = LLMClient({
             "stream": False #default is True

xgae/utils/setup_env.py

@@ -1,107 +1,95 @@
 import logging
 import os
-import traceback
 
 from langfuse import Langfuse
 
+_log_initialized = False
 
-class XGAError(Exception):
-    """Custom exception for errors in the XGA system."""
-    pass
+def setup_logging() -> None:
+    global _log_initialized
+    if not _log_initialized:
+        import colorlog
+        from dotenv import load_dotenv
+        load_dotenv()
 
-langfuse: Langfuse = None
+        env_log_level = os.getenv("LOG_LEVEL", "INFO")
+        env_log_file = os.getenv("LOG_FILE", "log/xga.log")
+        log_level = getattr(logging, env_log_level.upper(), logging.INFO)
 
-def setup_langfuse() -> None:
-    env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
-    env_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
-    env_host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
-    global langfuse
-    if env_public_key and env_secret_key:
-        langfuse = Langfuse(tracing_enabled=True,
-                            public_key=env_public_key,
-                            secret_key=env_secret_key,
-                            host=env_host)
-        logging.info("utils.setup_langfuse: Langfuse initialized!")
-    else:
-        langfuse = Langfuse(tracing_enabled=False)
-        logging.warning("utils.setup_langfuse: Langfuse is disabled!")
+        log_dir = os.path.dirname(env_log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+        else:
+            os.remove(env_log_file)
 
-def setup_logging() -> None:
-    env_log_level = os.getenv("LOG_LEVEL", "INFO")
-    env_log_file = os.getenv("LOG_FILE", "log/xga.log")
-    log_level = getattr(logging, env_log_level.upper(), logging.INFO)
+        logger = logging.getLogger()
+        for handler in logger.handlers[:]:
+            logger.removeHandler(handler)
 
-    log_dir = os.path.dirname(env_log_file)
-    if log_dir and not os.path.exists(log_dir):
-        os.makedirs(log_dir, exist_ok=True)
-    else:
-        os.remove(env_log_file)
 
-    logger = logging.getLogger()
-    for handler in logger.handlers[:]:
-        logger.removeHandler(handler)
 
-    import colorlog
+        log_colors = {
+            'DEBUG': 'cyan',
+            'INFO': 'green',
+            'WARNING': 'yellow',
+            'ERROR': 'red',
+            'CRITICAL': 'red,bg_white'
+        }
 
-    log_colors = {
-        'DEBUG': 'cyan',
-        'INFO': 'green',
-        'WARNING': 'yellow',
-        'ERROR': 'red',
-        'CRITICAL': 'red,bg_white'
-    }
+        console_formatter = colorlog.ColoredFormatter('%(log_color)s%(asctime)s - %(levelname)-8s%(reset)s %(white)s%(message)s',
+            log_colors=log_colors,
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
 
-    console_formatter = colorlog.ColoredFormatter('%(log_color)s%(asctime)s - %(levelname)-8s%(reset)s %(white)s%(message)s',
-        log_colors=log_colors,
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
+        file_formatter = logging.Formatter(
+            '%(asctime)s -%(levelname)-8s  %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
 
-    file_formatter = logging.Formatter(
-        '%(asctime)s -%(levelname)-8s  %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(console_formatter)
 
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(console_formatter)
+        file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+        file_handler.setFormatter(file_formatter)
 
-    file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
-    file_handler.setFormatter(file_formatter)
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
 
-    logger.addHandler(console_handler)
-    logger.addHandler(file_handler)
+        logger.setLevel(log_level)
 
-    logger.setLevel(log_level)
+        logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
 
-    logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
+    _log_initialized = True
 
+setup_logging()
 
-def handle_error(e: Exception) -> None:
-    logging.error("An error occurred: %s", str(e))
-    logging.error("Traceback details:\n%s", traceback.format_exc())
-    raise (e) from e
+_langfuse_initialized = False
 
-def read_file(file_path: str) -> str:
-    if not os.path.exists(file_path):
-        logging.error(f"File '{file_path}' not found")
-        raise XGAError(f"File '{file_path}' not found")
+def setup_langfuse() -> Langfuse:
+    global _langfuse_initialized
+    _langfuse = None
+    if not _langfuse_initialized:
+        env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+        env_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+        env_host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
+        if env_public_key and env_secret_key:
+            _langfuse = Langfuse(tracing_enabled=True,
+                                public_key=env_public_key,
+                                secret_key=env_secret_key,
+                                host=env_host)
+            logging.info("Langfuse initialized Successfully by Key !")
+        else:
+            _langfuse = Langfuse(tracing_enabled=False)
+            logging.warning("Not set key, Langfuse is disabled!")
 
-    try:
-        with open(file_path, "r", encoding="utf-8") as template_file:
-            content = template_file.read()
-        return content
-    except Exception as e:
-        logging.error(f"Read file '{file_path}' failed")
-        handle_error(e)
+    _langfuse_initialized = True
+    return _langfuse
+
+langfuse: Langfuse = Langfuse if _langfuse_initialized else setup_langfuse()
 
-def setup_xga_env() -> None:
-    from dotenv import load_dotenv
-    load_dotenv()
-    setup_logging()
-    setup_langfuse()
 
 if __name__ == "__main__":
     try:
-        setup_xga_env()
         trace_id = langfuse.create_trace_id()
         print(f"trace_id={trace_id}")
     except Exception as e:

xgae/utils/utils.py

@@ -0,0 +1,42 @@
+import logging
+import os
+import sys
+import datetime
+
+from typing import Any, Dict
+
+def handle_error(e: Exception) -> None:
+    import traceback
+
+    logging.error("An error occurred: %s", str(e))
+    logging.error("Traceback details:\n%s", traceback.format_exc())
+    raise (e) from e
+
+def read_file(file_path: str) -> str:
+    if not os.path.exists(file_path):
+        logging.error(f"File '{file_path}' not found")
+        raise Exception(f"File '{file_path}' not found")
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as template_file:
+            content = template_file.read()
+        return content
+    except Exception as e:
+        logging.error(f"Read file '{file_path}' failed")
+        handle_error(e)
+
+def format_file_with_args(file_content:str, args: Dict[str, Any])-> str:
+    from io import StringIO
+
+    formated = file_content
+    original_stdout = sys.stdout
+    buffer = StringIO()
+    sys.stdout = buffer
+    try:
+        code = f"print(f\"\"\"{file_content}\"\"\")"
+        exec(code, args)
+        formated = buffer.getvalue()
+    finally:
+        sys.stdout = original_stdout
+
+    return formated

{xgae-0.1.1.dist-info → xgae-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.1
+Version: 0.1.3
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.13
 Requires-Dist: colorlog>=6.9.0

xgae-0.1.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/xga_base.py,sha256=b9FnBbCuO4lCAIBBhnedtRk49Dl3M6cBn5h_Wkzw4o0,1345
+xgae/engine/xga_engine.py,sha256=kci7pvF8NwAYJ3Y6DS0JKLkPEQERZwcwRzjcAFQx_ec,4169
+xgae/engine/xga_mcp_tool_box.py,sha256=coyQy7tj2YTBpOc0JKmVBJO8ItO4Z6s1pdbucHd85qg,9762
+xgae/engine/xga_prompt_builder.py,sha256=RuTvQCNufqxDwVvSOPXR0qxAc42cG7NuIaUy9amu66A,4351
+xgae/engine/responser/xga_non_stream_responser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/responser/xga_responser_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/responser/xga_stream_reponser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/utils/llm_client.py,sha256=UMMK84psLsx36-Nn6Q8X1hl9wd-OdaS9ZhxbRjwNCr0,12149
+xgae/utils/setup_env.py,sha256=vY2wnq5KMXQ2dx2wAPeTpudp7b-fvgzenkwHpgd8vuI,2951
+xgae/utils/utils.py,sha256=cCYmWjKFksZ8BRD1YYnaM_jTLVHAg1ibEdjsczEUO6k,1134
+xgae-0.1.3.dist-info/METADATA,sha256=t4sr4k9pbVAcicIRjoqt327eWtSC0uAeo2pDB5LPjs0,309
+xgae-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.3.dist-info/RECORD,,

xgae-0.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/xga_base.py,sha256=ZuOVD5mLnfi8rTnDspY8qfEgwefVTTYgf6eY3B_001s,1213
-xgae/engine/xga_engine.py,sha256=3U0F3_ISu5K1CGYhn0RZsIaZkm4OQIrMTIf3N22M7bE,3013
-xgae/engine/xga_mcp_tool_box.py,sha256=3L48c-Wl8QghbudUsZdYemOzEHoOGF0QC-sAh0H1PVI,9047
-xgae/engine/xga_prompt_builder.py,sha256=wPCB6g0QNpKDuvWs5Ix_Z8-OoCFjxqApodb-g-qZrbM,1503
-xgae/engine/responser/xga_non_stream_responser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/responser/xga_responser_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/responser/xga_stream_reponser.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/utils/llm_client.py,sha256=bsdWLTXRDDpiuEn72a5BuT4FYomE1LjY-thQHbTQ_Fg,12167
-xgae/utils/setup_env.py,sha256=nJHllWuM9kLs_mJg_-j3Lhj8FHtyFjK4CIoDY_SHOxk,3253
-xgae-0.1.1.dist-info/METADATA,sha256=_j2ZiXzJZa-sw_fk7P0sHkKiyYus_ncxoL9YoZEv4iQ,309
-xgae-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.1.dist-info/RECORD,,