agentengine-sdk-python 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/tools/gateway.py

@@ -1,19 +1,28 @@
 from __future__ import annotations
 
-import os
 import hashlib
 import json
+import os
 import shlex
 from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any
 from uuid import uuid4
 
+from ksadk.runtime_context import get_current_invocation_context
+
 
 @dataclass(frozen=True)
 class ToolPolicy:
     risk_level: str = "low"
     side_effects: Sequence[str] = field(default_factory=tuple)
+    # Approval scopes classify operations which might need an interactive
+    # decision. ``public_network`` is intentionally a read-only exception:
+    # web discovery must remain available in every approval profile.
+    approval_scopes: Sequence[str] = field(default_factory=tuple)
+    # Use only for tools whose operation is inherently safe to run without a
+    # human decision. This wins over a risk level or explicit legacy policy.
+    approval_exempt: bool = False
     requires_approval: bool | None = None
 
 
@@ -50,8 +59,9 @@ class ToolGateway:
 
     @staticmethod
     def _approval_mode() -> str:
-        value = os.environ.get("KSADK_TOOL_APPROVAL_MODE", "").strip().lower()
-        return value or "off"
+        context = get_current_invocation_context()
+        requested_mode = context.tool_approval_mode if context is not None else None
+        return normalize_tool_approval_mode(requested_mode)
 
     @staticmethod
     def _is_approved(approval: Mapping[str, Any] | None) -> bool:
@@ -108,24 +118,76 @@ def tool_policy_requires_approval(
     *,
     approval_mode: str | None = None,
 ) -> bool:
-    mode = (approval_mode or os.environ.get("KSADK_TOOL_APPROVAL_MODE", "")).strip().lower() or "off"
+    mode = normalize_tool_approval_mode(approval_mode)
+    if policy.approval_exempt or _is_read_only_public_network_policy(policy):
+        return False
     if policy.requires_approval is not None:
-        return policy.requires_approval and mode != "off"
-    if mode != "strict":
+        return policy.requires_approval and mode != "full"
+    if mode == "full":
         return False
+    if mode == "ask" and policy.approval_scopes:
+        return True
     return policy.risk_level.lower() in {"medium", "high", "critical"}
 
 
+def _is_read_only_public_network_policy(policy: ToolPolicy) -> bool:
+    """Keep public web reads available even under the most cautious profile.
+
+    A network write must declare a side effect, so it does not match this
+    exemption and can still require approval.
+    """
+    return bool(policy.approval_scopes) and set(policy.approval_scopes) <= {
+        "public_network"
+    } and not policy.side_effects
+
+
+def normalize_tool_approval_mode(value: str | None = None) -> str:
+    """Resolve the compact runtime approval profile.
+
+    ``ask`` confirms risky and non-network scoped operations; ``risk``
+    confirms medium-and-higher risk only; ``full`` leaves default policies
+    unprompted. Public web reads remain approval-free in every profile. The
+    process environment remains a default for non-UI callers, while a
+    request-scoped mode wins for the duration of that invocation.
+    """
+    raw = str(value or os.environ.get("KSADK_TOOL_APPROVAL_MODE", "risk")).strip().lower()
+    return raw if raw in {"ask", "risk", "full"} else "risk"
+
+
+def tool_approval_capability() -> dict[str, Any]:
+    """Describe the single profile interface exposed to hosted UIs."""
+    return {
+        "Modes": ["ask", "risk", "full"],
+        "DefaultMode": normalize_tool_approval_mode(),
+        "RuntimeOverride": True,
+    }
+
+
 def check_command_policy(command: str) -> dict[str, Any]:
     text = str(command or "").strip()
     if not text:
-        return {"ok": False, "decision": "reject", "error_type": "command_required", "error_message": "command is required"}
+        return {
+            "ok": False,
+            "decision": "reject",
+            "error_type": "command_required",
+            "error_message": "command is required",
+        }
     try:
         tokens = shlex.split(text)
     except ValueError as exc:
