langchain-agentx-python 0.5.3__tar.gz → 0.6.0__tar.gz

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 0.5.3
+Version: 0.6.0
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "0.5.3"
+__version__ = "0.6.0"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/loop/config/agent_loop_config.py

@@ -54,7 +54,9 @@ class AgentLoopConfig:
     prompt_handler: Any | None = None  # L3 PermissionPromptHandler
     workspace_root: str | None = None  # 工具层 workspace 根路径，权限检查边界
     agent_home: str = ".langchain_agentx"  # Agent 家目录（skills/worktrees/tasks 派生根）
-    cwd: str | None = None  # 当前工作目录，路径展开基准，可被子代理覆盖（CC 对照：getCwd()）
+    cwd: str | None = None  # 过渡期保留；路径展开应走 boundary_view.resolve_cwd()
+    boundary: Any | None = None  # WorkspaceBoundary frozen 实例
+    enable_dynamic_root_grant: bool = False  # workflow 默认关；CLI 入口默认开
 
     # 会话标识
     session_id: str = ""

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/loop/graph/factory.py

@@ -185,6 +185,8 @@ class LoopGraphBuilder:
         managed_rules: str | None = None,
         active_files_getter: "Callable[[], list[str]] | None" = None,
         workspace_root: str | Path | None = None,
+        read_roots: list[str | Path] | None = None,
+        write_roots: list[str | Path] | None = None,
         agent_home: str = ".langchain_agentx",
         workspace_trust_accepted: bool | None = None,
         raw_hooks: "HookRegistry | None" = None,
@@ -192,6 +194,7 @@ class LoopGraphBuilder:
         capabilities: "RuntimeCapabilities | None" = None,
         enable_git_snapshot: bool | None = None,
         include_default_session_context: bool = True,
+        enable_dynamic_root_grant: bool = False,
     ) -> None:
         self._raw_model = model
         self._raw_system_prompt = system_prompt
@@ -227,6 +230,8 @@ class LoopGraphBuilder:
         self._raw_managed_rules = managed_rules
         self._raw_active_files_getter = active_files_getter
         self._raw_workspace_root = workspace_root
+        self._raw_read_roots = list(read_roots) if read_roots else None
+        self._raw_write_roots = list(write_roots) if write_roots else None
         self._raw_agent_home = agent_home
         self._raw_workspace_trust_accepted = workspace_trust_accepted
         self._raw_hooks = raw_hooks
@@ -234,6 +239,7 @@ class LoopGraphBuilder:
         self._raw_capabilities = capabilities
         self._raw_enable_git_snapshot = enable_git_snapshot
         self._raw_include_default_session_context = include_default_session_context
+        self._raw_enable_dynamic_root_grant = enable_dynamic_root_grant
 
         self._prepared = False
 
@@ -251,8 +257,13 @@ class LoopGraphBuilder:
         base_prompt = self._resolve_base_prompt()
         self._dynamic_sections: list[SystemPromptSection] = list(self._raw_dynamic_sections)
         append_system_prompt = self._raw_append_system_prompt
-        self._setup_loader_tools()
         self._resolve_workspace_config()
+        self._setup_loader_tools()
+        if session_store is not None and hasattr(session_store, "configure_root_grant"):
+            session_store.configure_root_grant(
+                enabled=self._raw_enable_dynamic_root_grant,
+                boundary=self._workspace_boundary,
+            )
         if self._raw_capabilities is None:
             from ...workspace import RuntimeCapabilities as _Caps
 
@@ -352,7 +363,8 @@ class LoopGraphBuilder:
             ),
             workspace_root=self._workspace_root,
             agent_home=self._agent_home,
-            cwd=self._workspace_root,
+            boundary=self._workspace_boundary,
+            enable_dynamic_root_grant=self._raw_enable_dynamic_root_grant,
             subagent_type=self._raw_subagent_type,
             trace_enabled=self._raw_enable_trace,
             model_profile_registry=self._model_profile_registry,
