xgae 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

xgae/engine/responser/xga_non_stream_responser.py

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

xgae/engine/xga_engine.py

@@ -1,278 +0,0 @@
-
-import logging
-import json
-
-from typing import List, Any, Dict, Optional, AsyncGenerator, cast, Union, Literal
-from uuid import uuid4
-
-from xgae.engine.responser.xga_responser_base import TaskResponseContext, TaskResponseProcessor, TaskRunContinuousState
-from xgae.engine.xga_base import XGAContextMsg, XGAToolBox, XGAResponseMsg
-from xgae.utils.llm_client import LLMClient, LLMConfig
-from xgae.utils.setup_env import langfuse
-from xgae.utils.utils import handle_error
-
-from xga_prompt_builder import XGAPromptBuilder
-from xga_mcp_tool_box import XGAMcpToolBox
-
-class XGATaskEngine:
-    def __init__(self,
-                 session_id: Optional[str] = None,
-                 task_id: Optional[str] = None,
-                 agent_id: Optional[str] = None,
-                 system_prompt: Optional[str] = None,
-                 llm_config: Optional[LLMConfig] = None,
-                 prompt_builder: Optional[XGAPromptBuilder] = None,
-                 tool_box: Optional[XGAToolBox] = None):
-        self.session_id = session_id if session_id else f"xga_sid_{uuid4()}"
-        self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
-        self.agent_id = agent_id
-
-        self.llm_client = LLMClient(llm_config)
-        self.model_name = self.llm_client.model_name
-        self.is_stream = self.llm_client.is_stream
-
-        self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
-        self.tool_box = tool_box or XGAMcpToolBox()
-
-        self.task_context_msgs: List[XGAContextMsg] = []
-        self.task_no = -1
-        self.task_run_id = f"{self.task_id}[{self.task_no}]"
-        self.trace_id = None
-
-    async def __async_init__(self, general_tools:List[str], custom_tools: List[str]) -> None:
-        await  self.tool_box.load_mcp_tools_schema()
-        await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
-        general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
-        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
-
-        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
-
-    @classmethod
-    async def create(cls,
-                     session_id: Optional[str] = None,
-                     task_id: Optional[str] = None,
-                     agent_id: Optional[str] = None,
-                     system_prompt: Optional[str] = None,
-                     general_tools: Optional[List[str]] = None,
-                     custom_tools: Optional[List[str]] = None,
-                     llm_config: Optional[LLMConfig] = None,
-                     prompt_builder: Optional[XGAPromptBuilder] = None,
-                     tool_box: Optional[XGAToolBox] = None) -> 'XGATaskEngine':
-        engine: XGATaskEngine = cls(session_id=session_id,
-                                    task_id=task_id,
-                                    agent_id=agent_id,
-                                    system_prompt=system_prompt,
-                                    llm_config=llm_config,
-                                    prompt_builder=prompt_builder,
-                                    tool_box=tool_box)
-
-        general_tools = general_tools or ["complete"]
-        custom_tools = custom_tools or []
-        await engine.__async_init__(general_tools, custom_tools)
-
-        logging.info("*"*30 + f"   XGATaskEngine Task'{engine.task_id}' Initialized   " + "*"*30)
-        logging.info(f"model_name={engine.model_name}, is_stream={engine.is_stream}, trace_id={engine.trace_id}")
-        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
-
-        return engine
-
-
-    async def run_task(self,
-                       task_message: Dict[str, Any],
-                       max_auto_run: int = 25,
-                       trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
-        try:
-            self.trace_id = trace_id or self.trace_id or langfuse.create_trace_id()
-
-            self.task_no += 1
-            self.task_run_id = f"{self.task_id}[{self.task_no}]"
-
-            self.add_context_msg(type="user", content=task_message, is_llm_message=True)
-
-            if max_auto_run <= 1:
-                continuous_state:TaskRunContinuousState  = {
-                    "accumulated_content": "",
-                    "auto_continue_count": 0,
-                    "auto_continue": False
-                }
-                async for chunk in self._run_task_once(continuous_state):
-                    yield chunk
-            else:
-                async for chunk in self._run_task_auto(max_auto_run):
-                    yield chunk
-        finally:
-            await self.tool_box.destroy_task_tool_box(self.task_id)
-
-    async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
-        llm_messages = [{"role": "system", "content": self.task_prompt}]
-        cxt_llm_contents = self._get_context_llm_contents()
-        llm_messages.extend(cxt_llm_contents)
-
-        partial_content = continuous_state.get('accumulated_content', '')
-        if partial_content:
-            temp_assistant_message = {
-                "role": "assistant",
-                "content": partial_content
-            }
-            llm_messages.append(temp_assistant_message)
-
-        llm_response = await self.llm_client.create_completion(llm_messages)
-        response_processor = self._create_response_processer()
-
-        async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
-            yield chunk
-
-
-    async def _run_task_auto(self, max_auto_run: int) -> AsyncGenerator:
-        continuous_state: TaskRunContinuousState = {
-            "accumulated_content": "",
-            "auto_continue_count": 0,
-            "auto_continue": True
-        }
-
-        def update_continuous_state(_auto_continue_count,  _auto_continue):
-            continuous_state["auto_continue_count"] = _auto_continue_count
-            continuous_state["auto_continue"] = _auto_continue
-
-        auto_continue_count = 0
-        auto_continue = True
-        while auto_continue and auto_continue_count < max_auto_run:
-            auto_continue = False
-
-            try:
-                async for chunk in self._run_task_once(continuous_state):
-                    try:
-                        if chunk.get("type") == "status":
-                            content = json.loads(chunk.get('content', '{}'))
-                            status_type = content.get('status_type', None)
-                            if status_type == "error":
-                                logging.error(f"run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
-                                yield chunk
-                                return
-                            elif status_type == 'finish':
-                                finish_reason = content.get('finish_reason', None)
-                                if finish_reason == 'stop' :
-                                    auto_continue = True
-                                    auto_continue_count += 1
-                                    update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='stop', auto-continuing ({auto_continue_count}/{max_auto_run})")
-                                    continue
-                                elif finish_reason == 'xml_tool_limit_reached':
-                                    logging.info(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stopping auto-continue")
-                                    auto_continue = False
-                                    update_continuous_state(auto_continue_count, auto_continue)
-                                elif finish_reason == 'length':
-                                    auto_continue = True
-                                    auto_continue_count += 1
-                                    update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='length', auto-continuing ({auto_continue_count}/{max_auto_run})")
-                                    continue
-                    except Exception as parse_error:
-                        logging.error(f"run_task_auto: Error in parse chunk: {str(parse_error)}")
-                        yield {
-                            "type": "status",
-                            "status": "error",
-                            "message": f"Error in parse chunk: {str(parse_error)}"
-                        }
-                        return
-
-                    # Otherwise just yield the chunk normally
-                    yield chunk
-
-                # If not auto-continuing, we're done
-                if not auto_continue:
-                    break
-            except Exception as run_error:
-                logging.error(f"run_task_auto: Call task_run_once error: {str(run_error)}")
-                yield {
-                    "type": "status",
-                    "status": "error",
-                    "message": f"Call task_run_once error: {str(run_error)}"
-                }
-                return
-
-    def add_context_msg(self, type: Literal["user", "status",  "tool", "assistant", "assistant_response_end"],
-                        content: Union[Dict[str, Any], List[Any], str],
-                        is_llm_message: bool,
-                        metadata: Optional[Dict[str, Any]]=None)-> XGAContextMsg:
-        message = XGAContextMsg(
-            message_id = f"xga_msg_{uuid4()}",
-            type = type,
-            content = content,
-            is_llm_message=is_llm_message,
-            metadata = metadata,
-            session_id = self.session_id,
-            agent_id = self.agent_id,
-            task_id = self.task_id,
-            task_run_id = self.task_run_id,
-            trace_id = self.trace_id
-        )
-        self.task_context_msgs.append(message)
-
-        return message
-
-    def _get_context_llm_contents (self) -> List[Dict[str, Any]]:
-        llm_messages = []
-        for message in self.task_context_msgs:
-            if message["is_llm_message"]:
-                llm_messages.append(message)
-
-        cxt_llm_contents = []
-        for llm_message in llm_messages:
-            content = llm_message["content"]
-            # @todo content List type
-            if isinstance(content, str):
-                try:
-                    _content = json.loads(content)
-                    cxt_llm_contents.append(_content)
-                except json.JSONDecodeError as e:
-                    logging.error(f"get_context_llm_contents: Failed to decode json, content=:{content}")
-                    handle_error(e)
-            else:
-                cxt_llm_contents.append(content)
-
-        return cxt_llm_contents
-
-    def _create_response_processer(self) -> TaskResponseProcessor:
-        response_context = self._create_response_context()
-        is_stream = response_context.get("is_stream", False)
-        if is_stream:
-            from xgae.engine.responser.xga_stream_responser import StreamTaskResponser
-            return StreamTaskResponser(response_context)
-        else:
-            from xgae.engine.responser.xga_non_stream_responser import NonStreamTaskResponser
-            return NonStreamTaskResponser(response_context)
-
-    def _create_response_context(self) -> TaskResponseContext:
-        response_context: TaskResponseContext = {
-            "is_stream": self.is_stream,
-            "task_id": self.task_id,
-            "task_run_id": self.task_run_id,
-            "trace_id": self.trace_id,
-            "model_name": self.model_name,
-            "max_xml_tool_calls": 0,
-            "add_context_msg": self.add_context_msg,
-            "tool_box": self.tool_box,
-            "tool_execution_strategy": "parallel",
-            "xml_adding_strategy": "user_message",
-        }
-        return response_context
-
-if __name__ == "__main__":
-    import asyncio
-    from xgae.utils.utils import read_file
-    async def main():
-        tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
-        system_prompt = read_file("templates/scp_test_prompt.txt")
-        engine = await XGATaskEngine.create(tool_box=tool_box,
-                                            general_tools=[],
-                                            custom_tools=["bomc_fault.*"],
-                                            llm_config=LLMConfig(stream=False),
-                                            system_prompt=system_prompt)
-        #engine = await XGATaskEngine.create()
-
-        async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"},
-                                           max_auto_run=8):
-             print(chunk)
-
-    asyncio.run(main())

xgae-0.1.4.dist-info/RECORD

@@ -1,16 +0,0 @@
-xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/xga_base.py,sha256=yM8YdThOVHo_TFrLUiu33hZzU2H9knQLs3JfD6hOx24,1669
-xgae/engine/xga_engine.py,sha256=7XRRC6KKz3a2EvH7P9k8szbCCm2O6MxIL674GzUkwHI,12940
-xgae/engine/xga_mcp_tool_box.py,sha256=dvToorrw8FJq4NrzUz494czI6QhT3bvmJQlt5oFgVBA,9994
-xgae/engine/xga_prompt_builder.py,sha256=RuTvQCNufqxDwVvSOPXR0qxAc42cG7NuIaUy9amu66A,4351
-xgae/engine/responser/xga_non_stream_responser.py,sha256=HlSN025jIsl-JY_n6fEdqJQkqc1UqCrgFr6K23uXF3E,12704
-xgae/engine/responser/xga_responser_base.py,sha256=IBJPQELMxZSpnz8YlSCgvPNSHEEUp8_vglotVnHoSeY,36808
-xgae/engine/responser/xga_stream_responser.py,sha256=FESVliTzHFy8BkTudi_Ftcty6QFpJWx7kYRubSuLqsg,50370
-xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
-xgae/utils/llm_client.py,sha256=mgzn8heUyRm92HTLEYGdfsGEpFtD-xLFr39P98_JP0s,12402
-xgae/utils/setup_env.py,sha256=-Ehv7_E9udHc8AjP66Y78E4X7_G6gpuNJkioCh5fn4A,2902
-xgae/utils/utils.py,sha256=cCYmWjKFksZ8BRD1YYnaM_jTLVHAg1ibEdjsczEUO6k,1134
-xgae/utils/xml_tool_parser.py,sha256=7Ei7X8zSgVct0fFCSmxDtknCLtdrUIwL9hy_0qSNlvs,7546
-xgae-0.1.4.dist-info/METADATA,sha256=R_nN1j5mESZfEQIiLFBQufsOc_Hbd6190GBLgo7-k-o,309
-xgae-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.4.dist-info/RECORD,,