xgae 0.1.2__tar.gz → 0.1.3__tar.gz

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

@@ -25,27 +25,27 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
-    &quot;Python.llm_client.executor&quot;: &quot;Run&quot;,
-    &quot;Python.run_xga_engine.executor&quot;: &quot;Debug&quot;,
-    &quot;Python.setup_env.executor&quot;: &quot;Run&quot;,
-    &quot;Python.utils.executor&quot;: &quot;Run&quot;,
-    &quot;Python.xga_engine.executor&quot;: &quot;Run&quot;,
-    &quot;Python.xga_mcp_tool_box.executor&quot;: &quot;Debug&quot;,
-    &quot;Python.xga_prompt_builder.executor&quot;: &quot;Debug&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;last_opened_file_path&quot;: &quot;/Users/sharkystar/DevProjects/xga/xgae&quot;,
-    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
-    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
-    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
-    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
-    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
-    &quot;settings.editor.selected.configurable&quot;: &quot;com.intellij.pycharm.community.ide.impl.configuration.PythonContentEntriesConfigurable&quot;,
-    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "Python.llm_client.executor": "Run",
+    "Python.run_xga_engine.executor": "Run",
+    "Python.setup_env.executor": "Run",
+    "Python.utils.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/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": "com.intellij.pycharm.community.ide.impl.configuration.PythonContentEntriesConfigurable",
+    "vue.rearranger.settings.migration": "true"
   }
-}</component>
+}]]></component>
   <component name="RecentsManager">
     <key name="MoveFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$/src/xgae/engine/responser" />
@@ -148,7 +148,7 @@
       <workItem from="1755525531052" duration="13030000" />
       <workItem from="1755585869510" duration="5796000" />
       <workItem from="1755593112104" duration="786000" />
-      <workItem from="1755611972189" duration="671000" />
+      <workItem from="1755611972189" duration="6282000" />
     </task>
     <servers />
   </component>
@@ -169,7 +169,7 @@
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
     <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$run_xga_engine.coverage" NAME="run_xga_engine Coverage Results" MODIFIED="1755657339432" 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$" />

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

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

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

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

{xgae-0.1.2 → xgae-0.1.3}/src/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:

xgae-0.1.3/src/xgae/engine/xga_engine.py

@@ -0,0 +1,99 @@
+
+from typing import List, Any, Dict, Optional, AsyncGenerator
+from uuid import uuid4
+
+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 XGATaskEngine():
+    def __init__(self,
+                 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,
+                 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(system_prompt)
+        self.tool_box = tool_box or XGAMcpToolBox()
+
+
+    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]]) -> AsyncGenerator:
+        try:
+            yield self.task_prompt
+
+        finally:
+            await self.tool_box.destroy_task_tool_box(self.task_id)
+        
+
+    def _run_task_once(self):
+        pass
+
+
+    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-0.1.2 → xgae-0.1.3}/src/xgae/engine/xga_mcp_tool_box.py

@@ -7,9 +7,8 @@ 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"

{xgae-0.1.2 → xgae-0.1.3}/src/xgae/engine/xga_prompt_builder.py

@@ -1,25 +1,28 @@
-import datetime
-import sys
 import json
-
+import datetime
 from typing import Optional, List
-from io import StringIO
 
-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, system_prompt_template: Optional[str] = None):
-        self.system_prompt = None
-        if system_prompt_template:
-            self.system_prompt = system_prompt_template
+    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)
+
+        task_prompt = self.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
 
-    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
+        return task_prompt
 
     def build_general_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
         tool_prompt = ""
@@ -41,7 +44,7 @@ class XGAPromptBuilder():
                 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["properties"] = input_schema.get("properties", {})
                 openai_parameters["required"] = input_schema["required"]
 
                 openai_schemas.append(openai_schema)
@@ -65,32 +68,21 @@ class XGAPromptBuilder():
             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"
+                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():
-            org_prompt_template = read_file("templates/gemini_system_prompt_template.txt")
+            system_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(
+            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')
@@ -102,14 +94,4 @@ class XGAPromptBuilder():
 
         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.2 → xgae-0.1.3}/src/xgae/utils/setup_env.py

@@ -1,10 +1,8 @@
 import logging
 import os
-import traceback
 
 from langfuse import Langfuse
 
-
 _log_initialized = False
 
 def setup_logging() -> None:
@@ -65,17 +63,6 @@ def setup_logging() -> None:
 
 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:
@@ -101,20 +88,6 @@ def setup_langfuse() -> 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()

xgae-0.1.3/src/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.2/src/xgae/engine/xga_engine.py

@@ -1,105 +0,0 @@
-
-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())