-        return {"ok": False, "decision": "reject", "error_type": "invalid_command", "error_message": str(exc)}
+        return {
+            "ok": False,
+            "decision": "reject",
+            "error_type": "invalid_command",
+            "error_message": str(exc),
+        }
     if not tokens:
-        return {"ok": False, "decision": "reject", "error_type": "command_required", "error_message": "command is required"}
+        return {
+            "ok": False,
+            "decision": "reject",
+            "error_type": "command_required",
+            "error_message": "command is required",
+        }
     if _contains_recursive_rm(tokens):
         return _command_rejected("recursive rm is not allowed without explicit approval")
     if any(token in _DANGEROUS_COMMAND_TOKENS for token in tokens):
@@ -137,12 +199,19 @@ def check_command_policy(command: str) -> dict[str, Any]:
         if subcommand in _DANGEROUS_GIT_COMMANDS:
             return _command_rejected(f"git {subcommand} is not allowed without explicit approval")
     if _references_metadata_endpoint(tokens):
-        return _command_rejected("metadata/private endpoint access is not allowed by default policy")
+        return _command_rejected(
+            "metadata/private endpoint access is not allowed by default policy"
+        )
     return {"ok": True, "decision": "allow", "reason": "default_allow"}
 
 
 def _command_rejected(message: str) -> dict[str, Any]:
-    return {"ok": False, "decision": "reject", "error_type": "command_rejected", "error_message": message}
+    return {
+        "ok": False,
+        "decision": "reject",
+        "error_type": "command_rejected",
+        "error_message": message,
+    }
 
 
 def _contains_recursive_rm(tokens: Sequence[str]) -> bool:
@@ -162,7 +231,9 @@ def _references_metadata_endpoint(tokens: Sequence[str]) -> bool:
 
 def _canonical_tool_args(tool_args: Any) -> str:
     try:
-        return json.dumps(tool_args or {}, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        return json.dumps(
+            tool_args or {}, ensure_ascii=False, sort_keys=True, separators=(",", ":")
+        )
     except TypeError:
         return json.dumps(str(tool_args), ensure_ascii=False, separators=(",", ":"))
 
@@ -185,7 +256,9 @@ def build_tool_receipt_idempotency_key(
         "tool_args": _canonical_tool_args(tool_args),
     }
     digest = hashlib.sha256(
-        json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
+        json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode(
+            "utf-8"
+        )
     ).hexdigest()
     return f"tool_receipt:{digest}"
 
@@ -222,8 +295,12 @@ def approval_interrupt_info_from_result(
             or {}
         ),
         "risk_level": str(approval_request.get("risk_level") or result.get("risk_level") or ""),
-        "side_effects": list(approval_request.get("side_effects") or result.get("side_effects") or []),
-        "server_label": str(approval_request.get("server_label") or result.get("server_label") or "ksadk"),
+        "side_effects": list(
+            approval_request.get("side_effects") or result.get("side_effects") or []
+        ),
+        "server_label": str(
+            approval_request.get("server_label") or result.get("server_label") or "ksadk"
+        ),
     }
     if run_id:
         interrupt["run_id"] = str(run_id)

ksadk/tools/result_budget.py

@@ -10,7 +10,6 @@ from uuid import uuid4
 
 from ksadk.sessions.local_service import resolve_local_session_dir
 
-
 _SAFE_NAME_RE = re.compile(r"[^A-Za-z0-9_.-]+")
 
 
@@ -58,7 +57,10 @@ def budget_tool_output(
     active_budget = budget or default_tool_result_budget()
     text, mime_type, extension = _stringify_value(value)
     original_chars = len(text)
-    should_persist = original_chars > active_budget.persist_threshold_chars or original_chars > active_budget.max_chars
+    should_persist = (
+        original_chars > active_budget.persist_threshold_chars
+        or original_chars > active_budget.max_chars
+    )
     preview_limit = max(0, min(active_budget.preview_chars, active_budget.max_chars))
     preview = text[:preview_limit] if should_persist else text[: active_budget.max_chars]
     result: dict[str, Any] = {
@@ -126,7 +128,9 @@ def _persist_tool_output(
         or metadata.get("id")
         or uuid4().hex
     )
-    stem = _safe_filename(f"{tool_use_id}.{field_name}") or _safe_filename(f"{tool_name}.{field_name}.{uuid4().hex}")
+    stem = _safe_filename(f"{tool_use_id}.{field_name}") or _safe_filename(
+        f"{tool_name}.{field_name}.{uuid4().hex}"
+    )
     path = (persist_dir / f"{stem}.{extension}").resolve()
     if persist_dir not in path.parents and path != persist_dir:
         raise ValueError("tool result path must stay inside persist_dir")
@@ -137,7 +141,11 @@ def _persist_tool_output(
 def _stringify_value(value: Any) -> tuple[str, str, str]:
     if isinstance(value, str):
         return value, "text/plain", "txt"
-    return json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True), "application/json", "json"
+    return (
+        json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True),
+        "application/json",
+        "json",
+    )
 
 
 def _safe_filename(value: str) -> str:

ksadk/toolsets/__init__.py

@@ -3,34 +3,36 @@ from __future__ import annotations
 import json
 import os
 import re
-from collections.abc import Iterable
-from collections.abc import Mapping
+from collections.abc import Callable, Iterable, Mapping
 from typing import Any
 
-from ksadk.toolsets.platform import get_platform_tools
-from ksadk.toolsets.platform import component_status
-from ksadk.toolsets.sandbox import get_sandbox_tools
+from ksadk.tools.gateway import ToolPolicy, tool_policy_requires_approval
+from ksadk.toolsets._langchain import as_tool
+from ksadk.toolsets.platform import component_status, get_platform_tools
 from ksadk.toolsets.sandbox import (
     _SANDBOX_TOOL_POLICIES,
+    get_sandbox_tools,
     run_code,
     run_command,
     sandbox_backend_name,
     sandbox_status,
 )
-from ksadk.toolsets.skills import get_skill_tools
 from ksadk.toolsets.skills import (
     _SKILL_TOOL_POLICIES,
     _skill_execution_backend,
     execute_skills,
+    get_skill_tools,
+    list_skill_spaces,
     list_skills,
     load_skill,
     search_skills,
 )
-from ksadk.toolsets.workspace import get_workspace_tools
+from ksadk.toolsets.web import _WEB_TOOL_POLICIES, get_web_tools, web_fetch, web_search
 from ksadk.toolsets.workspace import (
     _WORKSPACE_TOOL_POLICIES,
     delete_workspace_file,
     edit_workspace_file,
+    get_workspace_tools,
     lint_workspace_file,
     list_workspace_files,
     multi_edit_workspace_file,
@@ -40,10 +42,6 @@ from ksadk.toolsets.workspace import (
     write_workspace_file,
     write_workspace_files,
 )
-from ksadk.toolsets.web import get_web_tools
-from ksadk.toolsets.web import web_fetch, web_search, _WEB_TOOL_POLICIES
-from ksadk.tools.gateway import ToolPolicy, tool_policy_requires_approval
-from ksadk.toolsets._langchain import as_tool
 
 _DEFAULT_GROUPS = ("skill", "workspace", "platform", "sandbox", "web")
 _DISPATCHER_TOOL_NAME = "tool_dispatcher"
@@ -79,9 +77,12 @@ _TOOLSET_FACTORIES = {
     "web": get_web_tools,
 }
 
-_TOOLSET_DESCRIPTORS = {
+_TOOLSET_DESCRIPTORS: dict[
+    str, tuple[tuple[Callable[..., Any], ToolPolicy, dict[str, Any]], ...]
+] = {
     "skill": (
         (list_skills, _SKILL_TOOL_POLICIES["list_skills"], {}),
+        (list_skill_spaces, _SKILL_TOOL_POLICIES["list_skill_spaces"], {}),
         (search_skills, _SKILL_TOOL_POLICIES["search_skills"], {}),
         (load_skill, _SKILL_TOOL_POLICIES["load_skill"], {}),
         (
@@ -95,20 +96,58 @@ _TOOLSET_DESCRIPTORS = {
         ),
     ),
     "workspace": (
-        (workspace_status, _WORKSPACE_TOOL_POLICIES["workspace_status"], {"boundary": "workspace_root"}),
-        (list_workspace_files, _WORKSPACE_TOOL_POLICIES["list_workspace_files"], {"boundary": "workspace_root"}),
-        (read_workspace_file, _WORKSPACE_TOOL_POLICIES["read_workspace_file"], {"boundary": "workspace_root"}),
-        (write_workspace_file, _WORKSPACE_TOOL_POLICIES["write_workspace_file"], {"boundary": "workspace_root"}),
-        (write_workspace_files, _WORKSPACE_TOOL_POLICIES["write_workspace_files"], {"boundary": "workspace_root"}),
-        (edit_workspace_file, _WORKSPACE_TOOL_POLICIES["edit_workspace_file"], {"boundary": "workspace_root"}),
-        (multi_edit_workspace_file, _WORKSPACE_TOOL_POLICIES["multi_edit_workspace_file"], {"boundary": "workspace_root"}),
-        (lint_workspace_file, _WORKSPACE_TOOL_POLICIES["lint_workspace_file"], {"boundary": "workspace_root"}),
-        (search_workspace_files, _WORKSPACE_TOOL_POLICIES["search_workspace_files"], {"boundary": "workspace_root"}),
-        (delete_workspace_file, _WORKSPACE_TOOL_POLICIES["delete_workspace_file"], {"boundary": "workspace_root"}),
-    ),
-    "platform": (
-        (component_status, ToolPolicy(risk_level="low"), {}),
+        (
+            workspace_status,
+            _WORKSPACE_TOOL_POLICIES["workspace_status"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            list_workspace_files,
+            _WORKSPACE_TOOL_POLICIES["list_workspace_files"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            read_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["read_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            write_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["write_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            write_workspace_files,
+            _WORKSPACE_TOOL_POLICIES["write_workspace_files"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            edit_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["edit_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            multi_edit_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["multi_edit_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            lint_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["lint_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            search_workspace_files,
+            _WORKSPACE_TOOL_POLICIES["search_workspace_files"],
+            {"boundary": "workspace_root"},
+        ),
+        (
+            delete_workspace_file,
+            _WORKSPACE_TOOL_POLICIES["delete_workspace_file"],
+            {"boundary": "workspace_root"},
+        ),
     ),
+    "platform": ((component_status, ToolPolicy(risk_level="low"), {}),),
     "sandbox": (
         (
             sandbox_status,
@@ -218,9 +257,38 @@ def tool_dispatcher(
     include: str | Iterable[str] | None = None,
     profile: str = "default",
 ) -> dict[str, Any]:
-    """List, describe, or call ksadk built-in tools through one governed entrypoint."""
+    """List, describe, or call ksadk built-in tools through one governed entrypoint.
+
+    Args:
+        action: One of "list" (list available tools), "describe" (get a tool's
+            spec), or "call" (execute a tool). Common synonyms "call_tool",
+            "execute", "run" are auto-mapped to "call"; "get" to "describe".
+        tool_name: Required for "describe" and "call"; ignored for "list".
+        arguments: Tool arguments (dict or JSON string); used with "call".
+        include: Comma-separated tool groups to scope (e.g. "skill,sandbox").
+        profile: Tool profile name (default: "default").
+    """
 
     normalized_action = str(action or "").strip().lower()
+    # 兼容 LLM 常见同义词,避免 "call_tool"/"execute"/"run" 等导致 unknown_action。
+    _ACTION_SYNONYMS = {
+        "call_tool": "call",
+        "execute": "call",
+        "run": "call",
+        "invoke": "call",
+        "get": "describe",
+        "info": "describe",
+        "ls": "list",
+        "search": "list",
+    }
+    normalized_action = _ACTION_SYNONYMS.get(normalized_action, normalized_action)
+    # LLM 常把 tool_name 塞进 action(如 "list_skills"/"search_skills"/"run_command")。
+    # 如果 action 不是合法值,无论 tool_name 是否有值,都自动当成 "call":
+    # 有 tool_name → 直接 call; 无 tool_name → 把 action 值当 tool_name 再 call。
+    if normalized_action not in ("list", "describe", "call"):
+        if not tool_name:
+            tool_name = normalized_action
+        normalized_action = "call"
     requested_include = _normalize_include(include)
 
     if normalized_action == "list":
@@ -231,17 +299,25 @@ def tool_dispatcher(
                 include_dispatcher=False,
             )
         except ValueError:
-            return _unknown_tool_error(", ".join(requested_include) if requested_include else str(include or ""))
+            return _unknown_tool_error(
+                ", ".join(requested_include) if requested_include else str(include or "")
+            )
         return {"ok": True, "tools": specs, "tool_count": len(specs)}
 
     if normalized_action == "describe":
         target_name = _normalize_tool_name(tool_name)
         if not target_name:
-            return {"ok": False, "error_type": "missing_tool_name", "error_message": "tool_name is required"}
+            return {
+                "ok": False,
+                "error_type": "missing_tool_name",
+                "error_message": "tool_name is required",
+            }
         if target_name in {_DISPATCHER_TOOL_NAME, _LEGACY_DISPATCHER_TOOL_NAME}:
             return _dispatcher_self_call_error()
         try:
-            _, specs = _select_agentengine_tools(include=[target_name], profile=profile, include_dispatcher=False)
+            _, specs = _select_agentengine_tools(
+                include=[target_name], profile=profile, include_dispatcher=False
+            )
         except ValueError:
             return _unknown_tool_error(target_name)
         return {"ok": True, "tool": specs[0]}
@@ -249,15 +325,26 @@ def tool_dispatcher(
     if normalized_action == "call":
         target_name = _normalize_tool_name(tool_name)
         if not target_name:
-            return {"ok": False, "error_type": "missing_tool_name", "error_message": "tool_name is required"}
+            return {
+                "ok": False,
+                "error_type": "missing_tool_name",
+                "error_message": "tool_name is required",
+            }
         if target_name in {_DISPATCHER_TOOL_NAME, _LEGACY_DISPATCHER_TOOL_NAME}:
             return _dispatcher_self_call_error()
         try:
-            tools, specs = _select_agentengine_tools(include=[target_name], profile=profile, include_dispatcher=False)
+            tools, specs = _select_agentengine_tools(
+                include=[target_name], profile=profile, include_dispatcher=False
+            )
         except ValueError:
             return _unknown_tool_error(target_name)
         if specs and specs[0].get("enabled") is False:
-            return {"ok": False, "error_type": "tool_disabled", "error_message": f"Tool is disabled: {target_name}", "tool_name": target_name}
+            return {
+                "ok": False,
+                "error_type": "tool_disabled",
+                "error_message": f"Tool is disabled: {target_name}",
+                "tool_name": target_name,
+            }
         tool_arguments, arguments_error = _normalize_tool_arguments(arguments)
         if arguments_error:
             return arguments_error
@@ -429,7 +516,9 @@ def _expand_requested_names(requested: list[str], tool_registry: Mapping[str, An
     return names
 
 
-def _expand_requested_descriptor_names(requested: list[str], descriptor_registry: Mapping[str, Any]) -> list[str]:
+def _expand_requested_descriptor_names(
+    requested: list[str], descriptor_registry: Mapping[str, Any]
+) -> list[str]:
     names: list[str] = []
     for name in requested:
         canonical_name = _canonical_toolset_group(name)
@@ -560,7 +649,9 @@ def _normalize_tool_name(tool_name: str | None) -> str:
     return str(tool_name or "").strip()
 
 
-def _normalize_tool_arguments(arguments: dict[str, Any] | str | None) -> tuple[dict[str, Any], dict[str, Any] | None]:
+def _normalize_tool_arguments(
+    arguments: dict[str, Any] | str | None,
+) -> tuple[dict[str, Any], dict[str, Any] | None]:
     if arguments is None:
         return {}, None
     if isinstance(arguments, dict):
@@ -594,7 +685,9 @@ def _normalize_tool_arguments(arguments: dict[str, Any] | str | None) -> tuple[d
     }
 
 
-def _normalize_dispatched_tool_arguments(tool_name: str, arguments: dict[str, Any]) -> dict[str, Any]:
+def _normalize_dispatched_tool_arguments(
+    tool_name: str, arguments: dict[str, Any]
+) -> dict[str, Any]:
     if tool_name == "save_memory" and "content" not in arguments:
         if "key" in arguments and "value" in arguments:
             return {"content": f"{arguments['key']}: {_stringify_memory_value(arguments['value'])}"}
@@ -819,13 +912,18 @@ def _tool_spec(
         "risk_level": policy.risk_level,
         "requires_approval": tool_policy_requires_approval(policy),
         "side_effects": list(policy.side_effects),
+        "approval_scopes": list(policy.approval_scopes),
+        "approval_exempt": policy.approval_exempt,
         "enabled": True,
     }
     for key, value in dict(extras or {}).items():
         spec[key] = value() if callable(value) else value
     enabled = bool(spec.get("enabled", True))
     if name == "web_search":
-        enabled = bool(os.environ.get("KSADK_WEB_SEARCH_PROVIDER") or os.environ.get("OPENCLAW_WEB_SEARCH_PROVIDER"))
+        enabled = bool(
+            os.environ.get("KSADK_WEB_SEARCH_PROVIDER")
+            or os.environ.get("OPENCLAW_WEB_SEARCH_PROVIDER")
+        )
     if name in {"run_command", "run_code", "sandbox_status"}:
         enabled = enabled and _enabled_backend(sandbox_backend_name())
     spec["enabled"] = enabled

ksadk/toolsets/platform.py

@@ -34,8 +34,16 @@ def component_status() -> dict:
             "knowledge_base_bound": bool(_env("KSADK_KB_DATASET_ID")),
             "long_term_memory_bound": bool(_env("KSADK_LTM_NAMESPACE")),
             "skill_space_bound": bool(spaces),
-            "isolated_execution": "enabled" if skill_runtime_backend not in {"", "disabled", "none", "off"} else "not_enabled",
-            "sandbox_direct_tools": "enabled" if sandbox_backend not in {"", "disabled", "none", "off"} else "not_enabled",
+            "isolated_execution": (
+                "enabled"
+                if skill_runtime_backend not in {"", "disabled", "none", "off"}
+                else "not_enabled"
+            ),
+            "sandbox_direct_tools": (
+                "enabled"
+                if sandbox_backend not in {"", "disabled", "none", "off"}
+                else "not_enabled"
+            ),
         },
         "skill_space": {
             "space_ids": spaces,
@@ -48,13 +56,17 @@ def component_status() -> dict:
         "skill_runtime": {
             "backend": skill_runtime_backend,
             "enabled": skill_runtime_backend not in {"", "disabled", "none", "off"},
-            "template_bound": bool(_env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")),
+            "template_bound": bool(
+                _env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")
+            ),
             "request_protocol": "--request-file JSON envelope",
         },
         "sandbox": {
             "backend": sandbox_backend,
             "enabled": sandbox_backend not in {"", "disabled", "none", "off"},
-            "template_bound": bool(_env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")),
+            "template_bound": bool(
+                _env("KSADK_SANDBOX_TEMPLATE_ID") or _env("KSADK_SKILL_RUNTIME_TEMPLATE_ID")
+            ),
             "tools": ["sandbox_status", "run_command", "run_code"],
         },
         "workspace": {
@@ -71,7 +83,11 @@ def component_status() -> dict:
                 "delete_workspace_file",
             ],
             "boundary": "Workspace tools are confined to the AgentEngine UI workspace directory.",
-            "editing_model": "write tools support whole-file writes; edit_workspace_file supports exact snippet replacement; lint_workspace_file provides lightweight built-in checks.",
+            "editing_model": (
+                "write tools support whole-file writes; edit_workspace_file supports "
+                "exact snippet replacement; lint_workspace_file provides lightweight "
+                "built-in checks."
+            ),
         },
     }