infiagent 3.2.4__tar.gz → 3.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infiagent
-Version: 3.2.4
+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.4-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.4 → 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.4-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.4 → infiagent-3.2.5}/core/tool_executor.py

@@ -6,12 +6,13 @@ from utils.windows_compat import safe_print
 """
 
 import json
+import hashlib
 import time
 import uuid
 import asyncio
 import threading
 import os
-from typing import Dict, Any
+from typing import Dict, Any, List
 
 from tool_server_lite.registry import get_runtime_registry, get_runtime_registry_failures
 from utils.mcp_manager import call_mcp_tool
@@ -59,6 +60,7 @@ class ToolExecutor:
         self.agent_id = ""
         self.agent_name = ""
         self.tool_runtime_defaults = self._load_tool_runtime_defaults()
+        self.tool_runtime_defaults_log_mode = self._load_tool_runtime_defaults_log_mode()
 
     def set_agent_context(self, *, agent_id: str = "", agent_name: str = ""):
         self.agent_id = str(agent_id or "")
@@ -96,6 +98,77 @@ class ToolExecutor:
         for key, value in defaults.items():
             merged[str(key)] = value
         return merged
+
+    def _load_tool_runtime_defaults_log_mode(self) -> str:
+        mode = str(os.environ.get("MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE", "fingerprint") or "fingerprint").strip().lower()
+        if mode not in {"plaintext", "redact", "fingerprint"}:
+            return "fingerprint"
+        return mode
+
+    @staticmethod
+    def _fingerprint_runtime_value(value: Any) -> str:
+        try:
+            normalized = json.dumps(value, ensure_ascii=False, sort_keys=True)
+        except Exception:
+            normalized = repr(value)
+        return "sha256:" + hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:12]
+
+    def _hidden_runtime_placeholder(self, key: str, value: Any) -> str:
+        mode = self.tool_runtime_defaults_log_mode
+        if mode == "plaintext":
+            return str(value)
+        if mode == "redact":
+            return f"[RUNTIME_HIDDEN_PARAM:{key}:REDACTED]"
+
+        value_type = type(value).__name__
+        if isinstance(value, str):
+            shape = f"type=str len={len(value)}"
+        elif isinstance(value, (list, tuple, set)):
+            shape = f"type={value_type} size={len(value)}"
+        elif isinstance(value, dict):
+            shape = f"type=dict keys={len(value)}"
+        else:
+            shape = f"type={value_type}"
+        return f"[RUNTIME_HIDDEN_PARAM:{key} {shape} fp={self._fingerprint_runtime_value(value)}]"
+
+    def _sanitize_runtime_tool_arguments(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        defaults = self.tool_runtime_defaults.get(str(tool_name), {})
+        if not defaults:
+            return dict(arguments or {})
+        sanitized = dict(arguments or {})
+        for key, value in defaults.items():
+            if str(key) in sanitized:
+                sanitized[str(key)] = self._hidden_runtime_placeholder(str(key), value)
+        return sanitized
+
+    def _sanitize_runtime_tool_result(self, tool_name: str, result: Dict[str, Any]) -> Dict[str, Any]:
+        defaults = self.tool_runtime_defaults.get(str(tool_name), {})
+        if not defaults:
+            return dict(result or {})
+        if self.tool_runtime_defaults_log_mode == "plaintext":
+            return dict(result or {})
+
+        secret_strings: List[tuple[str, str]] = []
+        for key, value in defaults.items():
+            if isinstance(value, str) and value:
+                secret_strings.append((value, self._hidden_runtime_placeholder(str(key), value)))
+
+        def _walk(obj: Any) -> Any:
+            if isinstance(obj, dict):
+                return {k: _walk(v) for k, v in obj.items()}
+            if isinstance(obj, list):
+                return [_walk(v) for v in obj]
+            if isinstance(obj, tuple):
+                return tuple(_walk(v) for v in obj)
+            if isinstance(obj, str):
+                text = obj
+                for secret, placeholder in secret_strings:
+                    if secret in text:
+                        text = text.replace(secret, placeholder)
+                return text
+            return obj
+
+        return _walk(dict(result or {}))
     
     def _init_tools_registry(self):
         """
