xgae 0.1.1__tar.gz → 0.1.2__tar.gz

{xgae-0.1.1 → xgae-0.1.2}/.idea/misc.xml

@@ -3,5 +3,5 @@
   <component name="Black">
     <option name="sdkName" value="Python 3.13 (xgae)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/DevelopSpace/xgae/.venv" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" project-jdk-type="Python SDK" />
 </project>

{xgae-0.1.1 → xgae-0.1.2}/.idea/workspace.xml

@@ -29,16 +29,20 @@
   "keyToString": {
     "ModuleVcsDetector.initialDetectionPerformed": "true",
     "Python.llm_client.executor": "Run",
+    "Python.run_xga_engine.executor": "Debug",
+    "Python.setup_env.executor": "Run",
     "Python.utils.executor": "Run",
-    "Python.xga_mcp_tool_box.executor": "Run",
+    "Python.xga_engine.executor": "Run",
+    "Python.xga_mcp_tool_box.executor": "Debug",
+    "Python.xga_prompt_builder.executor": "Debug",
     "RunOnceActivity.ShowReadmeOnStart": "true",
-    "last_opened_file_path": "/Users/goosezzy/DevelopSpace/xgae",
+    "last_opened_file_path": "/Users/sharkystar/DevProjects/xga/xgae",
     "node.js.detected.package.eslint": "true",
     "node.js.detected.package.tslint": "true",
     "node.js.selected.package.eslint": "(autodetect)",
     "node.js.selected.package.tslint": "(autodetect)",
     "nodejs_package_manager_path": "npm",
-    "settings.editor.selected.configurable": "preferences.general",
+    "settings.editor.selected.configurable": "com.intellij.pycharm.community.ide.impl.configuration.PythonContentEntriesConfigurable",
     "vue.rearranger.settings.migration": "true"
   }
 }</component>
@@ -57,6 +61,7 @@
         <env name="PYTHONUNBUFFERED" value="1" />
       </envs>
       <option name="SDK_HOME" value="" />
+      <option name="SDK_NAME" value="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" />
       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
       <option name="IS_MODULE_SDK" value="false" />
       <option name="ADD_CONTENT_ROOTS" value="true" />
@@ -81,6 +86,39 @@
       <option name="INPUT_FILE" value="" />
       <method v="2" />
     </configuration>
+    <configuration name="run_xga_engine" type="PythonConfigurationType" factoryName="Python">
+      <module name="xgae" />
+      <option name="ENV_FILES" value="" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <EXTENSION ID="net.ashald.envfile">
+        <option name="IS_ENABLED" value="false" />
+        <option name="IS_SUBST" value="false" />
+        <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+        <option name="IS_IGNORE_MISSING_FILES" value="false" />
+        <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+        <ENTRIES>
+          <ENTRY IS_ENABLED="true" PARSER="runconfig" IS_EXECUTABLE="false" />
+        </ENTRIES>
+      </EXTENSION>
+      <option name="SCRIPT_NAME" value="$PROJECT_DIR$/src/xgae/engine/xga_engine.py" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
   </component>
   <component name="SharedIndexes">
     <attachedChunks>
@@ -104,25 +142,37 @@
       <workItem from="1755270285722" duration="12068000" />
       <workItem from="1755283728206" duration="1511000" />
       <workItem from="1755286552901" duration="3130000" />
-      <workItem from="1755307767865" duration="337000" />
-      <workItem from="1755308113420" duration="2825000" />
-      <workItem from="1755321931380" duration="8531000" />
-      <workItem from="1755330830188" duration="229000" />
-      <workItem from="1755396985976" duration="6435000" />
-      <workItem from="1755415614018" duration="461000" />
-      <workItem from="1755416476555" duration="256000" />
-      <workItem from="1755419142521" duration="150000" />
-      <workItem from="1755429851003" duration="290000" />
-      <workItem from="1755430331676" duration="21000" />
+      <workItem from="1755409529770" duration="670000" />
+      <workItem from="1755478595168" duration="20000" />
+      <workItem from="1755479257156" duration="16895000" />
+      <workItem from="1755525531052" duration="13030000" />
+      <workItem from="1755585869510" duration="5796000" />
+      <workItem from="1755593112104" duration="786000" />
+      <workItem from="1755611972189" duration="671000" />
     </task>
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">
     <option name="version" value="3" />
   </component>
+  <component name="XDebuggerManager">
+    <breakpoint-manager>
+      <default-breakpoints>
+        <breakpoint type="python-exception">
+          <properties notifyOnTerminate="true" exception="BaseException">
+            <option name="notifyOnTerminate" value="true" />
+          </properties>
+        </breakpoint>
+      </default-breakpoints>
+    </breakpoint-manager>
+  </component>
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
-    <SUITE FILE_PATH="coverage/xgae$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755430037796" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1755247632274" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$xga_engine.coverage" NAME="xga_engine Coverage Results" MODIFIED="1755580277172" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$xga_prompt_builder.coverage" NAME="xga_prompt_builder Coverage Results" MODIFIED="1755587456555" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_xga_engine.coverage" NAME="run_xga_engine Coverage Results" MODIFIED="1755593194247" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$utils.coverage" NAME="utils Coverage Results" MODIFIED="1755226923439" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1755565531587" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755583099719" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1755565705235" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
   </component>
 </project>

{xgae-0.1.1 → xgae-0.1.2}/.idea/xgae.iml

@@ -5,7 +5,7 @@
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
       <excludeFolder url="file://$MODULE_DIR$/.venv" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.13 virtualenv at ~/DevelopSpace/xgae/.venv" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

{xgae-0.1.1 → xgae-0.1.2}/PKG-INFO

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

{xgae-0.1.1 → xgae-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.1"
+version = "0.1.2"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"

{xgae-0.1.1 → xgae-0.1.2}/src/xgae/engine/xga_base.py

@@ -20,7 +20,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-0.1.2/src/xgae/engine/xga_engine.py

@@ -0,0 +1,105 @@
+
+from typing import List, Any, Dict, Optional, AsyncGenerator
+from uuid import uuid4
+
+from xgae.engine.xga_base import XGAMessage, XGAToolSchema, 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():
+    def __init__(self,
+                 session_id: Optional[str] = None,
+                 trace_id: Optional[str] = None,
+                 agent_id: 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.agent_id = agent_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.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) -> None:
+        await  self.tool_box.load_mcp_tools_schema()
+
+    @classmethod
+    async def create(cls,
+                     session_id: Optional[str] = None,
+                     trace_id: Optional[str] = None,
+                     agent_id: Optional[str] = None,
+                     llm_config: Optional[Dict[str, Any]] = None,
+                     prompt_builder: Optional[XGAPromptBuilder] = None,
+                     tool_box: Optional[XGAToolBox] = None) -> 'XGAEngine' :
+        engine: XGAEngine = cls(session_id=session_id,
+                                trace_id=trace_id,
+                                agent_id=agent_id,
+                                llm_config=llm_config,
+                                prompt_builder=prompt_builder,
+                                tool_box=tool_box)
+
+        await engine.__async_init__()
+        return engine
+
+
+    async def run_task(self,
+                       task_messages: List[Dict[str, Any]],
+                       task_id: Optional[str] = None,
+                       system_prompt: Optional[str] = None,
+                       general_tools: Optional[List[str]] = ["*"],
+                       custom_tools: Optional[List[str]] = []) -> 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)
+            task_prompt = self.build_task_prompt(system_prompt)
+            yield task_prompt
+
+        finally:
+            await self.tool_box.destroy_task_tool_box(self.task_id)
+        
+
+    def _run_task_once(self):
+        pass
+
+    def build_task_prompt(self, system_prompt: Optional[str] = None) -> str:
+        task_prompt = self.prompt_builder.build_system_prompt(self.model_name, system_prompt)
+
+        tool_schemas =self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        tool_prompt = self.prompt_builder.build_general_tool_prompt(tool_schemas)
+        task_prompt = task_prompt + "\n" + tool_prompt
+
+        tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+        tool_prompt = self.prompt_builder.build_custom_tool_prompt(tool_schemas)
+        task_prompt = task_prompt + "\n" + tool_prompt
+
+        return task_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")
+        tool_box = None
+        engine = await XGAEngine.create(tool_box=tool_box)
+        # async for chunk in engine.run_task(task_messages=[{}], custom_tools=["bomc_fault.*"]):
+        async for chunk in engine.run_task(task_messages=[{}], custom_tools=[]):
+             print(chunk)
+
+    asyncio.run(main())

