xgae 0.1.7__tar.gz → 0.1.8__tar.gz

{xgae-0.1.7 → xgae-0.1.8}/.env

@@ -1,6 +1,7 @@
 # LOG
 LOG_LEVEL=INFO
 LOG_FILE=log/xgae.log
+LOG_ENABLE=True
 
 # LANGFUSE
 LANGFUSE_PUBLIC_KEY=

{xgae-0.1.7 → xgae-0.1.8}/.idea/workspace.xml

@@ -29,6 +29,7 @@
   "keyToString": {
     "ModuleVcsDetector.initialDetectionPerformed": "true",
     "Python.llm_client.executor": "Run",
+    "Python.mcp_tool_box.executor": "Run",
     "Python.message_tools_app.executor": "Run",
     "Python.responser_base.executor": "Run",
     "Python.run_engine_with_human_in_loop.executor": "Run",
@@ -38,6 +39,8 @@
     "Python.run_xga_engine.executor": "Run",
     "Python.setup_env.executor": "Run",
     "Python.task_engine.executor": "Run",
+    "Python.test_langfuse.executor": "Run",
+    "Python.test_litellm_langfuse.executor": "Run",
     "Python.utils.executor": "Run",
     "Python.xga_engine.executor": "Run",
     "Python.xga_mcp_tool_box.executor": "Debug",
@@ -160,7 +163,8 @@
       <workItem from="1755700523844" duration="24000" />
       <workItem from="1755737435202" duration="48139000" />
       <workItem from="1756044658912" duration="1248000" />
-      <workItem from="1756082326044" duration="23338000" />
+      <workItem from="1756082326044" duration="23657000" />
+      <workItem from="1756168626188" duration="26778000" />
     </task>
     <servers />
   </component>
@@ -179,18 +183,22 @@
     </breakpoint-manager>
   </component>
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/xgae$test_litellm_langfuse.coverage" NAME="test_litellm_langfuse Coverage Results" MODIFIED="1756196476262" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_engine.coverage" NAME="xga_engine Coverage Results" MODIFIED="1755580277172" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_simple.coverage" NAME="run_simple Coverage Results" MODIFIED="1756111714718" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_xga_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756111613459" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$message_tools_app.coverage" NAME="message_tools_app Coverage Results" MODIFIED="1756094157566" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_engine_with_human_in_loop.coverage" NAME="run_engine_with_human_in_loop Coverage Results" MODIFIED="1756089269027" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_prompt_builder.coverage" NAME="xga_prompt_builder Coverage Results" MODIFIED="1755587456555" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$test_langfuse.coverage" NAME="test_langfuse Coverage Results" MODIFIED="1756196410142" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_task_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756207048901" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$responser_base.coverage" NAME="responser_base Coverage Results" MODIFIED="1756103040764" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$mcp_tool_box.coverage" NAME="mcp_tool_box Coverage Results" MODIFIED="1756188784603" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$utils.coverage" NAME="utils Coverage Results" MODIFIED="1755226923439" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1755657717310" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1756200209483" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_user_prompt.coverage" NAME="run_user_prompt Coverage Results" MODIFIED="1756089624828" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755583099719" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$task_engine.coverage" NAME="task_engine Coverage Results" MODIFIED="1756102942600" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1756112044142" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1756188100577" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$task_engine.coverage" NAME="task_engine Coverage Results" MODIFIED="1756199881134" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
   </component>
 </project>

xgae-0.1.8/PKG-INFO

@@ -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.7 → xgae-0.1.8}/pyproject.toml

@@ -1,16 +1,16 @@
 [project]
 name = "xgae"
-version = "0.1.7"
+version = "0.1.8"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "colorlog>=6.9.0",
-    "langchain-mcp-adapters>=0.1.4",
-    "langgraph>=0.3.21",
-    "litellm>=1.74.8",
-    "mcp>=1.12.1",
-    "langfuse>=2.60.5",
+    "colorlog==6.9.0",
+    "langchain-mcp-adapters==0.1.9",
+    "langgraph==0.6.5",
+    "litellm==1.74.15",
+    "mcp==1.13.0",
+    "langfuse==2.60.9",
 ]
 
 [build-system]

{xgae-0.1.7 → xgae-0.1.8}/src/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-0.1.7 → xgae-0.1.8}/src/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-0.1.7 → xgae-0.1.8}/src/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-0.1.7 → xgae-0.1.8}/src/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-0.1.7 → xgae-0.1.8}/src/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)}"))