@@ -513,9 +525,18 @@ class LoopGraphBuilder:
     def _setup_loader_tools(self) -> None:
         self._loader_tools = []
         self._skill_runtime_tool = None
+        self._loop_loader = None
         if self._raw_loader is not None:
-            self._loader_tools = self._raw_loader._registry.to_langchain_tools()
-            for rt in self._raw_loader._registry.list():
+            self._loop_loader = self._raw_loader.spawn_loop_loader(
+                workspace_root=self._workspace_root,
+                agent_home=self._agent_home,
+            )
+            self._loop_loader.register_default_tools()
+            for tool in self._raw_loader.registry.list():
+                if tool.name not in self._loop_loader.registry._tools:
+                    self._loop_loader.register(tool)
+            self._loader_tools = self._loop_loader.registry.to_langchain_tools()
+            for rt in self._loop_loader.registry.list():
                 if self._skill_runtime_tool is None and rt.__class__.__name__ == "SkillRuntimeTool":
                     self._skill_runtime_tool = rt
 
@@ -532,6 +553,13 @@ class LoopGraphBuilder:
         self._workspace_cfg = workspace_cfg
         self._workspace_root = str(workspace_cfg.workspace_root)
         self._agent_home = workspace_cfg.agent_home
+        from langchain_agentx.workspace import WorkspaceBoundary
+
+        self._workspace_boundary = WorkspaceBoundary.build(
+            workspace_root=self._workspace_root,
+            read_roots=self._raw_read_roots,
+            write_roots=self._raw_write_roots,
+        )
 
     @staticmethod
     def _run_coro_sync(coro: Any) -> Any:
@@ -1310,7 +1338,12 @@ class LoopGraphBuilder:
             if "configurable" not in config:
                 config["configurable"] = {}
             config["configurable"]["tool_loader"] = self._raw_loader
