infiagent 3.2.3__tar.gz → 3.2.5__tar.gz

{infiagent-3.2.3/infiagent.egg-info → infiagent-3.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infiagent
-Version: 3.2.3
+Version: 3.2.5
 Summary: InfiAgent multi-agent framework for long-running task automation
 Home-page: https://github.com/ChenglinPoly/Multi-Level-Agent
 Author: Chenglin Yu
@@ -55,7 +55,7 @@ Requires-Dist: psutil>=5.9.0
   <h1>MLA V3 - Build Domain-Specific SOTA-Level AI Agents</h1>
 
   <p>
-    <img src="https://img.shields.io/badge/version-3.2.3-blue.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-3.2.5-blue.svg" alt="Version">
     <img src="https://img.shields.io/badge/python-3.9+-green.svg" alt="Python">
     <img src="https://img.shields.io/badge/license-GPL-blue.svg" alt="License: GPL">
   </p>

{infiagent-3.2.3 → infiagent-3.2.5}/README.md

@@ -4,7 +4,7 @@
   <h1>MLA V3 - Build Domain-Specific SOTA-Level AI Agents</h1>
 
   <p>
-    <img src="https://img.shields.io/badge/version-3.2.3-blue.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-3.2.5-blue.svg" alt="Version">
     <img src="https://img.shields.io/badge/python-3.9+-green.svg" alt="Python">
     <img src="https://img.shields.io/badge/license-GPL-blue.svg" alt="License: GPL">
   </p>

{infiagent-3.2.3 → infiagent-3.2.5}/core/agent_executor.py

@@ -75,6 +75,8 @@ class AgentExecutor:
 
         # 从配置中提取信息
         self.available_tools = list(agent_config.get("available_tools", []))
+        if "task_history_search" not in self.available_tools and "task_history_search" in config_loader.all_tools:
+            self.available_tools.append("task_history_search")
         self.max_turns = self._resolve_max_turns()
         requested_model = self._get_agent_model_preference("execution")
         self._inject_mcp_tools()
@@ -132,20 +134,23 @@ class AgentExecutor:
         self.latest_thinking = ""
         self.first_thinking_done = False
         runtime = get_runtime_settings()
-        self.action_window_steps = int(self.agent_config.get("action_window_steps") or runtime.get("action_window_steps", 30))
-        self.thinking_interval = int(self.agent_config.get("thinking_interval") or runtime.get("thinking_interval", self.action_window_steps))
+        self.thinking_enabled = bool(self.agent_config.get("thinking_enabled", runtime.get("thinking_enabled", True)))
+        self.thinking_steps = int(
+            self.agent_config.get("thinking_steps")
+            or runtime.get("thinking_steps", runtime.get("thinking_interval", runtime.get("action_window_steps", 30)))
+        )
+        self.action_window_steps = self.thinking_steps
+        self.thinking_interval = self.thinking_steps
+        self.no_tool_retry_limit = int(
+            self.agent_config.get("no_tool_retry_limit")
+            or runtime.get("no_tool_retry_limit", 7)
+        )
         self.fresh_enabled = runtime.get("fresh_enabled", False)
         self.fresh_interval_sec = runtime.get("fresh_interval_sec", 0)
         self.last_fresh_at = time.time()
         self.tool_call_counter = 0
         self.llm_turn_counter = 0  # LLM调用轮次计数器（用于消息分组）
         self.current_task_id = None
-        self.token_usage_totals = {
-            "prompt_tokens": 0,
-            "completion_tokens": 0,
-            "total_tokens": 0,
-            "reasoning_tokens": 0,
-        }
 
     def _get_agent_model_preference(self, category: str) -> Optional[str]:
         field_map = {
@@ -248,7 +253,7 @@ class AgentExecutor:
             
             try:
                 # 首次thinking（初始规划）
-                if start_turn == 0 and not self.first_thinking_done:
+                if self.thinking_enabled and start_turn == 0 and not self.first_thinking_done:
                     thinking_result = self._trigger_thinking(
                         task_id, 
                         user_input, 
@@ -294,13 +299,16 @@ class AgentExecutor:
                     # 从 action_history 构建标准 messages 数组
                     messages = self._build_messages_from_action_history()
                     
-                    # 基于真实预算做一次动作历史压缩，再调用 LLM
-                    full_system_prompt, messages = self._fit_request_to_budget(
-                        task_id,
-                        user_input,
-                        full_system_prompt,
-                        messages,
-                    )
+                    # 无 thinking 模式：在动作调用前先进行一轮 ReAct 反思（纯文本，不调用工具）
+                    if not self.thinking_enabled:
+                        self._run_react_reflection(
+                            task_id=task_id,
+                            task_input=user_input,
+                            system_prompt=full_system_prompt,
+                            messages=messages,
+                            turn=turn,
+                        )
+                        messages = self._build_messages_from_action_history()
 
                     # 调用LLM（使用标准 messages 格式）
                     llm_response = self._execute_llm_call(full_system_prompt, messages, task_id=task_id)
@@ -317,33 +325,32 @@ class AgentExecutor:
                         return error_result
 
                     if not llm_response.tool_calls:
-                        # 强制工具调用机制
-
-                        if max_tool_try < 5:
-                            max_tool_try += 1
-                            self.event_emitter.dispatch(CliDisplayEvent(
-                                message=f"⚠️ LLM未调用工具，第{max_tool_try}/5次提醒", 
-                                style='warning'
-                            ))
-                            self.action_history.append({
-                                "_turn": self.llm_turn_counter,
-                                "tool_name": "_no_tool_call",
-                                "arguments": {},
-                                "result": {
-                                    "status": "error",
-                                    "output": f"第{max_tool_try}次：LLM未调用工具，请在下一轮中必须调用工具"
-                                },
-                                "assistant_content": llm_response.output or ""
-                            })
-                            self.llm_turn_counter += 1
-                            self._save_state(task_id, user_input, turn)
-                            continue
-                        else:
-                            # 5次后仍不调用，触发thinking并报错
+                        if self.thinking_enabled:
+                            if max_tool_try < self.no_tool_retry_limit:
+                                max_tool_try += 1
+                                self.event_emitter.dispatch(CliDisplayEvent(
+                                    message=f"⚠️ LLM未调用工具，第{max_tool_try}/{self.no_tool_retry_limit}次提醒",
+                                    style='warning'
+                                ))
+                                self.action_history.append({
+                                    "_turn": self.llm_turn_counter,
+                                    "tool_name": "_no_tool_call",
+                                    "arguments": {},
+                                    "result": {
+                                        "status": "error",
+                                        "output": f"第{max_tool_try}次：LLM未调用工具，请在下一轮中必须调用工具"
+                                    },
+                                    "assistant_content": llm_response.output or "",
+                                    "reasoning_content": llm_response.reasoning_content or "",
+                                })
+                                self.llm_turn_counter += 1
+                                self._save_state(task_id, user_input, turn)
+                                continue
+
                             thinking_result = self._trigger_thinking(
-                                task_id, 
-                                user_input, 
-                                is_initial=False, 
+                                task_id,
+                                user_input,
+                                is_initial=False,
                                 is_forced=True
                             )
                             error_output = thinking_result or "多次未调用工具"
@@ -357,6 +364,28 @@ class AgentExecutor:
                             self.event_emitter.dispatch(AgentEndEvent(status='error', result=error_result))
                             self.event_emitter.dispatch(ThinkingFailEvent(agent_name=self.agent_name, error_message=f"[{self.agent_name}] 强制thinking: {thinking_result if thinking_result else '分析失败'}"))
                             return error_result
+
+                        text_response = (llm_response.output or "").strip()
+                        if text_response:
+                            self._record_text_response(
+                                tool_name="_assistant_text",
+                                text=text_response,
+                                llm_turn=self.llm_turn_counter,
+                                reasoning_content=llm_response.reasoning_content or "",
+                            )
+                            self.llm_turn_counter += 1
+                            self._save_state(task_id, user_input, turn)
+                            continue
+
+                        error_result = {
+                            "status": "error",
+                            "output": "",
+                            "error_information": "ReAct模式下模型既未调用工具，也未返回可用文本"
+                        }
+                        error_result = self._with_model_outputs(error_result)
+                        self.hierarchy_manager.pop_agent(self.agent_id, str(error_result))
+                        self.event_emitter.dispatch(AgentEndEvent(status='error', result=error_result))
+                        return error_result
                     # 重置计数器（成功调用了工具）
                     max_tool_try = 0
 
@@ -386,7 +415,7 @@ class AgentExecutor:
                     # 检查是否该触发thinking（每 N 轮工具调用）
                     # 用整除判断是否跨过了 thinking_interval 边界（避免多 tool_call 跳过边界值）
                     crossed_boundary = (counter_before // self.thinking_interval) < (self.tool_call_counter // self.thinking_interval)
-                    if self.tool_call_counter > 0 and crossed_boundary:
+                    if self.thinking_enabled and self.tool_call_counter > 0 and crossed_boundary:
                         thinking_result = self._trigger_thinking(task_id, user_input, is_initial=False)
                         if thinking_result:
                             self.latest_thinking = thinking_result
@@ -395,7 +424,7 @@ class AgentExecutor:
 
                     # 检查动作窗口是否跨过边界：thinking 完成后再清空当前可见动作窗口
                     crossed_action_window = (counter_before // self.action_window_steps) < (self.tool_call_counter // self.action_window_steps)
-                    if self.tool_call_counter > 0 and crossed_action_window:
+                    if self.thinking_enabled and self.tool_call_counter > 0 and crossed_action_window:
                         self.action_history = []
                         self.llm_turn_counter = 0
                 
@@ -492,6 +521,15 @@ class AgentExecutor:
                     "content": f"[Previous actions summary]\n{action['result']['output']}"
                 })
                 continue
+
+            if tool_name in {"_react_reflection", "_assistant_text"}:
+                assistant_content = action.get("assistant_content", "") or action.get("result", {}).get("output", "")
+                if assistant_content:
+                    assistant_msg = {"role": "assistant", "content": assistant_content}
+                    if action.get("reasoning_content"):
+                        assistant_msg["reasoning_content"] = action["reasoning_content"]
+                    messages.append(assistant_msg)
+                continue
             
             # 特殊处理：LLM 未调用工具
             if tool_name == "_no_tool_call":
@@ -611,7 +649,17 @@ class AgentExecutor:
     def _format_kimi_history_tool_call_id(tool_name: str, sequence_index: int) -> str:
         safe_tool_name = str(tool_name or "").strip() or "tool"
         return f"functions.{safe_tool_name}:{max(0, int(sequence_index))}"
-    def _execute_llm_call(self, system_prompt: str, messages: List[Dict] = None, task_id: Optional[str] = None):
+    def _execute_llm_call(
+        self,
+        system_prompt: str,
+        messages: List[Dict] = None,
+        task_id: Optional[str] = None,
+        *,
+        tool_list: Optional[List[str]] = None,
+        tool_choice: Optional[str] = None,
+        debug_label: str = "execution",
+        stream_tokens: bool = True,
+    ):
         """
         执行LLM调用并分发事件
         
@@ -629,7 +677,8 @@ class AgentExecutor:
             system_prompt=system_prompt
         ))
         
-        execution_tool_choice = self.llm_client.resolve_tool_choice(
+        effective_tool_list = list(self.available_tools if tool_list is None else tool_list)
+        execution_tool_choice = tool_choice or self.llm_client.resolve_tool_choice(
             category="execution",
             model=self.execution_model,
         )
@@ -639,26 +688,27 @@ class AgentExecutor:
             history=messages,
             model=self.execution_model,
             system_prompt=system_prompt,
-            tool_list=self.available_tools,
+            tool_list=effective_tool_list,
             tool_choice=execution_tool_choice,
             max_tokens=max_tokens_override,
             emit_tokens="token",  # 主 Agent 调用：流式发送 content token
             debug_task_id=task_id,
-            debug_label="execution",
+            debug_label=debug_label,
             stream_callback=self._build_llm_stream_callback(
                 stream_group="llm",
                 agent_name=self.agent_name,
                 model=self.execution_model,
-            ) if self.stream_llm_tokens else None,
+            ) if self.stream_llm_tokens and stream_tokens else None,
         )
 
         llm_record = {
             "turn_index": self.llm_turn_counter,
+            "debug_label": debug_label,
+            "tool_choice": execution_tool_choice,
             "model": llm_response.model or self.execution_model,
             "content": llm_response.output or "",
             "reasoning_content": llm_response.reasoning_content or "",
             "finish_reason": llm_response.finish_reason or "",
-            "usage": dict(llm_response.usage or {}),
             "tool_calls": [
                 {
                     "id": tool_call.id,
@@ -670,7 +720,6 @@ class AgentExecutor:
             "status": llm_response.status,
         }
         self.execution_traces.append(llm_record)
-        current_usage, cumulative_usage = self._accumulate_usage(llm_response.usage)
         
         self.event_emitter.dispatch(LlmCallEndEvent(
             llm_output=llm_response.output, 
@@ -678,111 +727,84 @@ class AgentExecutor:
             model=llm_record["model"],
             reasoning_content=llm_record["reasoning_content"],
             finish_reason=llm_record["finish_reason"],
-            usage=current_usage,
-            cumulative_usage=cumulative_usage,
-            request_budget=dict(llm_response.request_budget or {}),
         ))
         return llm_response
 
-    def _accumulate_usage(self, usage: Optional[Dict[str, Any]]) -> tuple[Dict[str, Any], Dict[str, Any]]:
-        current = dict(usage or {})
-        for key in ("prompt_tokens", "completion_tokens", "total_tokens", "reasoning_tokens"):
-            value = int(current.get(key, 0) or 0)
-            current[key] = value
-            self.token_usage_totals[key] = int(self.token_usage_totals.get(key, 0) or 0) + value
-        cumulative = dict(self.token_usage_totals)
-        if "cost" in current:
-            cumulative["last_cost"] = current.get("cost")
-        return current, cumulative
-
-    def _fit_request_to_budget(self, task_id: str, task_input: str, system_prompt: str, messages: List[Dict]) -> tuple[str, List[Dict]]:
-        """
-        在真正调用 LLM 之前，按实际请求预算动态压缩 action_history。
-        这一步是软压缩；最终是否超窗由 llm_client 内的硬预算检查兜底。
-        """
-        max_tokens_override = self.agent_config.get("max_tokens")
-
-        for _ in range(3):
-            tools_definition = self.llm_client._build_tools_definition(self.available_tools)
-            budget = self.llm_client.build_request_budget(
-                system_prompt=system_prompt,
-                messages=messages,
-                tools_definition=tools_definition,
-                max_tokens=max_tokens_override,
-                force_exact=False,
-            )
-            if budget.total_with_reserved_tokens >= int(self.llm_client.max_context_window * 0.7):
-                budget = self.llm_client.build_request_budget(
-                    system_prompt=system_prompt,
-                    messages=messages,
-                    tools_definition=tools_definition,
-                    max_tokens=max_tokens_override,
-                    force_exact=True,
-                )
-
-            if not budget.over_budget or not self.action_history:
-                return system_prompt, messages
-
-            from services.action_compressor import ActionCompressor
-
-            if not hasattr(self, "action_compressor"):
-                self.action_compressor = ActionCompressor(
-                    self.llm_client,
-                    preferred_model=self._get_agent_model_preference("compressor"),
-                    max_tokens=self.agent_config.get("max_tokens"),
-                    debug_task_id=self.current_task_id,
-                )
-            else:
-                self.action_compressor.debug_task_id = self.current_task_id
-
-            available_action_tokens = max(
-                256,
-                budget.available_input_tokens
-                - budget.system_prompt_tokens
-                - budget.tool_tokens
-                - budget.image_surcharge_tokens,
-            )
-            before_tokens = self.action_compressor.count_action_context_tokens(
-                self.action_history,
-                thinking=self.latest_thinking,
-                task_input=self.current_task_input,
-            )
-            compressed = self.action_compressor.compress_if_needed(
-                self.action_history,
-                self.llm_client.max_context_window,
-                thinking=self.latest_thinking,
-                task_input=self.current_task_input,
-                max_action_tokens=available_action_tokens,
-            )
-            after_tokens = self.action_compressor.count_action_context_tokens(
-                compressed,
-                thinking=self.latest_thinking,
-                task_input=self.current_task_input,
-            )
-
-            if after_tokens >= before_tokens:
-                return system_prompt, messages
+    def _record_text_response(
+        self,
+        *,
+        tool_name: str,
+        text: str,
+        llm_turn: int,
+        reasoning_content: str = "",
+    ) -> None:
+        action_record = {
+            "_turn": llm_turn,
+            "tool_name": tool_name,
+            "arguments": {},
+            "result": {
+                "status": "success",
+                "output": text,
+            },
+            "assistant_content": text,
+            "reasoning_content": reasoning_content,
+            "_has_image": False,
+            "_image_base64": None,
+        }
+        fact_record = dict(action_record)
+        fact_record["_image_base64"] = None
+        self.action_history_fact.append(fact_record)
+        self.action_history.append(action_record)
 
-            self.event_emitter.dispatch(CliDisplayEvent(
-                message=(
-                    "🔐 请求接近上下文上限，按真实预算压缩动作历史: "
-                    f"{before_tokens} → {after_tokens} tokens "
-                    f"(可用动作预算 {available_action_tokens})"
-                ),
-                style='warning'
-            ))
-            self.action_history = compressed
-            system_prompt = self.context_builder.build_context(
-                task_id,
-                self.agent_id,
-                self.agent_name,
-                task_input,
-                action_history=self.action_history,
-                include_action_history=False
-            )
-            messages = self._build_messages_from_action_history()
+    def _build_react_reflection_prompt(self) -> str:
+        tool_names = ", ".join(self.available_tools) if self.available_tools else "(无可用工具)"
+        return (
+            "你当前处于 ReAct 反思阶段。请先简短输出当前进展、下一步最应该采取的动作、"
+            "以及是否需要使用 task_history_search 检索历史任务。"
+            "只输出纯文本思考，不要调用工具，不要输出 JSON/XML/markdown 标记。"
+            f"可用工具如下：{tool_names}"
+        )
 
-        return system_prompt, messages
+    def _run_react_reflection(
+        self,
+        *,
+        task_id: str,
+        task_input: str,
+        system_prompt: str,
+        messages: List[Dict],
+        turn: int,
+    ) -> None:
+        reflection_messages = list(messages or [])
+        reflection_messages.append({
+            "role": "user",
+            "content": self._build_react_reflection_prompt(),
+        })
+        llm_response = self._execute_llm_call(
+            system_prompt,
+            reflection_messages,
+            task_id=task_id,
+            tool_list=[],
+            tool_choice="none",
+            debug_label="react_reflection",
+            stream_tokens=False,
+        )
+        if llm_response.status != "success":
+            raise Exception(llm_response.error_information or "ReAct reflection failed")
+        reflection_text = str(llm_response.output or "").strip()
+        if not reflection_text:
+            return
+        self._record_text_response(
+            tool_name="_react_reflection",
+            text=reflection_text,
+            llm_turn=self.llm_turn_counter,
+            reasoning_content=llm_response.reasoning_content or "",
+        )
+        self.llm_turn_counter += 1
+        self._save_state(task_id, task_input, turn)
+        self.event_emitter.dispatch(CliDisplayEvent(
+            message=f"🤔 ReAct反思已更新: {reflection_text[:160]}",
+            style='info'
+        ))
 
     def _execute_tool_call(self, tool_call: Dict, task_id: str, user_input: str, turn: int,
                           assistant_content: str = "", reasoning_content: str = "",
@@ -1002,8 +1024,17 @@ class AgentExecutor:
 
         # 重新读取运行时参数
         runtime = get_runtime_settings()
-        self.action_window_steps = int(self.agent_config.get("action_window_steps") or runtime.get("action_window_steps", 30))
-        self.thinking_interval = int(self.agent_config.get("thinking_interval") or runtime.get("thinking_interval", self.action_window_steps))
+        self.thinking_enabled = bool(self.agent_config.get("thinking_enabled", runtime.get("thinking_enabled", True)))
+        self.thinking_steps = int(
+            self.agent_config.get("thinking_steps")
+            or runtime.get("thinking_steps", runtime.get("thinking_interval", runtime.get("action_window_steps", 30)))
+        )
+        self.action_window_steps = self.thinking_steps
+        self.thinking_interval = self.thinking_steps
+        self.no_tool_retry_limit = int(
+            self.agent_config.get("no_tool_retry_limit")
+            or runtime.get("no_tool_retry_limit", 7)
+        )
         self.fresh_enabled = runtime.get("fresh_enabled", False)
         self.fresh_interval_sec = runtime.get("fresh_interval_sec", 0)
         self.last_fresh_at = time.time()
@@ -1013,6 +1044,8 @@ class AgentExecutor:
         self.config_loader = loader_cls(self.config_loader.agent_system_name)
         self.agent_config = self.config_loader.get_tool_config(self.agent_name)
         self.available_tools = list(self.agent_config.get("available_tools", []))
+        if "task_history_search" not in self.available_tools and "task_history_search" in self.config_loader.all_tools:
+            self.available_tools.append("task_history_search")
         self._inject_mcp_tools()
 
         self.llm_client = SimpleLLMClient()
@@ -1207,12 +1240,10 @@ class AgentExecutor:
                 "formatted_result": result,
                 "finish_reason": thinking_payload.get("finish_reason", ""),
                 "status": thinking_payload.get("status", "success"),
-                "usage": dict(thinking_payload.get("usage") or {}),
                 "is_initial": bool(is_initial),
                 "is_forced": bool(is_forced),
             }
             self.thinking_traces.append(thinking_record)
-            current_usage, cumulative_usage = self._accumulate_usage(thinking_record["usage"])
             # 发送 thinking 事件（完整内容）
             self.event_emitter.dispatch(ThinkingEndEvent(
                 agent_name=self.agent_name, 
@@ -1221,8 +1252,6 @@ class AgentExecutor:
                 raw_output=thinking_record["content"],
                 raw_reasoning_content=thinking_record["reasoning_content"],
                 finish_reason=thinking_record["finish_reason"],
-                usage=current_usage,
-                cumulative_usage=cumulative_usage,
                 is_initial=is_initial,
                 is_forced=is_forced
             ))
@@ -1248,6 +1277,17 @@ class AgentExecutor:
         def _callback(chunk: Dict[str, Any]):
             kind = str((chunk or {}).get("kind") or "content").strip().lower()
             text = str((chunk or {}).get("text") or "")
+            attempt = int((chunk or {}).get("attempt") or 1)
+            if kind == "reset":
+                event_type = "run.thinking.reset" if stream_group == "thinking" else "run.llm.reset"
+                payload = {
+                    "agent_name": agent_name,
+                    "model": str((chunk or {}).get("model") or model or ""),
+                    "attempt": attempt,
+                    "reason": str((chunk or {}).get("reason") or "retry"),
+                }
+                self._emit_sdk_stream_event(event_type, payload)
+                return
             if not text:
                 return
             current_model = str((chunk or {}).get("model") or model or "")
@@ -1258,6 +1298,7 @@ class AgentExecutor:
                     "model": current_model,
                     "text": text,
                     "token_kind": kind,
+                    "attempt": attempt,
                     "is_initial": bool(is_initial),
                     "is_forced": bool(is_forced),
                 }
@@ -1268,6 +1309,7 @@ class AgentExecutor:
                     "model": current_model,
                     "text": text,
                     "token_kind": kind,
+                    "attempt": attempt,
                 }
             self._emit_sdk_stream_event(event_type, payload)
 
@@ -1276,7 +1318,8 @@ class AgentExecutor:
     def _build_model_outputs_payload(self) -> Dict[str, Any]:
         execution_traces = list(getattr(self, "execution_traces", []) or [])
         thinking_traces = list(getattr(self, "thinking_traces", []) or [])
-        last_execution = execution_traces[-1] if execution_traces else None
+        execution_only = [item for item in execution_traces if str(item.get("debug_label") or "execution") == "execution"]
+        last_execution = execution_only[-1] if execution_only else (execution_traces[-1] if execution_traces else None)
         last_thinking = thinking_traces[-1] if thinking_traces else None
         return {
             "execution_turns": execution_traces,