xgae 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

xgae/utils/setup_env.py

@@ -3,91 +3,78 @@ import os
 
 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)
+    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)
 
-        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'
-        )
+    log_colors = {
+        'DEBUG': 'cyan',
+        'INFO': 'green',
+        'WARNING': 'yellow',
+        'ERROR': 'red',
+        'CRITICAL': 'red,bg_white'
+    }
 
-        file_formatter = logging.Formatter(
-            '%(asctime)s -%(levelname)-8s  %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
+    console_formatter = colorlog.ColoredFormatter('%(log_color)s%(asctime)s - %(levelname)-8s%(reset)s %(white)s%(message)s',
+        log_colors=log_colors,
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
 
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(console_formatter)
+    file_formatter = logging.Formatter(
+        '%(asctime)s -%(levelname)-8s  %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
 
-        file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
-        file_handler.setFormatter(file_formatter)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(console_formatter)
 
-        logger.addHandler(console_handler)
-        logger.addHandler(file_handler)
+    file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+    file_handler.setFormatter(file_formatter)
 
-        logger.setLevel(log_level)
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
 
-        logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
+    logger.setLevel(log_level)
 
-    _log_initialized = True
+    logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
 
-setup_logging()
-
-_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
+    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: Langfuse = Langfuse if _langfuse_initialized else setup_langfuse()
+    return _langfuse
 
 
 if __name__ == "__main__":
+        from xgae.utils import langfuse
+
         trace_id = langfuse.create_trace_id()
         logging.warning(f"trace_id={trace_id}")

xgae/utils/xml_tool_parser.py

@@ -5,14 +5,11 @@ This module provides a reliable XML tool call parsing system that supports
 the XML format with structured function_calls blocks.
 """
 
-import re
-import xml.etree.ElementTree as ET
-from typing import List, Dict, Any, Optional, Tuple
-from dataclasses import dataclass
 import json
 import logging
-
-logger = logging.getLogger(__name__)
+import re
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
 
 
 @dataclass
@@ -85,7 +82,7 @@ class XMLToolParser:
                     if tool_call:
                         tool_calls.append(tool_call)
                 except Exception as e:
-                    logger.error(f"Error parsing invoke block for {function_name}: {e}")
+                    logging.error(f"Error parsing invoke block for {function_name}: {e}")
         
         return tool_calls
     

{xgae-0.1.5.dist-info → xgae-0.1.7.dist-info}/METADATA

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

xgae-0.1.7.dist-info/RECORD

@@ -0,0 +1,19 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/engine_base.py,sha256=ySERuLy1YWsf-3s0NFKcyTnXQ4g69wR-cQhtnG0OFmU,1747
+xgae/engine/mcp_tool_box.py,sha256=iBfCLWXvbkKWd1JnSgBLA1T1KdSdpEZCrROkC_cXp7g,10132
+xgae/engine/prompt_builder.py,sha256=8_rNRJksn2QLV_K98S0x0qNeHcmxhU0kB_53IZJTGOU,4366
+xgae/engine/task_engine.py,sha256=mjS7oDlJH-1wBohzz1FfFng2nE_K0xL-QaNZDuQss3A,17986
+xgae/engine/responser/non_stream_responser.py,sha256=kOP9kDEhHtrDKMyVnBPWEx0yO-xTvVacfXGJJqFtONU,6395
+xgae/engine/responser/responser_base.py,sha256=rn3-LkS_alZUwdIxPfDGC_zAH_CncSQ2I-euYA6a45w,30524
+xgae/engine/responser/stream_responser.py,sha256=5KzCHApiPplZ-zN_sbbEbSvj2rtvKWBshJKe_-x7RDI,52927
+xgae/tools/without_general_tools_app.py,sha256=QknIF4OW9xvOad8gx-F_sCBwQYXqMalnNFvYvZXkQ_I,3789
+xgae/utils/__init__.py,sha256=jChvD-p_p5gsrCZUVYPUGJs4CS9gIdNFcSOpkRpcM4Y,317
+xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
+xgae/utils/llm_client.py,sha256=RvID4bL9yZon096uvuoFZPlqAPiHhET9-9qYp6sUERc,12605
+xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
+xgae/utils/setup_env.py,sha256=EVk0KG92Sk6ejBxXZbDDr_dc3KM8GFMofMA4HvXqSfM,2409
+xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
+xgae-0.1.7.dist-info/METADATA,sha256=AbGuJUOv4574WF9a2nQNaTxuOKEN2K_U7RaACci2PME,309
+xgae-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.7.dist-info/entry_points.txt,sha256=rhQ9Vksnu8nA78lPTjiJxOCZ5k6sH6s5YNMR68y7C-A,73
+xgae-0.1.7.dist-info/RECORD,,

xgae-0.1.7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xgae-tools = xgae.tools.without_general_tools_app:main

xgae/engine/responser/xga_non_stream_responser.py

@@ -1,216 +0,0 @@
-import uuid
-import logging
-
-from typing import List, Dict, Any, AsyncGenerator, override,Optional
-
-from xgae.engine.responser.xga_responser_base import TaskResponseProcessor, TaskResponseContext, TaskRunContinuousState
-
-from xgae.utils.json_helpers import (
-    safe_json_parse,
-    to_json_string, format_for_yield
-)
-
-class NonStreamTaskResponser(TaskResponseProcessor):
-    def __init__(self, response_context: TaskResponseContext):
-        super().__init__(response_context)
-
-    @override
-    async def process_response(self,
-                               llm_response: Any,
-                               prompt_messages: List[Dict[str, Any]],
-                               continuous_state: Optional[TaskRunContinuousState] = None) -> AsyncGenerator[Dict[str, Any], None]:
-        content = ""
-        all_tool_data = []  # Stores {'tool_call': ..., 'parsing_details': ...}
-        tool_index = 0
-        assistant_message_object = None
-        tool_result_message_objects = {}
-        finish_reason = None
-
-        native_tool_calls_for_message = []
-        llm_model = self.response_context.get("model_name")
-        thread_id = self.response_context.get("task_id")
-        thread_run_id = self.response_context.get("task_run_id")
-        tool_execution_strategy = self.response_context.get("tool_execution_strategy", "parallel")
-        xml_adding_strategy = self.response_context.get("xml_adding_strategy", "user_message")
-        max_xml_tool_calls = self.response_context.get("max_xml_tool_calls", 0)
-        try:
-            # Save and Yield thread_run_start status message
-            start_content = {"status_type": "thread_run_start", "thread_run_id": thread_run_id}
-            start_msg_obj = self.add_message(
-                type="status", content=start_content,
-                is_llm_message=False, metadata={"thread_run_id": thread_run_id}
-            )
-           # if start_msg_obj: yield format_for_yield(start_msg_obj)
-
-            # Extract finish_reason, content, tool calls
-            if hasattr(llm_response, 'choices') and llm_response.choices:
-                if hasattr(llm_response.choices[0], 'finish_reason'):
-                    finish_reason = llm_response.choices[0].finish_reason
-                    logging.info(f"Non-streaming finish_reason: {finish_reason}")
-                    self.trace.event(name="non_streaming_finish_reason", level="DEFAULT",
-                                     status_message=(f"Non-streaming finish_reason: {finish_reason}"))
-                response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0],
-                                                                              'message') else None
-                if response_message:
-                    if hasattr(response_message, 'content') and response_message.content:
-                        content = response_message.content
-                        
-                        parsed_xml_data = self._parse_xml_tool_calls(content)
-                        if max_xml_tool_calls > 0 and len(parsed_xml_data) > max_xml_tool_calls:
-                            # Truncate content and tool data if limit exceeded
-                            # ... (Truncation logic similar to streaming) ...
-                            if parsed_xml_data:
-                                xml_chunks = self._extract_xml_chunks(content)[:max_xml_tool_calls]
-                                if xml_chunks:
-                                    last_chunk = xml_chunks[-1]
-                                    last_chunk_pos = content.find(last_chunk)
-                                    if last_chunk_pos >= 0: content = content[:last_chunk_pos + len(last_chunk)]
-                            parsed_xml_data = parsed_xml_data[:max_xml_tool_calls]
-                            finish_reason = "xml_tool_limit_reached"
-                        all_tool_data.extend(parsed_xml_data)
-
-                    # if config.native_tool_calling and hasattr(response_message,
-                    #                                           'tool_calls') and response_message.tool_calls:
-                    #     for tool_call in response_message.tool_calls:
-                    #         if hasattr(tool_call, 'function'):
-                    #             exec_tool_call = {
-                    #                 "function_name": tool_call.function.name,
-                    #                 "arguments": safe_json_parse(tool_call.function.arguments) if isinstance(
-                    #                     tool_call.function.arguments, str) else tool_call.function.arguments,
-                    #                 "id": tool_call.id if hasattr(tool_call, 'id') else str(uuid.uuid4())
-                    #             }
-                    #             all_tool_data.append({"tool_call": exec_tool_call, "parsing_details": None})
-                    #             native_tool_calls_for_message.append({
-                    #                 "id": exec_tool_call["id"], "type": "function",
-                    #                 "function": {
-                    #                     "name": tool_call.function.name,
-                    #                     "arguments": tool_call.function.arguments if isinstance(
-                    #                         tool_call.function.arguments, str) else to_json_string(
-                    #                         tool_call.function.arguments)
-                    #                 }
-                    #             })
-
-            # --- SAVE and YIELD Final Assistant Message ---
-            message_data = {"role": "assistant", "content": content,
-                            "tool_calls": native_tool_calls_for_message or None}
-            assistant_message_object = self._add_message_with_agent_info(type="assistant", content=message_data,
-                is_llm_message=True, metadata={"thread_run_id": thread_run_id}
-            )
-            if assistant_message_object:
-                yield assistant_message_object
-            else:
-                logging.error(f"Failed to save non-streaming assistant message for thread {thread_id}")
-                self.trace.event(name="failed_to_save_non_streaming_assistant_message_for_thread", level="ERROR",
-                                 status_message=(
-                                     f"Failed to save non-streaming assistant message for thread {thread_id}"))
-                err_content = {"role": "system", "status_type": "error", "message": "Failed to save assistant message"}
-                err_msg_obj = self.add_message(
-                    type="status", content=err_content,
-                    is_llm_message=False, metadata={"thread_run_id": thread_run_id}
-                )
-                if err_msg_obj: yield format_for_yield(err_msg_obj)
-
-            # --- Execute Tools and Yield Results ---
-            tool_calls_to_execute = [item['tool_call'] for item in all_tool_data]
-            if  tool_calls_to_execute:
-                logging.info(
-                    f"Executing {len(tool_calls_to_execute)} tools with strategy: {tool_execution_strategy}")
-                self.trace.event(name="executing_tools_with_strategy", level="DEFAULT", status_message=(
-                    f"Executing {len(tool_calls_to_execute)} tools with strategy: {tool_execution_strategy}"))
-                tool_results = await self._execute_tools(tool_calls_to_execute, tool_execution_strategy)
-
-                for i, (returned_tool_call, result) in enumerate(tool_results):
-                    original_data = all_tool_data[i]
-                    tool_call_from_data = original_data['tool_call']
-                    parsing_details = original_data['parsing_details']
-                    current_assistant_id = assistant_message_object['message_id'] if assistant_message_object else None
-
-                    context = self._create_tool_context(
-                        tool_call_from_data, tool_index, current_assistant_id, parsing_details
-                    )
-                    context.result = result
-
-                    # Save and Yield start status
-                    started_msg_obj = self._yield_and_save_tool_started(context, thread_id, thread_run_id)
-                    if started_msg_obj: yield format_for_yield(started_msg_obj)
-
-                    # Save tool result
-                    saved_tool_result_object = self._add_tool_result(
-                        thread_id, tool_call_from_data, result, xml_adding_strategy,
-                        current_assistant_id, parsing_details
-                    )
-
-                    # Save and Yield completed/failed status
-                    completed_msg_obj = self._yield_and_save_tool_completed(
-                        context,
-                        saved_tool_result_object['message_id'] if saved_tool_result_object else None,
-                        thread_id, thread_run_id
-                    )
-                    if completed_msg_obj: yield format_for_yield(completed_msg_obj)
-
-                    # Yield the saved tool result object
-                    if saved_tool_result_object:
-                        tool_result_message_objects[tool_index] = saved_tool_result_object
-                        yield format_for_yield(saved_tool_result_object)
-                    else:
-                        logging.error(f"Failed to save tool result for index {tool_index}")
-                        self.trace.event(name="failed_to_save_tool_result_for_index", level="ERROR",
-                                         status_message=(f"Failed to save tool result for index {tool_index}"))
-
-                    if completed_msg_obj["metadata"].get("agent_should_terminate") == "true":
-                        finish_reason = "completed"
-                        break
-                    tool_index += 1
-
-            # --- Save and Yield Final Status ---
-            if finish_reason:
-                finish_content = {"status_type": "finish", "finish_reason": finish_reason}
-                finish_msg_obj = self.add_message(
-                    type="status", content=finish_content,
-                    is_llm_message=False, metadata={"thread_run_id": thread_run_id}
-                )
-                if finish_msg_obj: yield format_for_yield(finish_msg_obj)
-
-            # --- Save and Yield assistant_response_end ---
-            if assistant_message_object:  # Only save if assistant message was saved
-                try:
-                    # Save the full LiteLLM response object directly in content
-                    self.add_message(
-                        type="assistant_response_end",
-                        content=llm_response,
-                        is_llm_message=False,
-                        metadata={"thread_run_id": thread_run_id}
-                    )
-                    logging.info("Assistant response end saved for non-stream")
-                except Exception as e:
-                    logging.error(f"Error saving assistant response end for non-stream: {str(e)}")
-                    self.trace.event(name="error_saving_assistant_response_end_for_non_stream", level="ERROR",
-                                     status_message=(f"Error saving assistant response end for non-stream: {str(e)}"))
-
-        except Exception as e:
-            logging.error(f"Error processing non-streaming response: {str(e)}", exc_info=True)
-            self.trace.event(name="error_processing_non_streaming_response", level="ERROR",
-                             status_message=(f"Error processing non-streaming response: {str(e)}"))
-            # Save and yield error status
-            err_content = {"role": "system", "status_type": "error", "message": str(e)}
-            err_msg_obj = self.add_message(
-                type="status", content=err_content,
-                is_llm_message=False, metadata={"thread_run_id": thread_run_id if 'thread_run_id' in locals() else None}
-            )
-            if err_msg_obj: yield format_for_yield(err_msg_obj)
-
-            # Re-raise the same exception (not a new one) to ensure proper error propagation
-            logging.critical(f"Re-raising error to stop further processing: {str(e)}")
-            self.trace.event(name="re_raising_error_to_stop_further_processing", level="CRITICAL",
-                             status_message=(f"Re-raising error to stop further processing: {str(e)}"))
-            raise  # Use bare 'raise' to preserve the original exception with its traceback
-
-        finally:
-            # Save and Yield the final thread_run_end status
-            end_content = {"status_type": "thread_run_end"}
-            end_msg_obj = self.add_message(
-                type="status", content=end_content,
-                is_llm_message=False, metadata={"thread_run_id": thread_run_id if 'thread_run_id' in locals() else None}
-            )
-            #if end_msg_obj: yield format_for_yield(end_msg_obj)
-

xgae-0.1.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/xga_base.py,sha256=Es6OICHQ5h9gq5MGm0Mx-7ScyfP94_kVSuRCSFHTsxo,1642
-xgae/engine/xga_engine.py,sha256=CVi9vhwI9kjlyqk_KF3AbpLpYcjCuWulZ8C2UD7242w,17501
-xgae/engine/xga_mcp_tool_box.py,sha256=o0HpP22DA3VPn1CzuQR-r1ue9GIkWGxjLLphJqc7iHw,9883
-xgae/engine/xga_prompt_builder.py,sha256=RuTvQCNufqxDwVvSOPXR0qxAc42cG7NuIaUy9amu66A,4351
-xgae/engine/responser/xga_non_stream_responser.py,sha256=qAWQb8VUIiYjcnww4Eap5tLbigGeTc_DO4gskilbiV0,12882
-xgae/engine/responser/xga_responser_base.py,sha256=RYaO4hn2EXiO--KgIgNmT-cBWPgTpHMAJT47bpMqdhE,34960
-xgae/engine/responser/xga_stream_responser.py,sha256=1x-z1JDghs9SLfSPc1RTS-RMLvs8N3KebaB_l62YIgg,52285
-xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
-xgae/utils/llm_client.py,sha256=mgzn8heUyRm92HTLEYGdfsGEpFtD-xLFr39P98_JP0s,12402
-xgae/utils/setup_env.py,sha256=-Ehv7_E9udHc8AjP66Y78E4X7_G6gpuNJkioCh5fn4A,2902
-xgae/utils/utils.py,sha256=cCYmWjKFksZ8BRD1YYnaM_jTLVHAg1ibEdjsczEUO6k,1134
-xgae/utils/xml_tool_parser.py,sha256=7Ei7X8zSgVct0fFCSmxDtknCLtdrUIwL9hy_0qSNlvs,7546
-xgae-0.1.5.dist-info/METADATA,sha256=JdXLTZ7vw3S4EAA7heCS5j0Vg1-1mHDPCfskAPSsZjc,309
-xgae-0.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.5.dist-info/RECORD,,