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

xgae/engine/engine_base.py

@@ -55,4 +55,4 @@ class XGAToolBox(ABC):
 
     @abstractmethod
     async def call_tool(self, task_id: str, tool_name: str, args: Optional[Dict[str, Any]] = None) -> XGAToolResult:
-        pass
+        pass

xgae/engine/mcp_tool_box.py

@@ -8,7 +8,6 @@ from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_mcp_adapters.tools import load_mcp_tools
 
 from xgae.engine.engine_base import XGAError, XGAToolSchema, XGAToolBox, XGAToolResult
-from xgae.utils import langfuse
 
 class XGAMcpToolBox(XGAToolBox):
     GENERAL_MCP_SERVER_NAME = "xga_general"
@@ -194,8 +193,8 @@ if __name__ == "__main__":
 
     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")
@@ -210,9 +209,6 @@ if __name__ == "__main__":
             print(asdict(tool_schema))
         print()
 
-        result = await mcp_tool_box.call_tool(task_id=task_id, tool_name="web_search", args={"task_id": task_id, "query": "查询天津天气"})
-        print(f"call web_search result: {result}")
-
         result = await mcp_tool_box.call_tool(task_id=task_id, tool_name="complete", args={"task_id": task_id})
         print(f"call complete result: {result}")
 

xgae/engine/responser/non_stream_responser.py

@@ -3,7 +3,6 @@ import logging
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
-from xgae.utils import langfuse
 from xgae.utils.json_helpers import format_for_yield
 
 class NonStreamTaskResponser(TaskResponseProcessor):
@@ -16,6 +15,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
         llm_content = ""
         parsed_xml_data = []
         finish_reason = None
+        llm_count = continuous_state.get("auto_continue_count")
 
         try:
             # Extract finish_reason, content, tool calls
@@ -24,7 +24,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     finish_reason = llm_response.choices[0].finish_reason
                     logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
 
-                    langfuse.create_event(trace_context=self.trace_context, name="non_stream_processor_start", level="DEFAULT",
+                    self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
                                      status_message=(f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}"))
 
                 response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0], 'message') else None
@@ -90,7 +90,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
 
         except Exception as e:
             logging.error(f"NonStreamTask: Error processing non-streaming response: {llm_content}")