@@ -278,12 +351,13 @@ class ToolExecutor:
             执行结果字典
         """
         merged_arguments = self._merge_runtime_tool_defaults(tool_name, arguments)
+        logged_arguments = self._sanitize_runtime_tool_arguments(tool_name, merged_arguments)
         try:
             trigger_tool_hooks(
                 when="before",
                 tool_name=tool_name,
                 task_id=task_id,
-                arguments=merged_arguments,
+                arguments=logged_arguments,
                 agent_id=self.agent_id,
                 agent_name=self.agent_name,
                 agent_level=self._agent_level(),
@@ -335,13 +409,14 @@ class ToolExecutor:
                 "error_information": f"工具执行失败: {str(e)}"
             }
 
+        logged_result = self._sanitize_runtime_tool_result(tool_name, result)
         try:
             trigger_tool_hooks(
                 when="after",
                 tool_name=tool_name,
                 task_id=task_id,
-                arguments=merged_arguments,
-                result=result,
+                arguments=logged_arguments,
+                result=logged_result,
                 agent_id=self.agent_id,
                 agent_name=self.agent_name,
                 agent_level=self._agent_level(),

{infiagent-3.2.4 → infiagent-3.2.5}/infiagent/sdk.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import asyncio
 import json
 import hashlib
+import shutil
 from copy import deepcopy
 from datetime import datetime
 from functools import partial
@@ -111,6 +112,7 @@ class InfiAgent:
         fresh_interval_sec: Optional[int] = None,
         mcp_servers: Optional[List[Dict[str, Any]]] = None,
         tool_runtime_defaults: Optional[Dict[str, Dict[str, Any]]] = None,
+        tool_runtime_defaults_log_mode: str = "fingerprint",
         tool_hooks: Optional[List[Dict[str, Any]]] = None,
         context_hooks: Optional[List[Dict[str, Any]]] = None,
         visible_skills: Optional[List[str]] = None,
@@ -176,6 +178,7 @@ class InfiAgent:
             self.runtime_env_overrides["MLA_MCP_CONFIG_JSON"] = json.dumps({"servers": mcp_servers}, ensure_ascii=False)
         if tool_runtime_defaults is not None:
             self.runtime_env_overrides["MLA_TOOL_RUNTIME_DEFAULTS_JSON"] = json.dumps(tool_runtime_defaults, ensure_ascii=False)
+        self.runtime_env_overrides["MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE"] = str(tool_runtime_defaults_log_mode or "fingerprint").strip().lower() or "fingerprint"
         if tool_hooks is not None:
             self.runtime_env_overrides["MLA_TOOL_HOOKS_JSON"] = json.dumps(tool_hooks, ensure_ascii=False)
         if context_hooks is not None:
@@ -203,6 +206,7 @@ class InfiAgent:
         self.fresh_interval_sec = max(0, int(fresh_interval_sec)) if fresh_interval_sec is not None else None
         self.mcp_servers = mcp_servers
         self.tool_runtime_defaults = tool_runtime_defaults
+        self.tool_runtime_defaults_log_mode = str(tool_runtime_defaults_log_mode or "fingerprint").strip().lower() or "fingerprint"
         self.tool_hooks = tool_hooks
         self.context_hooks = context_hooks
         self.visible_skills = [str(item).strip() for item in visible_skills if str(item).strip()] if visible_skills is not None else None
@@ -264,6 +268,8 @@ class InfiAgent:
             config["mcp_servers"] = self.mcp_servers
         if self.tool_runtime_defaults is not None:
             config["tool_runtime_defaults"] = self.tool_runtime_defaults
+        if self.tool_runtime_defaults_log_mode:
+            config["tool_runtime_defaults_log_mode"] = self.tool_runtime_defaults_log_mode
         if self.tool_hooks is not None:
             config["tool_hooks"] = self.tool_hooks
         if self.context_hooks is not None:
@@ -327,6 +333,9 @@ class InfiAgent:
         user_history_recent_items: Optional[int] = None,
         max_turns: Optional[int] = None,
         tool_runtime_defaults: Optional[Dict[str, Dict[str, Any]]] = None,
+        tool_runtime_defaults_log_mode: Optional[str] = None,
+        system_add_path: Optional[str] = None,
+        system_add_content: Optional[str] = None,
     ) -> Dict[str, Any]:
         target_task_id = self._resolve_task_id(task_id=task_id, workspace=workspace)
         Path(target_task_id).mkdir(parents=True, exist_ok=True)
@@ -357,6 +366,18 @@ class InfiAgent:
             extra_runtime_overrides["MLA_MAX_TURNS"] = str(max(1, int(max_turns)))
         if tool_runtime_defaults is not None:
             extra_runtime_overrides["MLA_TOOL_RUNTIME_DEFAULTS_JSON"] = json.dumps(tool_runtime_defaults, ensure_ascii=False)
+        if tool_runtime_defaults_log_mode is not None:
+            extra_runtime_overrides["MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE"] = str(tool_runtime_defaults_log_mode or "fingerprint").strip().lower() or "fingerprint"
+
+        if system_add_path and system_add_content is not None:
+            raise ValueError("system_add_path 与 system_add_content 只能二选一")
+        if system_add_path:
+            src = Path(system_add_path).expanduser().resolve()
+            if not src.exists():
+                raise FileNotFoundError(f"system_add_path 不存在: {src}")
+            shutil.copy2(src, Path(target_task_id) / "system-add.md")
+        elif system_add_content is not None:
+            (Path(target_task_id) / "system-add.md").write_text(str(system_add_content), encoding="utf-8")
 
         with self._runtime_scope(extra_runtime_overrides or None):
             extra_event_handlers, collected_events = self._build_sdk_event_handler(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infiagent
-Version: 3.2.4
+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.4-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.4 → infiagent-3.2.5}/setup.py

@@ -55,7 +55,7 @@ data_files.extend(_collect_data_files(project_root / "skills", "skills"))
 
 setup(
     name="infiagent",
-    version="3.2.4",
+    version="3.2.5",
     author="Chenglin Yu",
     author_email="yuchenglin96@qq.com",
     license="MIT",

{infiagent-3.2.4 → infiagent-3.2.5}/tests/test_sdk_runtime_paths.py

@@ -261,6 +261,15 @@ class SDKRuntimePathTests(unittest.TestCase):
         self.assertEqual(launch_config["context_hooks"], hooks)
         self.assertTrue(launch_config["seed_builtin_resources"])
 
+    def test_tool_runtime_defaults_log_mode_is_exposed_in_launch_config(self):
+        agent = infiagent(
+            user_data_root=str((self.base / "log_mode_root").resolve()),
+            tool_runtime_defaults={"file_write": {"content": "secret"}},
+            tool_runtime_defaults_log_mode="fingerprint",
+        )
+        launch_config = agent._build_launch_config()
+        self.assertEqual(launch_config["tool_runtime_defaults_log_mode"], "fingerprint")
+
     def test_max_turns_is_exposed_in_launch_config(self):
         agent = infiagent(
             user_data_root=str((self.base / "max_turns_root").resolve()),
@@ -271,6 +280,21 @@ class SDKRuntimePathTests(unittest.TestCase):
         runtime = agent.describe_runtime()
         self.assertEqual(runtime["max_turns"], 321)
 
+    def test_run_can_materialize_system_add_content(self):
+        root = (self.base / "system_add_root").resolve()
+        task_id = str((self.base / "system_add_task").resolve())
+        agent = infiagent(user_data_root=str(root))
+
+        with patch("infiagent.sdk.is_task_running", return_value=True):
+            result = agent.run(
+                "noop",
+                task_id=task_id,
+                system_add_content="SYSTEM_ADD_MARKER",
+            )
+
+        self.assertEqual(result["status"], "busy")
+        self.assertEqual((Path(task_id) / "system-add.md").read_text(encoding="utf-8"), "SYSTEM_ADD_MARKER")
+
     def test_add_message_resume_if_needed_uses_resume_when_stack_exists(self):
         root = (self.base / "resume_root").resolve()
         task_id = str((self.base / "resume_task").resolve())

{infiagent-3.2.4 → infiagent-3.2.5}/tests/test_tool_hooks.py

@@ -77,6 +77,51 @@ class ToolHooksTests(unittest.TestCase):
         self.assertEqual(result["status"], "success")
         self.assertEqual(result["output"], "runtime injected output")
 
+    def test_runtime_tool_defaults_are_redacted_in_hook_payloads(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp = Path(temp_dir)
+            callback_file = temp / "hook_callback.py"
+            sink = temp / "events.jsonl"
+            callback_file.write_text(
+                "\n".join([
+                    "import json",
+                    f"SINK = {str(sink)!r}",
+                    "def on_tool_event(payload):",
+                    "    with open(SINK, 'a', encoding='utf-8') as fh:",
+                    "        fh.write(json.dumps(payload, ensure_ascii=False) + '\\n')",
+                ]),
+                encoding="utf-8",
+            )
+
+            hooks = [{
+                "name": "capture-demo",
+                "when": "after",
+                "tool_names": ["final_output"],
+                "callback": f"{callback_file}:on_tool_event",
+            }]
+            defaults = {
+                "final_output": {
+                    "output": "SECRET_TOKEN_ABC123",
+                }
+            }
+            root = temp / "root"
+            task_id = str((temp / "task").resolve())
+            with runtime_env_scope({
+                "MLA_USER_DATA_ROOT": str(root),
+                "MLA_TOOL_HOOKS_JSON": json.dumps(hooks, ensure_ascii=False),
+                "MLA_TOOL_RUNTIME_DEFAULTS_JSON": json.dumps(defaults, ensure_ascii=False),
+                "MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE": "fingerprint",
+            }):
+                executor = ToolExecutor(ConfigLoader("OpenCowork"), get_hierarchy_manager(task_id))
+                executor.set_agent_context(agent_id="agent_demo", agent_name="alpha_agent")
+                result = executor.execute("final_output", {"status": "success"}, task_id)
+
+            self.assertEqual(result["status"], "success")
+            payload = json.loads(sink.read_text(encoding="utf-8").strip())
+            payload_text = json.dumps(payload, ensure_ascii=False)
+            self.assertNotIn("SECRET_TOKEN_ABC123", payload_text)
+            self.assertIn("RUNTIME_HIDDEN_PARAM:output", payload_text)
+
 
 if __name__ == "__main__":
     unittest.main()

{infiagent-3.2.4 → infiagent-3.2.5}/utils/task_runtime.py

@@ -184,6 +184,10 @@ def _build_launch_config_from_env_overrides(env_overrides: Optional[Dict[str, An
         except Exception:
             pass
 
+    log_mode = str(overrides.get("MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE") or "").strip().lower()
+    if log_mode:
+        config["tool_runtime_defaults_log_mode"] = log_mode
+
     return config
 
 
@@ -561,6 +565,8 @@ def launch_task_process(
             env["MLA_MCP_CONFIG_JSON"] = json.dumps({"servers": config["mcp_servers"]}, ensure_ascii=False)
         if config.get("tool_runtime_defaults") is not None:
             env["MLA_TOOL_RUNTIME_DEFAULTS_JSON"] = json.dumps(config["tool_runtime_defaults"], ensure_ascii=False)
+        if config.get("tool_runtime_defaults_log_mode") is not None:
+            env["MLA_TOOL_RUNTIME_DEFAULTS_LOG_MODE"] = str(config["tool_runtime_defaults_log_mode"]).strip().lower()
         if config.get("tool_hooks") is not None:
             env["MLA_TOOL_HOOKS_JSON"] = json.dumps(config["tool_hooks"], ensure_ascii=False)
         if config.get("context_hooks") is not None: