infiagent 3.2.4__tar.gz → 3.2.6__tar.gz

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

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

@@ -56,17 +56,24 @@ class ContextBuilder:
     def _resolve_compressor_tool_choice(self, model: str) -> str:
         return self.llm_client.resolve_tool_choice("compressor", model)
 
-    def _build_task_system_add(self, task_id: str) -> str:
+    def _build_task_system_add(self, task_id: str, agent_name: str) -> str:
         try:
-            system_add_path = Path(task_id) / "system-add.md"
-            if not system_add_path.exists():
-                return ""
-            content = system_add_path.read_text(encoding="utf-8").strip()
-            if not content:
-                return ""
-            return f"<任务级补充系统提示>\n{content}\n</任务级补充系统提示>"
+            task_dir = Path(task_id)
+            candidate_paths = []
+            if agent_name:
+                candidate_paths.append(task_dir / f"system-add.{agent_name}.md")
+            candidate_paths.append(task_dir / "system-add.md")
+
+            for system_add_path in candidate_paths:
+                if not system_add_path.exists():
+                    continue
+                content = system_add_path.read_text(encoding="utf-8").strip()
+                if not content:
+                    continue
+                return f"<任务级补充系统提示>\n{content}\n</任务级补充系统提示>"
         except Exception:
             return ""
+        return ""
 
     def _count_tokens(self, text: str) -> int:
         text = str(text or "")
@@ -105,7 +112,7 @@ class ContextBuilder:
         
         # 1️⃣ 读取通用系统提示词（general_prompts.yaml，包含<智能体经验>）
         general_system_prompt = self._load_general_system_prompt(agent_name)
-        task_system_add = self._build_task_system_add(task_id)
+        task_system_add = self._build_task_system_add(task_id, agent_name)
         
         # 2️⃣ 构建各个动态部分
         user_latest_input = self._build_user_latest_input(current)

{infiagent-3.2.4 → infiagent-3.2.6}/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.6}/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
@@ -85,6 +86,60 @@ def _materialize_inline_llm_config(
     return str(path)
 
 
+def _is_system_add_filename(name: str) -> bool:
+    name = str(name or "").strip()
+    if name == "system-add.md":
+        return True
+    return name.startswith("system-add.") and name.endswith(".md")
+
+
+def _clear_materialized_system_add_files(task_dir: Path) -> None:
+    if not task_dir.exists():
+        return
+    for item in task_dir.iterdir():
+        if item.is_file() and _is_system_add_filename(item.name):
+            item.unlink()
+
+
+def _materialize_system_add(
+    *,
+    task_dir: Path,
+    system_add_path: Optional[str] = None,
+    system_add_content: Optional[str] = None,
+) -> None:
+    if system_add_path and system_add_content is not None:
+        raise ValueError("system_add_path 与 system_add_content 只能二选一")
+
+    task_dir.mkdir(parents=True, exist_ok=True)
+
+    if system_add_path is None and system_add_content is None:
+        return
+
+    _clear_materialized_system_add_files(task_dir)
+
+    if system_add_content is not None:
+        (task_dir / "system-add.md").write_text(str(system_add_content), encoding="utf-8")
+        return
+
+    src = Path(str(system_add_path)).expanduser().resolve()
+    if not src.exists():
+        raise FileNotFoundError(f"system_add_path 不存在: {src}")
+
+    if src.is_dir():
+        candidates = [p for p in sorted(src.iterdir()) if p.is_file() and _is_system_add_filename(p.name)]
+        if not candidates:
+            raise FileNotFoundError(f"system_add_path 目录中未找到 system-add.md 或 system-add.<agent_name>.md: {src}")
+        default_files = [p for p in candidates if p.name == "system-add.md"]
+        if len(default_files) > 1:
+            raise ValueError(f"system_add_path 目录中包含多个 system-add.md: {src}")
+        for file_path in candidates:
+            shutil.copy2(file_path, task_dir / file_path.name)
+        return
+
+    target_name = src.name if _is_system_add_filename(src.name) else "system-add.md"
+    shutil.copy2(src, task_dir / target_name)
+
+
 class InfiAgent:
     def __init__(
         self,
@@ -111,6 +166,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 +232,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 +260,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 +322,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 +387,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 +420,13 @@ 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"
+        _materialize_system_add(
+            task_dir=Path(target_task_id),
+            system_add_path=system_add_path,
+            system_add_content=system_add_content,
+        )
 
         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.6/infiagent.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infiagent
-Version: 3.2.4
+Version: 3.2.6
 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.6-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.6}/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.6",
     author="Chenglin Yu",
     author_email="yuchenglin96@qq.com",
     license="MIT",

{infiagent-3.2.4 → infiagent-3.2.6}/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,58 @@ 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_run_can_materialize_system_add_directory(self):
+        root = (self.base / "system_add_dir_root").resolve()
+        task_id = str((self.base / "system_add_dir_task").resolve())
+        source_dir = (self.base / "system_add_src").resolve()
+        source_dir.mkdir(parents=True, exist_ok=True)
+        (source_dir / "system-add.md").write_text("DEFAULT_MARKER", encoding="utf-8")
+        (source_dir / "system-add.alpha_agent.md").write_text("ALPHA_MARKER", encoding="utf-8")
+        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_path=str(source_dir),
+            )
+
+        self.assertEqual(result["status"], "busy")
+        self.assertEqual((Path(task_id) / "system-add.md").read_text(encoding="utf-8"), "DEFAULT_MARKER")
+        self.assertEqual((Path(task_id) / "system-add.alpha_agent.md").read_text(encoding="utf-8"), "ALPHA_MARKER")
+
+    def test_run_can_materialize_agent_specific_system_add_file(self):
+        root = (self.base / "system_add_file_root").resolve()
+        task_id = str((self.base / "system_add_file_task").resolve())
+        source_file = (self.base / "system-add.alpha_agent.md").resolve()
+        source_file.write_text("ALPHA_ONLY_MARKER", encoding="utf-8")
+        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_path=str(source_file),
+            )
+
+        self.assertEqual(result["status"], "busy")
+        self.assertEqual((Path(task_id) / "system-add.alpha_agent.md").read_text(encoding="utf-8"), "ALPHA_ONLY_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.6}/tests/test_task_history_index.py

@@ -160,6 +160,21 @@ class TaskHistoryIndexTests(unittest.TestCase):
             self.assertEqual(total_count, 3)
             self.assertEqual(selected, [{"c": 3}])
 
+    def test_agent_specific_system_add_takes_precedence_over_default(self):
+        task_id = str((self.root / "task_system_add").resolve())
+        task_dir = Path(task_id)
+        task_dir.mkdir(parents=True, exist_ok=True)
+        (task_dir / "system-add.md").write_text("DEFAULT_SYSTEM_ADD", encoding="utf-8")
+        (task_dir / "system-add.alpha_agent.md").write_text("ALPHA_SYSTEM_ADD", encoding="utf-8")
+
+        with runtime_env_scope({"MLA_USER_DATA_ROOT": str(self.root)}):
+            hierarchy = _DummyHierarchyManager({"history": [], "current": {}, "runtime": {}})
+            builder = ContextBuilder(hierarchy, {}, _DummyConfigLoader(), llm_client=None)
+            content = builder._build_task_system_add(task_id, "alpha_agent")
+
+        self.assertIn("ALPHA_SYSTEM_ADD", content)
+        self.assertNotIn("DEFAULT_SYSTEM_ADD", content)
+
 
 if __name__ == "__main__":
     unittest.main()

{infiagent-3.2.4 → infiagent-3.2.6}/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.6}/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: