xgae 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

xgae/engine/mcp_tool_box.py

@@ -113,15 +113,20 @@ class XGAMcpToolBox(XGAToolBox):
         async with self._mcp_client.session(server_name) as session:
             tools = await load_mcp_tools(session)
             mcp_tool = next((t for t in tools if t.name == tool_name), None)
-
+            is_general_tool = False
             if mcp_tool:
                 tool_args = args or {}
                 if server_name == self.GENERAL_MCP_SERVER_NAME:
                     tool_args = dict({"task_id": task_id}, **tool_args)
+                    is_general_tool = True
 
                 try:
                     tool_result = await mcp_tool.arun(tool_args)
-                    result = XGAToolResult(success=True, output=str(tool_result))
+                    if is_general_tool:
+                        tool_result = json.loads(tool_result)
+                        result = XGAToolResult(success=tool_result['success'], output=str(tool_result['output']))
+                    else:
+                        result = XGAToolResult(success=True, output=str(tool_result))
                 except Exception as e:
                     error = f"Call mcp tool '{tool_name}' error: {str(e)}"
                     logging.error(f"McpToolBox call_tool: {error}")

xgae/engine/responser/non_stream_responser.py

@@ -2,7 +2,7 @@ import logging
 
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
 
-from xgae.utils import handle_error
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import format_for_yield
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
@@ -88,11 +88,10 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                 finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
                 yield format_for_yield(finish_msg)
         except Exception as e:
-            logging.error(f"NonStreamResp: Process response llm_content: {llm_content}")
-            handle_error(e)
+            trace = log_trace(e, f"NonStreamResp: Process response llm_content:\n {llm_content}")
             self.root_span.event(name="non_stream_process_response_error", level="ERROR",
                                  status_message=f"Process non-streaming response error: {e}",
-                                 metadata={"content": llm_content})
+                                 metadata={"content": llm_content, "trace": trace})
 
             content = {"role": "system", "status_type": "error", "message": f"Process non-streaming response error: {e}"}
             error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)

xgae/engine/responser/responser_base.py

@@ -6,7 +6,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple, Union, Literal, Callable, TypedDict, AsyncGenerator
 
-from xgae.utils import handle_error
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import safe_json_parse
 from xgae.utils.xml_tool_parser import XMLToolParser
 
@@ -174,10 +174,10 @@ class TaskResponseProcessor(ABC):
 
                     pos = max(pos + 1, current_pos)
         except Exception as e:
-            logging.error(f"TaskProcessor extract_xml_chunks: Error extracting XML chunks: {content}")
-            handle_error(e)
+            trace = log_trace(e, f"TaskProcessor extract_xml_chunks: Error extracting XML chunks: {content}")
             self.root_span.event(name="task_process_extract_xml_chunk_error", level="ERROR",
-                                 status_message=(f"Error extracting XML chunks: {e}"), metadata={"content": content})
+                                 status_message=f"Error extracting XML chunks: {e}",
+                                 metadata={"content": content, "trace": trace})
 
         return chunks
 
@@ -197,13 +197,13 @@ class TaskResponseProcessor(ABC):
 
                 if not parsed_calls:
                     logging.error(f"TaskProcessor parse_xml_tool_call: No tool calls found in XML chunk: {xml_chunk}")
-                    return
+                    return None
 
                 # Take the first tool call (should only be one per chunk)
                 xml_tool_call = parsed_calls[0]
                 if not xml_tool_call.function_name:
                     logging.error(f"TaskProcessor parse_xml_tool_call: xml_tool_call function name is empty: {xml_tool_call}")
-                    return
+                    return None
 
                 # Convert to the expected format
                 tool_call = {
@@ -222,10 +222,11 @@ class TaskResponseProcessor(ABC):
             # If not the expected <function_calls><invoke> format, return None
             logging.error(f"TaskProcessor parse_xml_tool_call: XML chunk does not contain expected <function_calls><invoke> format: {xml_chunk}")
         except Exception as e:
-            logging.error(f"TaskProcessor parse_xml_tool_call: Error parsing XML chunk: {xml_chunk}")
-            handle_error(e)
+            trace = log_trace(e, f"TaskProcessor parse_xml_tool_call: Error parsing XML chunk: {xml_chunk}")
             self.root_span.event(name="task_process_parsing_xml_chunk_error", level="ERROR",
-                                 status_message=(f"Error parsing XML chunk: {e}"), metadata={"xml_chunk": xml_chunk})
+                                 status_message=f"Error parsing XML chunk: {e}",
+                                 metadata={"xml_chunk": xml_chunk, "trace": trace})
+            return None
 
     def _parse_xml_tool_calls(self, content: str) -> List[Dict[str, Any]]:
         """Parse XML tool calls from content string.
@@ -247,10 +248,10 @@ class TaskResponseProcessor(ABC):
                         "parsing_details": parsing_details
                     })
         except Exception as e:
-            logging.warning(f"TaskProcessor parse_xml_tool_calls: Error parsing XML tool calls, xml_chunk: {xml_chunk}")
-            handle_error(e)
+            trace = log_trace(e, f"TaskProcessor parse_xml_tool_calls: Error parsing XML tool calls, xml_chunk: {xml_chunk}")
             self.root_span.event(name="task_process_parse_xml_tool_calls_error", level="ERROR",
-                             status_message=(f"Error parsing XML tool calls: {e}"), metadata={"content": xml_chunk})
+                             status_message=f"Error parsing XML tool calls: {e}",
+                                 metadata={"content": xml_chunk, "trace": trace})
 
         return parsed_data
 
@@ -261,51 +262,50 @@ class TaskResponseProcessor(ABC):
         exec_tool_span = self.root_span.span(name=f"execute_tool.{function_name}", input=tool_call["arguments"])
         try:
             arguments = tool_call["arguments"]
-
-            logging.info(f"TaskProcessor execute_tool: Executing tool: {function_name} with arguments: {arguments}")
-
             if isinstance(arguments, str):
                 try:
                     arguments = safe_json_parse(arguments)
                 except json.JSONDecodeError:
-                    arguments = {"text": arguments} # @todo modify
+                    logging.warning(f"TaskProcessor execute_tool: Tool '{function_name}' arguments is not dict type, args={arguments}")
+                    arguments = {"text": arguments}  # useless
 
             result = None
             available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
             if function_name in available_tool_names:
+                logging.info(f"TaskProcessor execute_tool: Tool '{function_name}' executing, args={arguments}")
                 result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
             else:
                 logging.error(f"TaskProcessor execute_tool: Tool function '{function_name}' not found in toolbox")
                 result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
 
-            logging.info(f"TaskProcessor execute_tool: Tool execution complete: {function_name} -> {result}")
+            logging.info(f"TaskProcessor execute_tool: Tool '{function_name}' execution complete, result: {result}")
             exec_tool_span.update(status_message="tool_executed", output=result)
 
             return result
         except Exception as e:
-            logging.error(f"TaskProcessor execute_tool: Error executing tool {function_name}")
+            trace = log_trace(e, f"TaskProcessor execute_tool: Executing tool {function_name}")
 
             exec_tool_span.update(status_message="task_process_tool_exec_error", level="ERROR",
-                                  output=f"Error executing tool {function_name}, error: {str(e)}")
+                                  output=f"Error executing tool {function_name}, error: {str(e)}",
+                                  metadata={"trace": trace})
+
             return XGAToolResult(success=False, output=f"Executing tool {function_name}, error: {str(e)}")
 
-    async def _execute_tools(
-            self,
-            tool_calls: List[Dict[str, Any]],
-            execution_strategy: ToolExecutionStrategy = "sequential"
-    ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
-        logging.info(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}")
+    async def _execute_tools(self, tool_calls: List[Dict[str, Any]],
+                             execution_strategy: ToolExecutionStrategy = "sequential"
+                             ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
+        logging.info(f"TaskProcessor execute_tools: Executing {len(tool_calls)} tools with strategy '{execution_strategy}'")
 
         if execution_strategy == "sequential":
             return await self._execute_tools_sequentially(tool_calls)
         elif execution_strategy == "parallel":
             return await self._execute_tools_in_parallel(tool_calls)
         else:
-            logging.warning(f"Unknown execution strategy: {execution_strategy}, falling back to sequential")
+            logging.warning(f"TaskProcessor execute_tools: Unknown execution strategy '{execution_strategy}', use sequential")
             return await self._execute_tools_sequentially(tool_calls)
 
-    async def _execute_tools_sequentially(self, tool_calls: List[Dict[str, Any]]) -> List[
-        Tuple[Dict[str, Any], XGAToolResult]]:
+    # @todo refact below code
+    async def _execute_tools_sequentially(self, tool_calls: List[Dict[str, Any]]) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
         """Execute tool calls sequentially and return results.
 
         This method executes tool calls one after another, waiting for each tool to complete
@@ -319,6 +319,7 @@ class TaskResponseProcessor(ABC):
         """
         if not tool_calls:
             return []
+
         tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
         logging.info(f"Executing {len(tool_calls)} tools sequentially: {tool_names}")
         self.root_span.event(name="task_process_executing_tools_sequentially", level="DEFAULT",

xgae/engine/responser/stream_responser.py

@@ -1,9 +1,8 @@
 import logging
 
 from typing import List, Dict, Any, Optional, AsyncGenerator, override
-from importlib_metadata import metadata
 
-from xgae.utils import handle_error
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import format_for_yield
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
 
@@ -120,11 +119,10 @@ class StreamTaskResponser(TaskResponseProcessor):
                 finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
                 yield format_for_yield(finish_msg)
         except Exception as e:
-            logging.error(f"StreamResp: Process response llm_content: {accumulated_content}")
-            handle_error(e)
+            trace = log_trace(e, f"StreamResp: Process response accumulated_content:\n {accumulated_content}")
             self.root_span.event(name="stream_response_process_error", level="ERROR",
                                  status_message=f"Process streaming response error: {e}",
-                                 metadata={"content": accumulated_content})
+                                 metadata={"content": accumulated_content, "trace": trace})
 
             content = {"role": "system", "status_type": "error", "message": f"Process streaming response error: {e}"}
             error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)

xgae/engine/task_engine.py

@@ -5,7 +5,7 @@ import os
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
 
-from xgae.utils import handle_error, to_bool
+from xgae.utils import log_trace, to_bool
 from xgae.utils.llm_client import LLMClient, LLMConfig
 from xgae.utils.json_helpers import format_for_yield
 
@@ -171,20 +171,19 @@ class XGATaskEngine:
                                     update_continuous_state(auto_continue_count, auto_continue)
                                     logging.info(f"TaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
                     except Exception as parse_error:
-                        logging.error(f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
-                        handle_error(parse_error)
+                        trace = log_trace(parse_error,f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
                         self.task_langfuse.root_span.event(name="engine_parse_chunk_error", level="ERROR",
-                                             status_message=(f"Task Engine parse chunk error: {parse_error}"),
-                                             metadata={"content": chunk})
+                                             status_message=f"Task Engine parse chunk error: {parse_error}",
+                                             metadata={"content": chunk, "trace": trace})
 
                         content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
                         error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
                         yield format_for_yield(error_msg)
             except Exception as run_error:
-                logging.error(f"TaskEngine run_task_auto: Call task_run_once error: {run_error}")
-                handle_error(run_error)
+                trace = log_trace(run_error, "TaskEngine run_task_auto: Call task_run_once")
                 self.task_langfuse.root_span.event(name="engine_task_run_once_error", level="ERROR",
-                                                   status_message=(f"Call task_run_once error: {run_error}"))
+                                                   status_message=f"Call task_run_once error: {run_error}",
+                                                   metadata={"trace": trace})
 
                 content = {"role": "system", "status_type": "error", "message": "Call run_task_once error"}
                 error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
@@ -268,11 +267,10 @@ class XGATaskEngine:
                 logging.warning(f"❌ FINAL_RESULT: LLM Result is EMPTY, finish_reason={finish_reason}")
                 final_result = XGATaskResult(type="error", content="LLM has no answer")
         except Exception as e:
-            logging.error(f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
-            handle_error(e)
+            trace = log_trace(e, f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
             self.task_langfuse.root_span.event(name="engine_parse_final_result_error", level="ERROR",
-                                               status_message=(f"Task Engine parse final result error: {e}"),
-                                               metadata={"content": chunk})
+                                               status_message=f"Task Engine parse final result error: {e}",
+                                               metadata={"content": chunk, "trace": trace})
 
             final_result = XGATaskResult(type="error", content="Parse final result failed!")
 
@@ -321,8 +319,7 @@ class XGATaskEngine:
                     _content = json.loads(content)
                     response_llm_contents.append(_content)
                 except json.JSONDecodeError as e:
-                    logging.error(f"TaskEngine get_history_llm_messages: Failed to decode json, content: {content}")
-                    handle_error(e)
+                    pass
             else:
                 response_llm_contents.append(content)
 
@@ -386,10 +383,9 @@ class XGATaskEngine:
                 logging.debug(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
             else:
                 logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
-
         except Exception as e:
-            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk log error， chunk: {chunk}")
-            handle_error(e)
+            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
+
 
 
 if __name__ == "__main__":

xgae/tools/without_general_tools_app.py

@@ -3,6 +3,7 @@ from pydantic import Field
 
 from mcp.server.fastmcp import FastMCP
 
+from xgae.engine.engine_base import  XGAToolResult
 
 mcp = FastMCP(name="XGAE Message Tools")
 
@@ -16,7 +17,7 @@ async def complete(task_id: str,
                        description="Comma-separated list of final outputs. Use when: 1) Completion relates to files 2) User needs to review outputs 3) Deliverables in files")]
                    ):
     print(f"<XGAETools-complete>: task_id={task_id}, text={text}, attachments={attachments}")
-    return {"status": "complete"}
+    return XGAToolResult(success=True, output=str({"status": "complete"}))
 
 
 @mcp.tool(
@@ -29,7 +30,7 @@ async def ask(task_id: str,
                   description="Comma-separated list of files/URLs to attach. Use when: 1) Question relates to files/configs 2) User needs to review content 3) Options documented in files 4) Supporting evidence needed")]
               ):
     print(f"<XGAETools-ask>: task_id={task_id}, text={text}, attachments={attachments}")
-    return {"status": "Awaiting user response..."}
+    return XGAToolResult(success=True, output=str({"status": "Awaiting user response..."}))
 
 @mcp.tool(
     description="end task, destroy sandbox"

xgae/utils/__init__.py

@@ -1,11 +1,22 @@
 import logging
 
-def handle_error(e: Exception) -> None:
+
+def log_trace(exception: Exception, error: str=None) -> str:
+    import traceback
+
+    if error:
+        logging.error(f"{error} , error: {exception}")
+
+    trace_info = traceback.format_exc()
+    logging.error("Trace Details:\n%s", traceback.format_exc())
+
+    return trace_info
+
+
+def get_trace() -> str:
     import traceback
 
-    logging.error("An error occurred: %s", str(e))
-    logging.error("Traceback details:\n%s", traceback.format_exc())
-    raise (e) from e
+    return traceback.format_exc()
 
 
 def to_bool(value: any) -> bool:
@@ -13,3 +24,4 @@ def to_bool(value: any) -> bool:
         return False
 
     return str(value).lower() == "true"
+

xgae/utils/misc.py

@@ -4,7 +4,6 @@ import sys
 
 from typing import Any, Dict
 
-from xgae.utils import handle_error
 
 def read_file(file_path: str) -> str:
     if not os.path.exists(file_path):
@@ -17,7 +16,7 @@ def read_file(file_path: str) -> str:
         return content
     except Exception as e:
         logging.error(f"Read file '{file_path}' failed")
-        handle_error(e)
+        raise
 
 def format_file_with_args(file_content:str, args: Dict[str, Any])-> str:
     from io import StringIO

{xgae-0.1.12.dist-info → xgae-0.1.13.dist-info}/METADATA

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

xgae-0.1.13.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=vKuCIJw0gwXdtkT-QNCZKt2dE53thvTFwQr7nTgvaPY,3000
+xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
+xgae/engine/mcp_tool_box.py,sha256=eE4qGxTHaSMMNDDWWafNXFT-vj_YYof4AjVSsxKoq68,10413
+xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
+xgae/engine/task_engine.py,sha256=ZWxi292fceWvZuv501lwUGgb_PStktmfLFDzhDlsFfY,21011
+xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
+xgae/engine/responser/non_stream_responser.py,sha256=RS2fIP_XCWjZEVtFRSNDJ9wM1N66MuzA66wXm3Nz1Jg,5583
+xgae/engine/responser/responser_base.py,sha256=WsUMUfEE2cexAg5LzXA1yUECOkbs1ekh8HbJS5-R7f8,30813
+xgae/engine/responser/stream_responser.py,sha256=O6_wSwdbqjYO-XowiLvHZKuw-F6fvxyjWULhfkkF6ow,7830
+xgae/tools/without_general_tools_app.py,sha256=FGMV6njcOKwwfitc0j_nUov0RC-eWlhO1IP8_KHz1tQ,3788
+xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
+xgae/utils/json_helpers.py,sha256=ubp-dOCeROnZv7JHARRdmDIO5Npdwzrt8AWo3SMv0kI,4705
+xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,14361
+xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
+xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
+xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
+xgae-0.1.13.dist-info/METADATA,sha256=8y0v909gMEo6oyUYTrY5ZjRP8ACB8U-BPHZTDd5uq4M,310
+xgae-0.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.13.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
+xgae-0.1.13.dist-info/RECORD,,

xgae-0.1.12.dist-info/RECORD

@@ -1,21 +0,0 @@
-xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
-xgae/cli_app.py,sha256=vKuCIJw0gwXdtkT-QNCZKt2dE53thvTFwQr7nTgvaPY,3000
-xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
-xgae/engine/mcp_tool_box.py,sha256=Vyku8uOsTZ4ElnwEEgaw0hiltTOlC-FvtC9Ox-iJYck,10089
-xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
-xgae/engine/task_engine.py,sha256=J4hVAkRgmd24larSFjxoCaVh9r3fDZJ95fUGB-FICZ8,21174
-xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
-xgae/engine/responser/non_stream_responser.py,sha256=za1-7b37jVcg1cgTadNNXljqUTbzA92168i80xV7zdw,5589
-xgae/engine/responser/responser_base.py,sha256=WA2oKqP-UhQZj2es2nIFKf6_XkOhIfqZMUcQzDhtc6Q,30424
-xgae/engine/responser/stream_responser.py,sha256=dXcj-l3jb8J0orZ7THdf0sOjw9M7aZbfjHQC0NwQizo,7868
-xgae/tools/without_general_tools_app.py,sha256=cza3aLVh-090QABYA_DakoXmlFmc9rxwrXQsQwveT9A,3655
-xgae/utils/__init__.py,sha256=6lZCuEzMj66SW5sXyWrIuLH2W-1mHpbLpIBq_qbnsiw,337
-xgae/utils/json_helpers.py,sha256=ubp-dOCeROnZv7JHARRdmDIO5Npdwzrt8AWo3SMv0kI,4705
-xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,14361
-xgae/utils/misc.py,sha256=M8lMXYp1pHiY6Ee8ZTUG88GpOAsE5fbYoRO_hcBFUCE,953
-xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
-xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
-xgae-0.1.12.dist-info/METADATA,sha256=7bOOMvn3Ntj_v_tZy2hkfiNKyTABLhoZRKDb0CJkwpM,310
-xgae-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.12.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
-xgae-0.1.12.dist-info/RECORD,,