-            langfuse.create_event(trace_context=self.trace_context, name="error_processing_non_streaming_response", level="ERROR",
+            self.root_span.event(name="error_processing_non_streaming_response", level="ERROR",
                              status_message=(f"Error processing non-streaming response: {str(e)}"))
 
             content = {"role": "system", "status_type": "error", "message": str(e)}
@@ -100,7 +100,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
 
             # Re-raise the same exception (not a new one) to ensure proper error propagation
             logging.critical(f"NonStreamTask: Re-raising error to stop further processing: {str(e)}")
-            langfuse.create_event(trace_context=self.trace_context, name="re_raising_error_to_stop_further_processing", level="CRITICAL",
+            self.root_span.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
 

xgae/engine/responser/responser_base.py

@@ -7,8 +7,9 @@ from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple, Union, Literal, Callable, TypedDict, AsyncGenerator
 
 from xgae.engine.engine_base import XGAToolResult, XGAToolBox
-from xgae.utils import langfuse
-from xgae.utils.json_helpers import safe_json_parse,format_for_yield
+from xgae.utils.setup_env import langfuse
+
+from xgae.utils.json_helpers import safe_json_parse, format_for_yield
 from xgae.utils.xml_tool_parser import XMLToolParser
 
 # Type alias for XML result adding strategy
@@ -21,6 +22,7 @@ class TaskResponserContext(TypedDict, total=False):
     is_stream: bool
     task_id: str
     task_run_id: str
+    task_no: int
     trace_id: str
     root_span_id: str
     model_name: str
@@ -56,15 +58,12 @@ class TaskResponseProcessor(ABC):
 
         self.task_id = response_context.get("task_id")
         self.task_run_id = response_context.get("task_run_id")
+        self.task_no = response_context.get("task_no")
         self.tool_execution_strategy = self.response_context.get("tool_execution_strategy", "parallel")
         self.xml_adding_strategy = self.response_context.get("xml_adding_strategy", "user_message")
         self.max_xml_tool_calls = self.response_context.get("max_xml_tool_calls", 0)
 
-        self.trace_context = {
-            "trace_id": self.response_context.get("trace_id"),
-            "parent_span_id": self.response_context.get("root_span_id"),
-        }
-
+        self.root_span = langfuse.span(trace_id=response_context.get("trace_id"), id=response_context.get("root_span_id"))
         self.add_response_message = response_context.get("add_response_msg_func")
 
         self.tool_box = response_context.get("tool_box")
@@ -174,7 +173,7 @@ class TaskResponseProcessor(ABC):
         except Exception as e:
             logging.error(f"Error extracting XML chunks: {e}")
             logging.error(f"Content was: {content}")
-            langfuse.create_event(trace_context=self.trace_context, name="error_extracting_xml_chunks", level="ERROR",
+            self.root_span.event(name="error_extracting_xml_chunks", level="ERROR",
                               status_message=(f"Error extracting XML chunks: {e}"), metadata={"content": content})
 
         return chunks
@@ -224,7 +223,7 @@ class TaskResponseProcessor(ABC):
         except Exception as e:
             logging.error(f"Error parsing XML chunk: {e}")
             logging.error(f"XML chunk was: {xml_chunk}")
-            langfuse.create_event(trace_context=self.trace_context, name="error_parsing_xml_chunk", level="ERROR",
+            self.root_span.event(name="error_parsing_xml_chunk", level="ERROR",
                               status_message=(f"Error parsing XML chunk: {e}"), metadata={"xml_chunk": xml_chunk})
             return None
 
@@ -250,7 +249,7 @@ class TaskResponseProcessor(ABC):
 
         except Exception as e:
             logging.error(f"Error parsing XML tool calls: {e}", exc_info=True)
-            langfuse.create_event(trace_context=self.trace_context, name="error_parsing_xml_tool_calls", level="ERROR",
+            self.root_span.event(name="error_parsing_xml_tool_calls", level="ERROR",
                              status_message=(f"Error parsing XML tool calls: {e}"), metadata={"content": content})
 
         return parsed_data
@@ -258,36 +257,35 @@ class TaskResponseProcessor(ABC):
 
     async def _execute_tool(self, tool_call: Dict[str, Any]) -> XGAToolResult:
         """Execute a single tool call and return the result."""
-        with langfuse.start_as_current_span(trace_context=self.trace_context, name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"]
-                                            ) as exec_tool_span:
-            try:
-                function_name = tool_call["function_name"]
-                arguments = tool_call["arguments"]
-
-                logging.info(f"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
-
-                result = None
-                available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
-                if function_name in available_tool_names:
-                    result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
-                else:
-                    logging.error(f"Tool function '{function_name}' not found in registry")
-                    result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
-                logging.info(f"Tool execution complete: {function_name} -> {result}")
-                exec_tool_span.update(status_message="tool_executed", output=result)
-
-                return result
-            except Exception as e:
-                logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
+        exec_tool_span = self.root_span.span(name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"])
+        try:
+            function_name = tool_call["function_name"]
+            arguments = tool_call["arguments"]
+
+            logging.info(f"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
+
+            result = None
+            available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
+            if function_name in available_tool_names:
+                result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
+            else:
+                logging.error(f"Tool function '{function_name}' not found in registry")
+                result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
+            logging.info(f"Tool execution complete: {function_name} -> {result}")
+            exec_tool_span.update(status_message="tool_executed", output=result)
+
+            return result
+        except Exception as e:
+            logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
 
-                exec_tool_span.update(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
-                return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
+            exec_tool_span.update(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
+            return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
 
     async def _execute_tools(
             self,
@@ -321,7 +319,7 @@ class TaskResponseProcessor(ABC):
             return []
         tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
         logging.info(f"Executing {len(tool_calls)} tools sequentially: {tool_names}")
-        langfuse.create_event(trace_context=self.trace_context, name="executing_tools_sequentially", level="DEFAULT",
+        self.root_span.event(name="executing_tools_sequentially", level="DEFAULT",
                               status_message=(f"Executing {len(tool_calls)} tools sequentially: {tool_names}"))
 
         results = []
@@ -337,19 +335,19 @@ class TaskResponseProcessor(ABC):
                 # Check if this is a terminating tool (ask or complete)
                 if tool_name in ['ask', 'complete']:
                     logging.info(f"Terminating tool '{tool_name}' executed. Stopping further tool execution.")
-                    # langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_executed",
+                    # self.root_span.event(name="terminating_tool_executed",
                     #                       level="DEFAULT", status_message=(f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
                     break  # Stop executing remaining tools
 
             except Exception as e:
                 logging.error(f"Error executing tool {tool_name}: {str(e)}")
-                langfuse.create_event(trace_context=self.trace_context, name="error_executing_tool", level="ERROR",
+                self.root_span.event(name="error_executing_tool", level="ERROR",
                                       status_message=(f"Error executing tool {tool_name}: {str(e)}"))
                 error_result = XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
                 results.append((tool_call, error_result))
 
         logging.info(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)")
-        # langfuse.create_event(trace_context=self.trace_context, name="sequential_execution_completed", level="DEFAULT",
+        # self.root_span.event(name="sequential_execution_completed", level="DEFAULT",
         #                       status_message=(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
         return results
 
@@ -361,7 +359,7 @@ class TaskResponseProcessor(ABC):
         try:
             tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
             logging.info(f"Executing {len(tool_calls)} tools in parallel: {tool_names}")
-            # langfuse.create_event(trace_context=self.trace_context, name="executing_tools_in_parallel", level="DEFAULT",
+            # self.root_span.event(name="executing_tools_in_parallel", level="DEFAULT",
             #                  status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
 
             # Create tasks for all tool calls
@@ -375,7 +373,7 @@ class TaskResponseProcessor(ABC):
             for i, (tool_call, result) in enumerate(zip(tool_calls, results)):
                 if isinstance(result, Exception):
                     logging.error(f"Error executing tool {tool_call.get('function_name', 'unknown')}: {str(result)}")
-                    langfuse.create_event(trace_context=self.trace_context, name="error_executing_tool", level="ERROR", status_message=(
+                    self.root_span.event(name="error_executing_tool", level="ERROR", status_message=(
                         f"Error executing tool {tool_call.get('function_name', 'unknown')}: {str(result)}"))
                     # Create error result
                     error_result = XGAToolResult(success=False, output=f"Error executing tool: {str(result)}")
@@ -384,13 +382,13 @@ class TaskResponseProcessor(ABC):
                     processed_results.append((tool_call, result))
 
             logging.info(f"Parallel execution completed for {len(tool_calls)} tools")
-            # langfuse.create_event(trace_context=self.trace_context, name="parallel_execution_completed", level="DEFAULT",
+            # self.root_span.event(name="parallel_execution_completed", level="DEFAULT",
             #                  status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
             return processed_results
 
         except Exception as e:
             logging.error(f"Error in parallel tool execution: {str(e)}", exc_info=True)
-            langfuse.create_event(trace_context=self.trace_context, name="error_in_parallel_tool_execution", level="ERROR",
+            self.root_span.event(name="error_in_parallel_tool_execution", level="ERROR",
                              status_message=(f"Error in parallel tool execution: {str(e)}"))
             # Return error results for all tools if the gather itself fails
             return [(tool_call, XGAToolResult(success=False, output=f"Execution error: {str(e)}"))
@@ -461,7 +459,7 @@ class TaskResponseProcessor(ABC):
             return message_obj  # Return the modified message object
         except Exception as e:
             logging.error(f"Error adding tool result: {str(e)}", exc_info=True)
-            langfuse.create_event(trace_context=self.trace_context, name="error_adding_tool_result", level="ERROR",
+            self.root_span.event(name="error_adding_tool_result", level="ERROR",
                              status_message=(f"Error adding tool result: {str(e)}"),
                              metadata={"tool_call": tool_call, "result": result, "strategy": strategy,
                                        "assistant_message_id": assistant_message_id,
@@ -481,7 +479,7 @@ class TaskResponseProcessor(ABC):
                 return message_obj  # Return the full message object
             except Exception as e2:
                 logging.error(f"Failed even with fallback message: {str(e2)}", exc_info=True)
-                langfuse.create_event(trace_context=self.trace_context, name="failed_even_with_fallback_message", level="ERROR",
+                self.root_span.event(name="failed_even_with_fallback_message", level="ERROR",
                                  status_message=(f"Failed even with fallback message: {str(e2)}"),
                                  metadata={"tool_call": tool_call, "result": result, "strategy": strategy,
                                            "assistant_message_id": assistant_message_id,
@@ -589,7 +587,7 @@ class TaskResponseProcessor(ABC):
         if context.function_name in ['ask', 'complete']:
             metadata["agent_should_terminate"] = "true"
             logging.info(f"Marking tool status for '{context.function_name}' with termination signal.")
-            # langfuse.create_event(trace_context=self.trace_context, name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
+            # self.root_span.event(name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
             #     f"Marking tool status for '{context.function_name}' with termination signal."))
         # <<< END ADDED >>>
 

xgae/engine/responser/stream_responser.py

@@ -7,7 +7,6 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import List, Dict, Any, Optional, AsyncGenerator, override, Literal
 
-from xgae.utils import langfuse
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext,TaskRunContinuousState,XmlAddingStrategy,ToolExecutionStrategy
 from xgae.utils.json_helpers import (
     ensure_dict, safe_json_parse,
@@ -205,7 +204,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                             __sequence += 1
                         else:
                             logging.info("XML tool call limit reached - not yielding more content chunks")
-                            langfuse.create_event(trace_context=self.trace_context, name="xml_tool_call_limit_reached", level="DEFAULT", status_message=(
+                            self.root_span.event(name="xml_tool_call_limit_reached", level="DEFAULT", status_message=(
                                 f"XML tool call limit reached - not yielding more content chunks"))
 
                         # --- Process XML Tool Calls (if enabled and limit not reached) ---
@@ -317,7 +316,7 @@ class StreamTaskResponser(TaskResponseProcessor):
 
                 if finish_reason == "xml_tool_limit_reached":
                     logging.info("Stopping stream processing after loop due to XML tool call limit")
-                    langfuse.create_event(trace_context=self.trace_context, name="stopping_stream_processing_after_loop_due_to_xml_tool_call_limit",
+                    self.root_span.event(name="stopping_stream_processing_after_loop_due_to_xml_tool_call_limit",
                                      level="DEFAULT", status_message=(
                             f"Stopping stream processing after loop due to XML tool call limit"))
                     break
@@ -352,18 +351,18 @@ class StreamTaskResponser(TaskResponseProcessor):
                     #     f"🔥 Estimated tokens – prompt: {prompt_tokens}, "
                     #     f"completion: {completion_tokens}, total: {prompt_tokens + completion_tokens}"
                     # )
-                    langfuse.create_event(trace_context=self.trace_context, name="usage_calculated_with_litellm_token_counter", level="DEFAULT",
+                    self.root_span.event(name="usage_calculated_with_litellm_token_counter", level="DEFAULT",
                                      status_message=(f"Usage calculated with litellm.token_counter"))
                 except Exception as e:
                     logging.warning(f"Failed to calculate usage: {str(e)}")
-                    langfuse.create_event(trace_context=self.trace_context, name="failed_to_calculate_usage", level="WARNING",
+                    self.root_span.event(name="failed_to_calculate_usage", level="WARNING",
                                      status_message=(f"Failed to calculate usage: {str(e)}"))
 
             # Wait for pending tool executions from streaming phase
             tool_results_buffer = []  # Stores (tool_call, result, tool_index, context)
             if pending_tool_executions:
                 logging.info(f"Waiting for {len(pending_tool_executions)} pending streamed tool executions")
-                langfuse.create_event(trace_context=self.trace_context, name="waiting_for_pending_streamed_tool_executions", level="DEFAULT", status_message=(
+                self.root_span.event(name="waiting_for_pending_streamed_tool_executions", level="DEFAULT", status_message=(
                     f"Waiting for {len(pending_tool_executions)} pending streamed tool executions"))
                 # ... (asyncio.wait logic) ...
                 pending_tasks = [execution["task"] for execution in pending_tool_executions]
@@ -387,19 +386,19 @@ class StreamTaskResponser(TaskResponseProcessor):
                                 if tool_name in ['ask', 'complete']:
                                     logging.info(
                                         f"Terminating tool '{tool_name}' completed during streaming. Setting termination flag.")
-                                    langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_completed_during_streaming",
+                                    self.root_span.event(name="terminating_tool_completed_during_streaming",
                                                      level="DEFAULT", status_message=(
                                             f"Terminating tool '{tool_name}' completed during streaming. Setting termination flag."))
                                     agent_should_terminate = True
 
                             else:  # Should not happen with asyncio.wait
                                 logging.warning(f"Task for tool index {tool_idx} not done after wait.")
-                                langfuse.create_event(trace_context=self.trace_context, name="task_for_tool_index_not_done_after_wait", level="WARNING",
+                                self.root_span.event(name="task_for_tool_index_not_done_after_wait", level="WARNING",
                                                  status_message=(
                                                      f"Task for tool index {tool_idx} not done after wait."))
                         except Exception as e:
                             logging.error(f"Error getting result for pending tool execution {tool_idx}: {str(e)}")
-                            langfuse.create_event(trace_context=self.trace_context, name="error_getting_result_for_pending_tool_execution", level="ERROR",
+                            self.root_span.event(name="error_getting_result_for_pending_tool_execution", level="ERROR",
                                              status_message=(
                                                  f"Error getting result for pending tool execution {tool_idx}: {str(e)}"))
                             context.error = e
@@ -419,7 +418,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                             if tool_name in ['ask', 'complete']:
                                 logging.info(
                                     f"Terminating tool '{tool_name}' completed during streaming. Setting termination flag.")
-                                langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_completed_during_streaming", level="DEFAULT",
+                                self.root_span.event(name="terminating_tool_completed_during_streaming", level="DEFAULT",
                                                  status_message=(
                                                      f"Terminating tool '{tool_name}' completed during streaming. Setting termination flag."))
                                 agent_should_terminate = True
@@ -432,7 +431,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                     except Exception as e:
                         logging.error(
                             f"Error getting result/yielding status for pending tool execution {tool_idx}: {str(e)}")
-                        langfuse.create_event(trace_context=self.trace_context, name="error_getting_result_yielding_status_for_pending_tool_execution",
+                        self.root_span.event(name="error_getting_result_yielding_status_for_pending_tool_execution",
                                          level="ERROR", status_message=(
                                 f"Error getting result/yielding status for pending tool execution {tool_idx}: {str(e)}"))
                         context.error = e
@@ -451,7 +450,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                 if finish_msg_obj: yield format_for_yield(finish_msg_obj)
                 logging.info(
                     f"Stream finished with reason: xml_tool_limit_reached after {xml_tool_call_count} XML tool calls")
-                langfuse.create_event(trace_context=self.trace_context, name="stream_finished_with_reason_xml_tool_limit_reached_after_xml_tool_calls",
+                self.root_span.event(name="stream_finished_with_reason_xml_tool_limit_reached_after_xml_tool_calls",
                                  level="DEFAULT", status_message=(
                         f"Stream finished with reason: xml_tool_limit_reached after {xml_tool_call_count} XML tool calls"))
 
@@ -501,7 +500,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                     yield format_for_yield(yield_message)
                 else:
                     logging.error(f"Failed to save final assistant message for thread {thread_id}")
-                    langfuse.create_event(trace_context=self.trace_context, name="failed_to_save_final_assistant_message_for_thread", level="ERROR",
+                    self.root_span.event(name="failed_to_save_final_assistant_message_for_thread", level="ERROR",
                                      status_message=(f"Failed to save final assistant message for thread {thread_id}"))
                     # Save and yield an error status
                     err_content = {"role": "system", "status_type": "error",
@@ -569,7 +568,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                 # Populate from buffer if executed on stream
                 if config.execute_on_stream and tool_results_buffer:
                     logging.info(f"Processing {len(tool_results_buffer)} buffered tool results")
-                    langfuse.create_event(trace_context=self.trace_context, name="processing_buffered_tool_results", level="DEFAULT",
+                    self.root_span.event(name="processing_buffered_tool_results", level="DEFAULT",
                                      status_message=(f"Processing {len(tool_results_buffer)} buffered tool results"))
                     for tool_call, result, tool_idx, context in tool_results_buffer:
                         if last_assistant_message_object: context.assistant_message_id = last_assistant_message_object[
@@ -580,7 +579,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                 elif final_tool_calls_to_process and not config.execute_on_stream:
                     logging.info(
                         f"Executing {len(final_tool_calls_to_process)} tools ({config.tool_execution_strategy}) after stream")
-                    langfuse.create_event(trace_context=self.trace_context, name="executing_tools_after_stream", level="DEFAULT", status_message=(
+                    self.root_span.event(name="executing_tools_after_stream", level="DEFAULT", status_message=(
                         f"Executing {len(final_tool_calls_to_process)} tools ({config.tool_execution_strategy}) after stream"))
                     results_list = await self._execute_tools(final_tool_calls_to_process,
                                                              config.tool_execution_strategy)
@@ -598,14 +597,14 @@ class StreamTaskResponser(TaskResponseProcessor):
                             tool_results_map[current_tool_idx] = (tc, res, context)
                         else:
                             logging.warning(f"Could not map result for tool index {current_tool_idx}")
-                            langfuse.create_event(trace_context=self.trace_context, name="could_not_map_result_for_tool_index", level="WARNING",
+                            self.root_span.event(name="could_not_map_result_for_tool_index", level="WARNING",
                                              status_message=(f"Could not map result for tool index {current_tool_idx}"))
                         current_tool_idx += 1
 
                 # Save and Yield each result message
                 if tool_results_map:
                     logging.info(f"Saving and yielding {len(tool_results_map)} final tool result messages")
-                    langfuse.create_event(trace_context=self.trace_context, name="saving_and_yielding_final_tool_result_messages", level="DEFAULT",
+                    self.root_span.event(name="saving_and_yielding_final_tool_result_messages", level="DEFAULT",
                                      status_message=(
                                          f"Saving and yielding {len(tool_results_map)} final tool result messages"))
                     for tool_idx in sorted(tool_results_map.keys()):
@@ -640,7 +639,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                         else:
                             logging.error(
                                 f"Failed to save tool result for index {tool_idx}, not yielding result message.")
-                            langfuse.create_event(trace_context=self.trace_context, name="failed_to_save_tool_result_for_index", level="ERROR",
+                            self.root_span.event(name="failed_to_save_tool_result_for_index", level="ERROR",
                                              status_message=(
                                                  f"Failed to save tool result for index {tool_idx}, not yielding result message."))
                             # Optionally yield error status for saving failure?
@@ -658,7 +657,7 @@ class StreamTaskResponser(TaskResponseProcessor):
             if agent_should_terminate:
                 logging.info(
                     "Agent termination requested after executing ask/complete tool. Stopping further processing.")
-                langfuse.create_event(trace_context=self.trace_context, name="agent_termination_requested", level="DEFAULT",
+                self.root_span.event(name="agent_termination_requested", level="DEFAULT",
                                  status_message="Agent termination requested after executing ask/complete tool. Stopping further processing.")
 
                 # Set finish reason to indicate termination
@@ -719,7 +718,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                         logging.info("Assistant response end saved for stream (before termination)")
                     except Exception as e:
                         logging.error(f"Error saving assistant response end for stream (before termination): {str(e)}")
-                        langfuse.create_event(trace_context=self.trace_context, name="error_saving_assistant_response_end_for_stream_before_termination",
+                        self.root_span.event(name="error_saving_assistant_response_end_for_stream_before_termination",
                                          level="ERROR", status_message=(
                                 f"Error saving assistant response end for stream (before termination): {str(e)}"))
 
@@ -775,12 +774,12 @@ class StreamTaskResponser(TaskResponseProcessor):
                         logging.info("Assistant response end saved for stream")
                     except Exception as e:
                         logging.error(f"Error saving assistant response end for stream: {str(e)}")
-                        langfuse.create_event(trace_context=self.trace_context, name="error_saving_assistant_response_end_for_stream", level="ERROR",
+                        self.root_span.event(name="error_saving_assistant_response_end_for_stream", level="ERROR",
                                          status_message=(f"Error saving assistant response end for stream: {str(e)}"))
 
         except Exception as e:
             logging.error(f"Error processing stream: {str(e)}", exc_info=True)
-            langfuse.create_event(trace_context=self.trace_context, name="error_processing_stream", level="ERROR",
+            self.root_span.event(name="error_processing_stream", level="ERROR",
                              status_message=(f"Error processing stream: {str(e)}"))
             # Save and yield error status message
 
@@ -794,12 +793,12 @@ class StreamTaskResponser(TaskResponseProcessor):
                 if err_msg_obj: yield format_for_yield(err_msg_obj)  # Yield the saved error message
                 # 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)}")
-                langfuse.create_event(trace_context=self.trace_context, name="re_raising_error_to_stop_further_processing", level="ERROR",
+                self.root_span.event(name="re_raising_error_to_stop_further_processing", level="ERROR",
                                  status_message=(f"Re-raising error to stop further processing: {str(e)}"))
             else:
                 logging.error(f"AnthropicException - Overloaded detected - Falling back to OpenRouter: {str(e)}",
                              exc_info=True)
-                langfuse.create_event(trace_context=self.trace_context, name="anthropic_exception_overloaded_detected", level="ERROR", status_message=(
+                self.root_span.event(name="anthropic_exception_overloaded_detected", level="ERROR", status_message=(
                     f"AnthropicException - Overloaded detected - Falling back to OpenRouter: {str(e)}"))
             raise  # Use bare 'raise' to preserve the original exception with its traceback
 
@@ -822,5 +821,5 @@ class StreamTaskResponser(TaskResponseProcessor):
                     if end_msg_obj: yield format_for_yield(end_msg_obj)
                 except Exception as final_e:
                     logging.error(f"Error in finally block: {str(final_e)}", exc_info=True)
-                    langfuse.create_event(trace_context=self.trace_context, name="error_in_finally_block", level="ERROR",
+                    self.root_span.event(name="error_in_finally_block", level="ERROR",
                                      status_message=(f"Error in finally block: {str(final_e)}"))

xgae/engine/task_engine.py

@@ -9,13 +9,16 @@ from uuid import uuid4
 from xgae.engine.responser.responser_base import TaskResponserContext, TaskResponseProcessor, TaskRunContinuousState
 from xgae.engine.engine_base import XGAResponseMsgType, XGAResponseMessage, XGAToolBox, XGATaskResult
 
-from xgae.utils import langfuse, handle_error
-from xgae.utils.llm_client import LLMClient, LLMConfig
+from xgae.utils import handle_error
+from xgae.utils.setup_env import langfuse
+
+from xgae.utils.llm_client import LLMClient, LLMConfig, LangfuseMetadata
 
 from xgae.utils.json_helpers import format_for_yield
 from xgae.engine.prompt_builder import XGAPromptBuilder
 from xgae.engine.mcp_tool_box import XGAMcpToolBox
 
+
 class XGATaskEngine:
     def __init__(self,
                  session_id: Optional[str] = None,
@@ -54,18 +57,14 @@ class XGATaskEngine:
         self.task_prompt :str = None
         self.trace_id :str = None
         self.root_span_id :str = None
+        self.root_span_name :str = None
 
     async def run_task_with_final_answer(self,
                                          task_message: Dict[str, Any],
                                          trace_id: Optional[str] = None) -> XGATaskResult:
-        self.trace_id = trace_id or langfuse.create_trace_id()
-        with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
-                                            name="run_task_with_final_answer",
-                                            input=task_message,
-                                            metadata={"task_id": self.task_id},
-                                            ) as root_span:
-            self.root_span_id = root_span.id
-
+        final_result:XGATaskResult = None
+        try:
+            self._init_langfuse("run_task_with_final_answer", task_message, trace_id)
             chunks = []
             async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
                 chunks.append(chunk)
@@ -75,8 +74,9 @@ class XGATaskEngine:
             else:
                 final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
 
-            root_span.update(output=final_result)
             return final_result
+        finally:
+            self._end_langfuse("run_task_with_final_answer", final_result)
 
 
     async def run_task(self,
@@ -84,27 +84,15 @@ class XGATaskEngine:
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
             await self._init_task()
-            if self.root_span_id is None:
-                self.trace_id = trace_id or langfuse.create_trace_id()
-                with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
-                                                    name="run_task",
-                                                    input=task_message
-                                                    ) as root_span:
-                    self.root_span_id = root_span.id
-
+            self._init_langfuse("run_task", task_message, trace_id)
 
             self.add_response_message(type="user", content=task_message, is_llm_message=True)
 
-            continuous_state: TaskRunContinuousState = {
-                "accumulated_content": "",
-                "auto_continue_count": 0,
-                "auto_continue": False if self.max_auto_run <= 1 else True
-            }
-            async for chunk in self._run_task_auto(continuous_state):
+            async for chunk in self._run_task_auto():
                 yield chunk
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
-            self.root_span_id = None
+            self._end_langfuse("run_task")
 
 
     async def _init_task(self) -> None:
@@ -133,11 +121,17 @@ class XGATaskEngine:
         logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
 
 
-    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
+    async def _run_task_auto(self) -> AsyncGenerator[Dict[str, Any], None]:
         def update_continuous_state(_auto_continue_count,  _auto_continue):
             continuous_state["auto_continue_count"] = _auto_continue_count
             continuous_state["auto_continue"] = _auto_continue
 
+        continuous_state: TaskRunContinuousState = {
+            "accumulated_content": "",
+            "auto_continue_count": 0,
+            "auto_continue": False if self.max_auto_run <= 1 else True
+        }
+
         auto_continue_count = 0
         auto_continue = True
         while auto_continue and auto_continue_count < self.max_auto_run:
@@ -196,14 +190,15 @@ class XGATaskEngine:
             }
             llm_messages.append(temp_assistant_message)
 
-        llm_response = await self.llm_client.create_completion(llm_messages, self.trace_id)
+        llm_count = continuous_state.get("auto_continue_count")
+        langfuse_metadata = self._create_llm_langfuse_meta(llm_count)
+        llm_response = await self.llm_client.create_completion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
             self._logging_reponse_chunk(chunk)
             yield chunk
 
-
     def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
         final_result: XGATaskResult = None
         try:
@@ -301,6 +296,40 @@ class XGATaskEngine:
         return response_llm_contents
 
 
+    def _create_llm_langfuse_meta(self, llm_count:int)-> LangfuseMetadata:
+        generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
+        generation_id = f"{self.task_run_id}({llm_count})"
+        return LangfuseMetadata(
+            generation_name=generation_name,
+            generation_id=generation_id,
+            existing_trace_id=self.trace_id,
+            session_id=self.session_id,
+        )
+
+    def _init_langfuse(self,
+                       root_span_name: str,
+                       task_message: Dict[str, Any],
+                       trace_id: Optional[str] = None):
+
+        if self.root_span_id is None:
+            trace = None
+            if trace_id:
+                self.trace_id = trace_id
+                trace = langfuse.trace(id=trace_id)
+            else:
+                trace = langfuse.trace(name="xga_task_engine")
+                self.trace_id = trace.id
+
+            span = trace.span(name=root_span_name, input=task_message,metadata={"task_id": self.task_id})
+            self.root_span_id = span.id
+            self.root_span_name = root_span_name
+
+    def _end_langfuse(self, root_span_name:str, output: Optional[XGATaskResult]=None):
+        if self.root_span_id and self.root_span_name == root_span_name:
+            langfuse.span(trace_id=self.trace_id, id=self.root_span_id).end(output=output)
+            self.root_span_id = None
+            self.root_span_name = None
+
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
         is_stream = response_context.get("is_stream", False)
@@ -316,6 +345,7 @@ class XGATaskEngine:
             "is_stream": self.is_stream,
             "task_id": self.task_id,
             "task_run_id": self.task_run_id,
+            "task_no": self.task_no,
             "trace_id": self.trace_id,
             "root_span_id": self.root_span_id,
             "model_name": self.model_name,

xgae/utils/__init__.py

@@ -1,13 +1,9 @@
 import logging
 
-from .setup_env import setup_langfuse, setup_logging
-
-setup_logging()
-langfuse = setup_langfuse()
-
 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
+

xgae/utils/llm_client.py

@@ -9,19 +9,29 @@ from typing import Union, Dict, Any, Optional, List, TypedDict
 from litellm.utils import ModelResponse, CustomStreamWrapper
 from openai import OpenAIError
 
+from xgae.utils.setup_env import langfuse
+
 class LLMConfig(TypedDict, total=False):
-    model: str
-    model_name: str
-    model_id: str
-    api_key: str
-    api_base: str
-    temperature: float
-    max_tokens: int
-    stream: bool
-    enable_thinking: bool
-    reasoning_effort: str
-    response_format: str
-    top_p: int
+    model: str              # Optional Name of the model to use , Override .env LLM_MODEL
+    model_name: str         # Optional Name of the model to use , use model if empty
+    model_id: str           # Optional ARN for Bedrock inference profiles, default is None
+    api_key: str            # Optional  API key, Override .env LLM_API_KEY or OS env variable
+    api_base: str           # Optional API base URL, Override .env LLM_API_BASE
+    temperature: float      # temperature: Optional Sampling temperature (0-1), Override .env LLM_TEMPERATURE
+    max_tokens: int         # max_tokens: Optional Maximum tokens in the response, Override .env LLM_MAX_TOKENS
+    stream: bool            # stream: Optional whether to stream the response, default is True
+    enable_thinking: bool   # Optional whether to enable thinking, default is  False
+    reasoning_effort: str   # Optional level of reasoning effort, default is  ‘low’
+    response_format: str    # response_format: Optional desired format for the response, default is  None
+    top_p: int              # Optional Top-p sampling parameter, default is None
+
+
+class LangfuseMetadata(TypedDict, total=False):
+    generation_name: str
+    generation_id: str
+    existing_trace_id: str
+    session_id: str
+
 
 class LLMError(Exception):
     """Base exception for LLM-related errors."""
@@ -31,27 +41,15 @@ class LLMClient:
     RATE_LIMIT_DELAY = 30
     RETRY_DELAY = 0.1
 
-    def __init__(self, llm_config: LLMConfig=None) -> None:
-        """
-        Arg: llm_config (Optional[Dict[str, Any]], optional)
-            model: Override default model to use, default set by .env LLM_MODEL
-            model_name: Optional Name of the model to use , use model if empty
-            model_id: Optional ARN for Bedrock inference profiles, default is None
-            api_key: Optional  API key, Override .env LLM_API_KEY or OS environment variable
-            api_base: Optional API base URL, Override .env LLM_API_BASE
-            temperature: Optional Sampling temperature (0-1), Override .env LLM_TEMPERATURE
-            max_tokens: Optional Maximum tokens in the response, Override .env LLM_MAX_TOKENS
-            stream: Optional whether to stream the response, default is True
-            response_format: Optional desired format for the response, default is  None
-            enable_thinking: Optional whether to enable thinking, default is  False
-            reasoning_effort: Optional level of reasoning effort, default is  ‘low’
-            top_p: Optional Top-p sampling parameter, default is None
-        """
+    langfuse_inited = False
+    langfuse_enabled = False
 
-        llm_config = llm_config or LLMConfig()
+    def __init__(self, llm_config: LLMConfig=None):
         litellm.modify_params = True
         litellm.drop_params = True
+        self._init_langfuse()
 
+        llm_config = llm_config or LLMConfig()
         self.max_retries = int(os.getenv("LLM_MAX_RETRIES", 1))
 
         env_llm_model = os.getenv("LLM_MODEL", "openai/qwen3-235b-a22b")
@@ -83,6 +81,20 @@ class LLMClient:
         self.lite_llm_params = self._prepare_llm_params(llm_config_params)
         logging.info(f"📡 LLMClient initialed : model={self.model_name}, is_stream={self.is_stream}, enable thinking={self.lite_llm_params['enable_thinking']}")
 
+    @staticmethod
+    def _init_langfuse():
+        if not LLMClient.langfuse_inited:
+            LLMClient.langfuse_inited =True
+            if langfuse and langfuse.enabled:
+                litellm.success_callback = ["langfuse"]
+                litellm.failure_callback = ["langfuse"]
+                LLMClient.langfuse_enabled = True
+                logging.info("=== LiteLLM Langfuse is enable !")
+            else:
+                LLMClient.langfuse_enabled = False
+                logging.warning("*** LiteLLM Langfuse is disable !")
+
+
 
     def _prepare_llm_params(self, llm_config_params: Dict[str, Any]) -> Dict[str, Any]:
         prepared_llm_params = llm_config_params.copy()
@@ -206,10 +218,10 @@ class LLMClient:
             logging.debug(f"LLMClient: Waiting {delay} seconds before retry llm completion...")
             await asyncio.sleep(delay)
 
-    async def create_completion(self, messages: List[Dict[str, Any]], trace_id: Optional[str]=None) -> Union[ModelResponse, CustomStreamWrapper]:
+    async def create_completion(self, messages: List[Dict[str, Any]], langfuse_metadata: Optional[LangfuseMetadata]=None) -> Union[ModelResponse, CustomStreamWrapper]:
         complete_params = self._prepare_complete_params(messages)
-        if trace_id:
-            complete_params["litellm_trace_id"] = trace_id
+        if LLMClient.langfuse_enabled and langfuse_metadata:
+            complete_params["metadata"] = langfuse_metadata
 
         last_error = None
         for attempt in range(self.max_retries):
@@ -228,12 +240,11 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
-    from xgae.utils import langfuse
-
     async def llm_completion():
         llm_client = LLMClient(LLMConfig(stream=False))
-        messages = [{"role": "user", "content": "今天是2025年8月15日，北京本周每天温度"}]
-        trace_id = langfuse.create_trace_id()
+        messages = [{"role": "user", "content": "1+1="}]
+        trace_id = langfuse.trace(name = "xgae_litellm_test").trace_id
+
         response = await llm_client.create_completion(messages, trace_id)
         if llm_client.is_stream:
             async for chunk in response:
@@ -247,6 +258,7 @@ if __name__ == "__main__":
         else:
             print(response.choices[0].message.content)
 
+
     asyncio.run(llm_completion())
 
 

xgae/utils/setup_env.py

@@ -1,22 +1,27 @@
 import logging
 import os
 
+from dotenv import load_dotenv
 from langfuse import Langfuse
 
-def setup_logging() -> None:
+load_dotenv()
+
+def setup_logging() :
+    log_enable = bool(os.getenv("LOG_ENABLE", True))
+    if not log_enable :
+        return
+
     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_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)
+    log_dir = os.path.dirname(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)
+        os.remove(log_file)
 
     logger = logging.getLogger()
     for handler in logger.handlers[:]:
@@ -43,7 +48,7 @@ def setup_logging() -> None:
     console_handler = logging.StreamHandler()
     console_handler.setFormatter(console_formatter)
 
-    file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+    file_handler = logging.FileHandler(log_file, encoding='utf-8')
     file_handler.setFormatter(file_formatter)
 
     logger.addHandler(console_handler)
@@ -51,30 +56,25 @@ def setup_logging() -> None:
 
     logger.setLevel(log_level)
 
-    logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
+    logging.info(f"📡 XGAE_LOGGING is initialized, log_level={env_log_level}, log_file={log_file}")
 
+setup_logging()
 
 def setup_langfuse() -> Langfuse:
-    _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")
     if env_public_key and env_secret_key:
-        _langfuse = Langfuse(tracing_enabled=True,
+        _langfuse = Langfuse(enabled=True,
                             public_key=env_public_key,
                             secret_key=env_secret_key,
                             host=env_host)
 
-        logging.info("Langfuse initialized Successfully by Key !")
+        logging.info("📡 XGAE_LANGFUSE initialized Successfully by Key !")
     else:
-        _langfuse = Langfuse(tracing_enabled=False)
-        logging.warning("Not set key, Langfuse is disabled!")
+        _langfuse = Langfuse(enabled=False)
+        logging.warning("📡 XGAE_LANGFUSE Not set key, Langfuse is disabled!")
 
     return _langfuse
 
-
-if __name__ == "__main__":
-        from xgae.utils import langfuse
-
-        trace_id = langfuse.create_trace_id()
-        logging.warning(f"trace_id={trace_id}")
+langfuse = setup_langfuse()

xgae-0.1.8.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: xgae
+Version: 0.1.8
+Summary: Extreme General Agent Engine
+Requires-Python: >=3.13
+Requires-Dist: colorlog==6.9.0
+Requires-Dist: langchain-mcp-adapters==0.1.9
+Requires-Dist: langfuse==2.60.9
+Requires-Dist: langgraph==0.6.5
+Requires-Dist: litellm==1.74.15
+Requires-Dist: mcp==1.13.0

xgae-0.1.8.dist-info/RECORD

@@ -0,0 +1,19 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/engine_base.py,sha256=MExJxXHkufv_a-n9tm3FZAbJyxVAwEkRC3C_WAGdu4Q,1746
+xgae/engine/mcp_tool_box.py,sha256=6bsORGK2HE-NS8vWNnbbgUQ9uGr_MI7JGO9j_FYKUKA,9903
+xgae/engine/prompt_builder.py,sha256=8_rNRJksn2QLV_K98S0x0qNeHcmxhU0kB_53IZJTGOU,4366
+xgae/engine/task_engine.py,sha256=kOntdzVtTjjakIhcBNK5vBMiBuAXPqB4R5ustY-BNfU,18931
+xgae/engine/responser/non_stream_responser.py,sha256=tXvkGHFGm2oO0IE8Bz9DFDwqemBkO92Nb6MbX1ukHeE,6352
+xgae/engine/responser/responser_base.py,sha256=FdR0yX7VfU5kW-4JmTXBfnn9AwyX1EbOAnslkC7Vcyg,29874
+xgae/engine/responser/stream_responser.py,sha256=oPGtrT1nedGMjiBAwPzUlu6Z_rPWeVSODC1xQ6D8cTY,52055
+xgae/tools/without_general_tools_app.py,sha256=QknIF4OW9xvOad8gx-F_sCBwQYXqMalnNFvYvZXkQ_I,3789
+xgae/utils/__init__.py,sha256=GPubcIs2XFPiWKnuCpevAtYEmVWKJuXlmGkmsH9qoXA,219
+xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
+xgae/utils/llm_client.py,sha256=Y-o26VW1MOhJYsWJ0zR4u_YXsHSEbvVPY6r90zLQJXU,13213
+xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
+xgae/utils/setup_env.py,sha256=P_p74q3nroBdTkAElfGr4QLm4fu7ZRP0R9BMGNUL010,2352
+xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
+xgae-0.1.8.dist-info/METADATA,sha256=mk0D1208wUJnbIZxyteCAjE2tlKtQixumHo0mcqD3RI,309
+xgae-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.8.dist-info/entry_points.txt,sha256=rhQ9Vksnu8nA78lPTjiJxOCZ5k6sH6s5YNMR68y7C-A,73
+xgae-0.1.8.dist-info/RECORD,,

xgae-0.1.7.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.4
-Name: xgae
-Version: 0.1.7
-Summary: Extreme General Agent Engine
-Requires-Python: >=3.13
-Requires-Dist: colorlog>=6.9.0
-Requires-Dist: langchain-mcp-adapters>=0.1.4
-Requires-Dist: langfuse>=2.60.5
-Requires-Dist: langgraph>=0.3.21
-Requires-Dist: litellm>=1.74.8
-Requires-Dist: mcp>=1.12.1

xgae-0.1.7.dist-info/RECORD

@@ -1,19 +0,0 @@
-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,,