-            config["configurable"]["tool_registry"] = self._raw_loader.registry
+            registry = (
+                self._loop_loader.registry
+                if self._loop_loader is not None
+                else self._raw_loader.registry
+            )
+            config["configurable"]["tool_registry"] = registry
         compiled = graph.compile(
             debug=self._debug,
             name=self._name,
@@ -1400,6 +1433,8 @@ def create_loop_agent(
     managed_rules: str | None = None,
     active_files_getter: "Callable[[], list[str]] | None" = None,
     workspace_root: str | Path | None = None,
+    read_roots: list[str | Path] | None = None,
+    write_roots: list[str | Path] | None = None,
     agent_home: str = ".langchain_agentx",
     workspace_trust_accepted: bool | None = None,
     hooks: "HookRegistry | None" = None,
@@ -1407,6 +1442,7 @@ def create_loop_agent(
     capabilities: "RuntimeCapabilities | None" = None,
     enable_git_snapshot: bool | None = None,
     include_default_session_context: bool = True,
+    enable_dynamic_root_grant: bool = False,
 ) -> CompiledStateGraph[
     AgentState[ResponseT], ContextT, _InputAgentState, _OutputAgentState[ResponseT]
 ]:
@@ -1447,6 +1483,8 @@ def create_loop_agent(
         managed_rules=managed_rules,
         active_files_getter=active_files_getter,
         workspace_root=workspace_root,
+        read_roots=read_roots,
+        write_roots=write_roots,
         agent_home=agent_home,
         workspace_trust_accepted=workspace_trust_accepted,
         raw_hooks=hooks,
@@ -1454,6 +1492,7 @@ def create_loop_agent(
         capabilities=capabilities,
         enable_git_snapshot=enable_git_snapshot,
         include_default_session_context=include_default_session_context,
+        enable_dynamic_root_grant=enable_dynamic_root_grant,
     )
     tool_node = builder._build_tool_node()
     model_node = builder._build_model_nodes(tool_node)

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/session/conversation_factory.py

@@ -78,6 +78,7 @@ def create_conversation_session(
             prompt_handler=resolved_prompt_handler,
             permission_resolver=resolved_permission_resolver,
             container_type=container_type,
+            enable_dynamic_root_grant=True,
             **loop_kwargs,
         )
 

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/session/factory.py

@@ -86,6 +86,7 @@ def create_agent_session(
             active_files_getter=active_files_getter,
             container_type=container_type,
             enable_trace=enable_trace,
+            enable_dynamic_root_grant=True,
             capabilities=capabilities,
             **loop_kwargs,
         )

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/tool_runtime/adapter.py

@@ -139,22 +139,41 @@ class LangChainAdapter:
         conversation_session_id = getattr(loop_config, "conversation_session_id", None) or session_id
         workspace_root = getattr(loop_config, "workspace_root", None)
         agent_home = getattr(loop_config, "agent_home", ".langchain_agentx")
-        # cwd：loop_config.cwd → session_store.cwd_override → workspace_root → get_cwd()
-        from langchain_agentx.utils.cwd import get_cwd as _utils_get_cwd
+        boundary = getattr(loop_config, "boundary", None)
 
-        cwd = getattr(loop_config, "cwd", None)
+        sess = configurable.get("session_store")
+        from langchain_agentx.tool_runtime.session_store import (
+            AgentSessionStore as _AgentSessionStore,
+        )
+
+        boundary_view = None
+        if boundary is not None and isinstance(sess, _AgentSessionStore):
+            from langchain_agentx.workspace.view import WorkspaceBoundaryView
+
+            boundary_view = WorkspaceBoundaryView(boundary, sess)
+
+        cwd: str | None = None
+        if boundary_view is not None:
+            cwd = str(boundary_view.resolve_cwd(None))
+        elif isinstance(sess, _AgentSessionStore):
+            sess_cwd = sess.cwd_override
+            if isinstance(sess_cwd, str) and sess_cwd:
+                cwd = sess_cwd
         if not cwd:
-            sess = configurable.get("session_store")
-            from langchain_agentx.tool_runtime.session_store import (
-                AgentSessionStore as _AgentSessionStore,
+            cwd = workspace_root
+        if not cwd:
+            from langchain_agentx.workspace.errors import ConfigError
+
+            raise ConfigError(
+                "ToolExecutionContext cwd resolution failed: "
+                "neither boundary_view nor workspace_root configured."
             )
 
-            if isinstance(sess, _AgentSessionStore):
-                sess_cwd = sess.cwd_override
-                if isinstance(sess_cwd, str) and sess_cwd:
-                    cwd = sess_cwd
-        if not cwd:
-            cwd = workspace_root or _utils_get_cwd()
+        original_cwd: str | None = None
+        if boundary is not None:
+            original_cwd = str(boundary.workspace_root)
+        elif workspace_root:
+            original_cwd = str(workspace_root)
         trace_enabled = bool(getattr(loop_config, "trace_enabled", True))
 
         _depth_from_loop = getattr(loop_config, "agent_depth", None)
@@ -266,6 +285,8 @@ class LangChainAdapter:
             workspace_root=workspace_root,
             agent_home=agent_home,
             cwd=cwd,
+            original_cwd=original_cwd,
+            boundary_view=boundary_view,
             trace_enabled=trace_enabled,
             cancel_event=cancel_ev,
             tool_config_path=tool_config_path,

langchain-agentx-python-0.6.0/langchain_agentx/tool_runtime/loader.py

@@ -0,0 +1,209 @@
+"""
+runtime/loader.py — 工具运行时框架进程级初始化入口
+
+职责：
+    进程级一次性初始化，组装框架核心组件（pipeline / policy / registry）并统一管理工具注册。
+    loader 只负责注册 RuntimeTool，不构造 StructuredTool。
+    StructuredTool 构造由 factory（create_loop_agent）在 graph 构建时负责，
+    通过 create_loop_agent(loader=...) 在构图时调用 to_langchain_tools() 构造 StructuredTool。
+
+    policy_config 用于构造 DefaultPolicyEngine，在 register() 时自动注入给每个工具。
+    工具无需手动传入 policy，由 loader 统一治理。
+
+装配路径：
+    ToolRuntimeLoader(policy_config=...) 构造
+        → ProcessLoader（共享 policy / pipeline）
+        → spawn_loop_loader(...) 构造 per-loop LoopLoader
+        → 传入 create_loop_agent(loader=loader, ...)
+        → factory 内部调用 loop_loader.registry.to_langchain_tools()
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.tools import BaseTool
+
+from .adapter import LangChainAdapter
+from .base import RuntimeTool
+from .loop_loader import LoopLoader
+from .pipeline import ToolExecutorPipeline, ToolOutputManager
+from .auto_mode.config import AutoModeConfig
+from .process_loader import ProcessLoader
+from .registry import RuntimeToolRegistry
+from .prompt.handler import PermissionPromptHandler
+from .resolvers import PermissionResolver
+from .policy import PolicyEngine, ToolPolicyConfig
+from .session_store import AgentSessionStore
+
+
+class ToolRuntimeLoader:
+    """
+    工具运行时进程级装配入口。
+
+    policy_config:  策略配置，构造 DefaultPolicyEngine 并自动注入给所有注册工具。
+                    为 None 时不注入 policy（工具默认 allow，适用于开发/测试模式）。
+    policy_engine:  直接传入自定义 PolicyEngine 实例（优先于 policy_config）。
+    output_manager: 工具输出大小管控器，为 None 时使用默认配置。
+    headless:       是否处于无交互（headless）模式。
+                    True  — ask 走 HeadlessPromptHandler（仅 hook 链，无决议则 deny）。
+                    False — ask 走 prompt_handler 或 legacy permission_resolver。
+    prompt_handler: L3 PermissionPromptHandler；优先于 permission_resolver。
+    permission_resolver: 旧 (name, prompt) -> bool 垫片，自动包装为 LegacyResolverPromptHandler。
+    """
+
+    def __init__(
+        self,
+        *,
+        policy_config: ToolPolicyConfig | None = None,
+        policy_engine: PolicyEngine | None = None,
+        output_manager: ToolOutputManager | None = None,
+        headless: bool = False,
+        prompt_handler: PermissionPromptHandler | None = None,
+        permission_resolver: PermissionResolver | None = None,
+    ) -> None:
+        self._process = ProcessLoader(
+            policy_config=policy_config,
+            policy_engine=policy_engine,
+            output_manager=output_manager,
+            headless=headless,
+            prompt_handler=prompt_handler,
+            permission_resolver=permission_resolver,
+        )
+        self._registry = RuntimeToolRegistry(
+            pipeline=self._process.pipeline,
+            adapter=self._process.adapter,
+        )
+
+    def register(self, tool: RuntimeTool) -> "ToolRuntimeLoader":
+        """
+        注册工具并自动注入 PolicyEngine。
+
+        注入规则：
+            - 工具已有 _policy（初始化时手动传入）→ 不覆盖，保留工具自己的 policy
+            - 工具无 _policy（_policy is None）→ 注入 loader 的统一 policy
+        这允许个别工具使用专属 policy，其余工具统一受 loader policy 保护。
+        """
+        if self._process.policy is not None and getattr(tool, "_policy", None) is None:
+            tool._policy = self._process.policy
+        self._registry.register(tool)
+        return self
+
+    def register_default_tools(
+        self,
+        *,
+        workspace_root: str,
+        agent_home: str = ".langchain_agentx",
+        include_agent: bool = True,
+        include_skill: bool = False,
+        agent_registry: Any | None = None,
+    ) -> "ToolRuntimeLoader":
+        """
+        注册默认工具集（Read/Grep/Glob/Bash + 可选 Agent/Skill）。
+
+        向后兼容：在 loader 自身 registry 上注册（单 loop 模式）。
+        create_loop_agent 应优先使用 ``spawn_loop_loader`` 获得 per-loop 隔离。
+        """
+        loop = self.spawn_loop_loader(
+            workspace_root=workspace_root,
+            agent_home=agent_home,
+        )
+        loop.register_default_tools(
+            include_agent=include_agent,
+            include_skill=include_skill,
+            agent_registry=agent_registry,
+        )
+        for tool in loop.registry.list():
+            if tool.name not in self._registry._tools:
+                self._registry.register(tool)
+        return self
+
+    def spawn_loop_loader(
+        self,
+        *,
+        workspace_root: str,
+        agent_home: str = ".langchain_agentx",
+    ) -> LoopLoader:
+        """构造独立的 per-loop 工具注册表（不污染 loader 主 registry）。"""
+        return LoopLoader(
+            self._process,
+            workspace_root=workspace_root,
+            agent_home=agent_home,
+        )
+
+    def create_session(self, session_id: str | None = None) -> AgentSessionStore:
+        return AgentSessionStore(session_id=session_id)
+
+    def fork_with_tools(self, tools: list[RuntimeTool]) -> "ToolRuntimeLoader":
+        """
+        基于当前 loader 派生一个子 loader（共享 policy/headless 语义），并注册给定工具集。
+
+        目的：为 subagent 组装“过滤后的工具池”而不丢失权限/管控语义。
+        """
+        child = ToolRuntimeLoader(
+            policy_engine=self._process.policy,
+            headless=self._process.headless,
+            prompt_handler=self._process.prompt_handler,
+            permission_resolver=self._process.permission_resolver,
+        )
+        for t in tools:
+            child.register(t)
+        return child
+
+    def set_permission_resolver(
+        self,
+        permission_resolver: PermissionResolver | None,
+    ) -> None:
+        """更新 loader 与 pipeline 的 permission_resolver（包装为 L3 垫片）。"""
+        self._process.set_permission_resolver(permission_resolver)
+
+    def set_prompt_handler(
+        self,
+        prompt_handler: PermissionPromptHandler | None,
+    ) -> None:
+        """更新 loader 与 pipeline 的 prompt_handler。"""
+        self._process.set_prompt_handler(prompt_handler)
+
+    def update_auto_mode_config(
+        self,
+        *,
+        enabled: bool | None = None,
+        classifier_model: str | None = None,
+        classifier_path: str | None = None,
+        use_classifier: bool | None = None,
+        auto_mode_config: AutoModeConfig | None = None,
+    ) -> AutoModeConfig:
+        return self._process.update_auto_mode_config(
+            enabled=enabled,
+            classifier_model=classifier_model,
+            classifier_path=classifier_path,
+            use_classifier=use_classifier,
+            auto_mode_config=auto_mode_config,
+        )
+
+    @property
+    def process_loader(self) -> ProcessLoader:
+        return self._process
+
+    @property
+    def policy_config(self) -> ToolPolicyConfig | None:
+        return self._process.policy_config
+
+    @property
+    def policy(self) -> PolicyEngine | None:
+        return self._process.policy
+
+    @property
+    def registry(self) -> RuntimeToolRegistry:
+        return self._registry
+
+    @property
+    def pipeline(self) -> ToolExecutorPipeline:
+        return self._process.pipeline
+
+    @property
+    def adapter(self) -> LangChainAdapter:
+        return self._process.adapter
+
+    def __repr__(self) -> str:
+        return f"<ToolRuntimeLoader tools={list(self._registry._tools.keys())}>"

langchain-agentx-python-0.6.0/langchain_agentx/tool_runtime/loop_loader.py

@@ -0,0 +1,186 @@
+"""
+tool_runtime/loop_loader.py — loop 级工具注册与隔离实例
+
+职责：
+    每个 loop_agent 持有独立 RuntimeToolRegistry、ToolStateBridge、Glob/Grep 实例。
+
+链路位置：
+    create_loop_agent 经 ToolRuntimeLoader.spawn_loop_loader 构造 per-loop 实例。
+
+当前裁剪范围：
+    不含进程级 policy/pipeline 构造；从 ProcessLoader 注入共享组件。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .path_safety import PathSafetyConfig
+from .process_loader import ProcessLoader
+from .read_ignore_patterns import ReadDenyPatternCollector
+from .registry import RuntimeToolRegistry
+from .policy import DefaultPolicyEngine
+
+
+class LoopLoader:
+    """单 loop 工具注册表与 per-loop 工具实例。"""
+
+    def __init__(
+        self,
+        process: ProcessLoader,
+        *,
+        workspace_root: str,
+        agent_home: str = ".langchain_agentx",
+    ) -> None:
+        self._process = process
+        self._workspace_root = workspace_root
+        self._agent_home = agent_home
+        self._registry = RuntimeToolRegistry(
+            pipeline=process.pipeline,
+            adapter=process.adapter,
+        )
+
+    @property
+    def process(self) -> ProcessLoader:
+        return self._process
+
+    @property
+    def registry(self) -> RuntimeToolRegistry:
+        return self._registry
+
+    @property
+    def workspace_root(self) -> str:
+        return self._workspace_root
+
+    def register(self, tool: Any) -> "LoopLoader":
+        policy = self._process.policy
+        if policy is not None and getattr(tool, "_policy", None) is None:
+            tool._policy = policy
+        self._registry.register(tool)
+        return self
+
+    def register_default_tools(
+        self,
+        *,
+        include_agent: bool = True,
+        include_skill: bool = False,
+        agent_registry: Any | None = None,
+    ) -> "LoopLoader":
+        from pathlib import Path
+
+        from langchain_agentx.tools.ask_user_question import AskUserQuestionTool
+        from langchain_agentx.tools.bash import BashRuntimeTool
+        from langchain_agentx.tools.edit import EditRuntimeTool
+        from langchain_agentx.tools.edit.settings_validator import SettingsValidator
+        from langchain_agentx.tools.edit.staleness import StalenessChecker
+        from langchain_agentx.tools.edit.validator import EditStringValidator
+        from langchain_agentx.tools.glob import GlobRuntimeTool
+        from langchain_agentx.tools.grep import GrepRuntimeTool
+        from langchain_agentx.tools.read import ReadRuntimeTool
+        from langchain_agentx.tools.ripgrep_plugin_exclusions import PluginCacheGlobExclusions
+        from langchain_agentx.tools.task_list.tool import TaskListRuntimeTool
+        from langchain_agentx.tools.user_message import UserMessageTool
+        from langchain_agentx.tools.webfetch import loader as webfetch_loader
+        from langchain_agentx.tools.websearch import loader as websearch_loader
+        from langchain_agentx.tools.write import WriteRuntimeTool
+        from langchain_agentx.tool_runtime.state_bridge import ToolStateBridge
+        from langchain_agentx.workspace.config import AgentWorkspaceConfig
+
+        wr = Path(self._workspace_root).resolve()
+        cfg = AgentWorkspaceConfig(workspace_root=wr, agent_home=self._agent_home)
+        self._inject_path_safety_policy(
+            workspace_root=str(wr),
+            agent_home_segment=cfg.agent_home_dir.name,
+        )
+        plugin_ex = PluginCacheGlobExclusions(
+            cache_root=str(cfg.plugin_cache_dir.resolve()),
+        )
+
+        shared_bridge = ToolStateBridge(initial_cwd=str(wr))
+        search_ignore_patterns = self._collect_search_ignore_patterns()
+
+        settings_validator = SettingsValidator(agent_home_segment=cfg.agent_home_dir.name)
+        edit_staleness = StalenessChecker(shared_bridge)
+        edit_string_validator = EditStringValidator(
+            state_bridge=shared_bridge,
+            staleness_checker=edit_staleness,
+            settings_validator=settings_validator,
+        )
+
+        self.register(ReadRuntimeTool(state_bridge=shared_bridge))
+        self.register(WriteRuntimeTool(state_bridge=shared_bridge))
+        self.register(
+            EditRuntimeTool(
+                state_bridge=shared_bridge,
+                string_validator=edit_string_validator,
+                staleness_checker=edit_staleness,
+            )
+        )
+        self.register(
+            GrepRuntimeTool(
+                workspace_root=str(wr),
+                plugin_cache_glob_exclusions=plugin_ex,
+                ignore_patterns=search_ignore_patterns or None,
+            )
+        )
+        self.register(
+            GlobRuntimeTool(
+                workspace_root=str(wr),
+                plugin_cache_glob_exclusions=plugin_ex,
+                state_bridge=shared_bridge,
+                ignore_patterns=search_ignore_patterns or None,
+            )
+        )
+        self.register(BashRuntimeTool(state_bridge=shared_bridge))
+        self.register(UserMessageTool())
+        self.register(AskUserQuestionTool())
+        self.register(TaskListRuntimeTool(config=cfg))
+
+        websearch_loader.register(self)
+        webfetch_loader.register(self)
+
+        if include_agent:
+            from langchain_agentx.tools.agent import AgentRuntimeTool
+
+            self.register(AgentRuntimeTool(registry=agent_registry))
+
+        if include_skill:
+            from langchain_agentx.tools.skill import SkillRuntimeTool
+
+            self.register(
+                SkillRuntimeTool(
+                    workspace_root=self._workspace_root,
+                    agent_home=self._agent_home,
+                )
+            )
+
+        return self
+
+    def _collect_search_ignore_patterns(self) -> list[str]:
+        cfg = self._process.policy_config
+        policy = self._process.policy
+        if cfg is None and isinstance(policy, DefaultPolicyEngine):
+            cfg = policy._config
+        return ReadDenyPatternCollector().collect(cfg)
+
+    def _inject_path_safety_policy(
+        self,
+        *,
+        workspace_root: str,
+        agent_home_segment: str,
+    ) -> None:
+        path_cfg = PathSafetyConfig.from_workspace(
+            workspace_root=workspace_root,
+            agent_home_segment=agent_home_segment,
+        )
+        policy_config = self._process.policy_config
+        if policy_config is not None and policy_config.path_safety is None:
+            policy_config.path_safety = path_cfg
+        policy = self._process.policy
+        if isinstance(policy, DefaultPolicyEngine):
+            pc = policy._config
+            if pc.path_safety is None:
+                pc.path_safety = path_cfg
+
+
+__all__ = ["LoopLoader"]

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/tool_runtime/models.py

@@ -100,7 +100,9 @@ class ToolExecutionContext:
     agent_depth: int = 0
     workspace_root: str | None = None
     agent_home: str = ".langchain_agentx"
-    cwd: str | None = None  # 工具执行时的路径基准（CC 对照：getCwd()）
+    cwd: str | None = None  # 过渡期派生字段；工具应读 boundary_view.resolve_cwd()
+    original_cwd: str | None = None  # = boundary.workspace_root
+    boundary_view: Any | None = None  # WorkspaceBoundaryView
     trace_enabled: bool = True
     cancel_event: threading.Event | None = None
     """可选；由 ``RunnableConfig.configurable[\"cancel_event\"]`` 注入。set 后 Grep/Glob 应中断 rg。"""

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.0}/langchain_agentx/tool_runtime/pipeline.py

@@ -1026,6 +1026,17 @@ class ToolExecutorPipeline:
         if resp.permission_updates:
             ctx.persist_permission_updates(resp.permission_updates)
 
+        if resp.behavior == "allow":
+            from langchain_agentx.workspace.l3_root_grant import apply_l3_root_grants
+
+            apply_l3_root_grants(
+                ctx,
+                tool_name=tool.name,
+                input_data=parsed_data,
+                permission_updates=resp.permission_updates,
+                decision_source=resp.decision_source.value,
+            )
+
         if resp.behavior == "deny":
             env = blocked_envelope(
                 tool.name,