{xgae-0.1.1 → xgae-0.1.2}/src/xgae/engine/xga_mcp_tool_box.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import os
+
 from typing import List, Any, Dict, Optional, Literal, override
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
@@ -14,8 +15,9 @@ 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 +33,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 +45,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 +126,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 +183,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 +209,5 @@ if __name__ == "__main__":
         print(f"call complete result: {result}")
 
         await mcp_tool_box.destroy_task_tool_box(task_id)
+
     asyncio.run(main())

xgae-0.1.2/src/xgae/engine/xga_prompt_builder.py

@@ -0,0 +1,115 @@
+import datetime
+import sys
+import json
+
+from typing import Optional, List
+from io import StringIO
+
+from xga_base import XGAToolSchema
+from xgae.utils.setup_env import read_file, XGAError
+
+
+class XGAPromptBuilder():
+    def __init__(self, system_prompt_template: Optional[str] = None):
+        self.system_prompt = None
+        if system_prompt_template:
+            self.system_prompt = system_prompt_template
+
+    def build_system_prompt(self, model_name: str, system_prompt: Optional[str]=None)-> str:
+        task_system_prompt = system_prompt if system_prompt else self.system_prompt
+        if task_system_prompt is None:
+            task_system_prompt = self._load_default_system_prompt(model_name)
+        return task_system_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_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"
+                tool_info += f"  Parameters: {tool_schema.input_schema}\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():
+            org_prompt_template = read_file("templates/gemini_system_prompt_template.txt")
+        else:
+            org_prompt_template = read_file("templates/system_prompt_template.txt")
+
+        original_stdout = sys.stdout
+        buffer = StringIO()
+        sys.stdout = buffer
+        try:
+            namespace = {
+                "datetime": datetime,
+                "__builtins__": __builtins__
+            }
+            code = f"print(f\"\"\"{org_prompt_template}\"\"\")"
+            exec(code, namespace)
+            system_prompt_template = buffer.getvalue()
+        finally:
+            sys.stdout = original_stdout
+
+        system_prompt = 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')
+        )
+
+        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
+
+if __name__ == "__main__":
+
+    prompt_builder = XGAPromptBuilder()
+    prompt = prompt_builder.build_system_prompt("openai/qwen3-235b-a22b")
+
+    # system_prompt = read_file("templates/scp_test_prompt.txt")
+    # prompt = prompt_builder.build_system_prompt("openai/qwen3-235b-a22b", system_prompt=system_prompt)
+
+    print(prompt)
+
+

{xgae-0.1.1 → xgae-0.1.2}/src/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-0.1.2/src/xgae/utils/setup_env.py

@@ -0,0 +1,123 @@
+import logging
+import os
+import traceback
+
+from langfuse import Langfuse
+
+
+_log_initialized = False
+
+def setup_logging() -> None:
+    global _log_initialized
+    if not _log_initialized:
+        import colorlog
+        from dotenv import load_dotenv
+        load_dotenv()
+
+        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)
+
+        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)
+
+
+
+        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'
+        )
+
+        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)
+
+        file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+        file_handler.setFormatter(file_formatter)
+
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
+
+        logger.setLevel(log_level)
+
+        logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
+
+    _log_initialized = True
+
+setup_logging()
+
+
+class XGAError(Exception):
+    """Custom exception for errors in the XGA system."""
+    pass
+
+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 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!")
+
+    _langfuse_initialized = True
+    return _langfuse
+
+langfuse: Langfuse = Langfuse if _langfuse_initialized else setup_langfuse()
+
+
+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")
+
+    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)
+
+
+if __name__ == "__main__":
+    try:
+        trace_id = langfuse.create_trace_id()
+        print(f"trace_id={trace_id}")
+    except Exception as e:
+        handle_error(e)