infiagent 3.2.2__tar.gz → 3.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infiagent
-Version: 3.2.2
+Version: 3.2.3
 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.2-blue.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-3.2.3-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.2 → infiagent-3.2.3}/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.2-blue.svg" alt="Version">
+    <img src="https://img.shields.io/badge/version-3.2.3-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.2 → infiagent-3.2.3}/core/agent_executor.py

@@ -75,8 +75,6 @@ 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()
@@ -134,23 +132,20 @@ class AgentExecutor:
         self.latest_thinking = ""
         self.first_thinking_done = False
         runtime = get_runtime_settings()
-        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.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.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 = {
@@ -253,7 +248,7 @@ class AgentExecutor:
             
             try:
                 # 首次thinking（初始规划）
-                if self.thinking_enabled and start_turn == 0 and not self.first_thinking_done:
+                if start_turn == 0 and not self.first_thinking_done:
                     thinking_result = self._trigger_thinking(
                         task_id, 
                         user_input, 
@@ -299,16 +294,13 @@ class AgentExecutor:
                     # 从 action_history 构建标准 messages 数组
                     messages = self._build_messages_from_action_history()
                     
-                    # 无 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
+                    full_system_prompt, messages = self._fit_request_to_budget(
+                        task_id,
+                        user_input,
+                        full_system_prompt,
+                        messages,
+                    )
 
                     # 调用LLM（使用标准 messages 格式）
                     llm_response = self._execute_llm_call(full_system_prompt, messages, task_id=task_id)
@@ -325,32 +317,33 @@ class AgentExecutor:
                         return error_result
 
                     if not llm_response.tool_calls:
-                        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
-
+                        # 强制工具调用机制
+
+                        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并报错
                             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 "多次未调用工具"
@@ -364,28 +357,6 @@ 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
 
@@ -415,7 +386,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.thinking_enabled and self.tool_call_counter > 0 and crossed_boundary:
+                    if 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
@@ -424,7 +395,7 @@ class AgentExecutor:
 
                     # 检查动作窗口是否跨过边界：thinking 完成后再清空当前可见动作窗口
                     crossed_action_window = (counter_before // self.action_window_steps) < (self.tool_call_counter // self.action_window_steps)
-                    if self.thinking_enabled and self.tool_call_counter > 0 and crossed_action_window:
+                    if self.tool_call_counter > 0 and crossed_action_window:
                         self.action_history = []
                         self.llm_turn_counter = 0
                 
@@ -521,15 +492,6 @@ 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":
@@ -649,17 +611,7 @@ 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,
-        *,
-        tool_list: Optional[List[str]] = None,
-        tool_choice: Optional[str] = None,
-        debug_label: str = "execution",
-        stream_tokens: bool = True,
-    ):
+    def _execute_llm_call(self, system_prompt: str, messages: List[Dict] = None, task_id: Optional[str] = None):
         """
         执行LLM调用并分发事件
         
@@ -677,8 +629,7 @@ class AgentExecutor:
             system_prompt=system_prompt
         ))
         
-        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(
+        execution_tool_choice = self.llm_client.resolve_tool_choice(
             category="execution",
             model=self.execution_model,
         )
@@ -688,27 +639,26 @@ class AgentExecutor:
             history=messages,
             model=self.execution_model,
             system_prompt=system_prompt,
-            tool_list=effective_tool_list,
+            tool_list=self.available_tools,
             tool_choice=execution_tool_choice,
             max_tokens=max_tokens_override,
             emit_tokens="token",  # 主 Agent 调用：流式发送 content token
             debug_task_id=task_id,
-            debug_label=debug_label,
+            debug_label="execution",
             stream_callback=self._build_llm_stream_callback(
                 stream_group="llm",
                 agent_name=self.agent_name,
                 model=self.execution_model,
-            ) if self.stream_llm_tokens and stream_tokens else None,
+            ) if self.stream_llm_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,
@@ -720,6 +670,7 @@ 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, 
@@ -727,84 +678,111 @@ 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 _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)
+    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")
 
-    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}"
-        )
+        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,
+                )
 
-    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'
-        ))
+            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
+
+            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()
+
+        return system_prompt, messages
 
     def _execute_tool_call(self, tool_call: Dict, task_id: str, user_input: str, turn: int,
                           assistant_content: str = "", reasoning_content: str = "",
@@ -1024,17 +1002,8 @@ class AgentExecutor:
 
         # 重新读取运行时参数
         runtime = get_runtime_settings()
-        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.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.fresh_enabled = runtime.get("fresh_enabled", False)
         self.fresh_interval_sec = runtime.get("fresh_interval_sec", 0)
         self.last_fresh_at = time.time()
@@ -1044,8 +1013,6 @@ 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()
@@ -1240,10 +1207,12 @@ 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, 
@@ -1252,6 +1221,8 @@ 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
             ))
@@ -1277,17 +1248,6 @@ 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 "")
@@ -1298,7 +1258,6 @@ class AgentExecutor:
                     "model": current_model,
                     "text": text,
                     "token_kind": kind,
-                    "attempt": attempt,
                     "is_initial": bool(is_initial),
                     "is_forced": bool(is_forced),
                 }
@@ -1309,7 +1268,6 @@ class AgentExecutor:
                     "model": current_model,
                     "text": text,
                     "token_kind": kind,
-                    "attempt": attempt,
                 }
             self._emit_sdk_stream_event(event_type, payload)
 
@@ -1318,8 +1276,7 @@ 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 [])
-        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_execution = execution_traces[-1] if execution_traces else None
         last_thinking = thinking_traces[-1] if thinking_traces else None
         return {
             "execution_turns": execution_traces,