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

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/engine/xga_engine.py

@@ -8,6 +8,7 @@ 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,
@@ -30,18 +31,39 @@ class XGAEngine():
         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],
-                       prompt_template: Optional[str] = None,
+                       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)
-            system_prompt = await self._build_system_prompt(prompt_template, general_tools, custom_tools)
-            yield system_prompt
+            task_prompt = self.build_task_prompt(system_prompt)
+            yield task_prompt
 
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
@@ -50,20 +72,34 @@ 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)
+    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 = 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 =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 = 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)
+        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 system_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/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/engine/xga_prompt_builder.py

@@ -1,38 +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,
-                 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)
+    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:
-            _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')
-            )
+            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
 
-    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
+        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)
 
-    def build_general_tool_prompt(self, model_name:str, prompt_template: str, tool_schemas:List[XGAToolSchema])-> str:
-        pass
+    print(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

@@ -5,81 +5,102 @@ import traceback
 from langfuse import Langfuse
 
 
-class XGAError(Exception):
-    """Custom exception for errors in the XGA system."""
-    pass
-
-langfuse: Langfuse = None
-
-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_initialized = False
 
 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)
+    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_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)
+        log_colors = {
+            'DEBUG': 'cyan',
+            'INFO': 'green',
+            'WARNING': 'yellow',
+            'ERROR': 'red',
+            'CRITICAL': 'red,bg_white'
+        }
 
-    logger = logging.getLogger()
-    for handler in logger.handlers[:]:
-        logger.removeHandler(handler)
+        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'
+        )
 
-    import colorlog
+        file_formatter = logging.Formatter(
+            '%(asctime)s -%(levelname)-8s  %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
 
-    log_colors = {
-        'DEBUG': 'cyan',
-        'INFO': 'green',
-        'WARNING': 'yellow',
-        'ERROR': 'red',
-        'CRITICAL': 'red,bg_white'
-    }
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(console_formatter)
 
-    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_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+        file_handler.setFormatter(file_formatter)
 
-    file_formatter = logging.Formatter(
-        '%(asctime)s -%(levelname)-8s  %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
 
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(console_formatter)
+        logger.setLevel(log_level)
 
-    file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
-    file_handler.setFormatter(file_formatter)
+        logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
 
-    logger.addHandler(console_handler)
-    logger.addHandler(file_handler)
+    _log_initialized = True
 
-    logger.setLevel(log_level)
+setup_logging()
 
-    logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
 
+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")
@@ -93,15 +114,9 @@ def read_file(file_path: str) -> str:
         logging.error(f"Read file '{file_path}' failed")
         handle_error(e)
 
-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-0.1.1.dist-info → xgae-0.1.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/xga_base.py,sha256=vOiYWoBze7VrmndYnaNhMzoB1zCT80WtIlOWdp2IrUc,1253
+xgae/engine/xga_engine.py,sha256=AgklNAimyErvn74xUu6aardZvgjqbIR99gCojEmZfO0,4267
+xgae/engine/xga_mcp_tool_box.py,sha256=jRYvZ8eY72KRU0leD-o15fe_E8wjWJtxQZbsIqGVjPU,9753
+xgae/engine/xga_prompt_builder.py,sha256=Q3nrmYAofRkFQFdfSWkP00FZKjWMUQs2cvMs7bvyQgQ,4819
+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=qZmVfqaYHtjq5t-zwRt_G3i-QqGPxSb4D2FnFHbhdcY,3689
+xgae-0.1.2.dist-info/METADATA,sha256=iBwWKlpbp7z0ZQgydnieP_2NBf0Z7H0D6AtavbIN3Zc,309
+xgae-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.2.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,,