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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 0.5.3
+Version: 0.6.1
 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.1}/langchain_agentx/__init__.py

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

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.1}/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 = ""
@@ -65,6 +67,7 @@ class AgentLoopConfig:
     subagent_type: str | None = None
     # 观测控制面：主 Agent 打开则子 Agent 默认继承打开
     trace_enabled: bool = True
+    headless: bool = False
     # 模型能力配置：显式 profile > registry 匹配 > model metadata > 代码兜底
     model_profile: ModelProfile | None = None
     model_profile_registry: ModelProfileRegistry | None = None

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

@@ -101,6 +101,7 @@ from ..config import AgentLoopConfig, ModelContextResolver
 from ..config.runtime_settings import compute_recursion_limit
 from ...provider.model_profile import ModelProfileRegistry  # re-exported for legacy tests
 from ...workspace import resolve_agent_workspace_config
+from ...tool_runtime.prompt.session_mode import infer_session_headless
 
 logger = logging.getLogger(__name__)
 SKILL_TOOL_NAME = "skill"
@@ -185,6 +186,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 +195,8 @@ class LoopGraphBuilder:
         capabilities: "RuntimeCapabilities | None" = None,
         enable_git_snapshot: bool | None = None,
         include_default_session_context: bool = True,
+        enable_dynamic_root_grant: bool = False,
+        headless: bool | None = None,
     ) -> None:
         self._raw_model = model
         self._raw_system_prompt = system_prompt
@@ -227,6 +232,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 +241,8 @@ 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._raw_headless = headless
 
         self._prepared = False
 
@@ -251,8 +260,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,10 +366,12 @@ 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,
+            headless=self._resolve_session_headless(),
         )
         self._compaction_settings = self._build_compaction_settings()
         self._loop_context_compaction = default_loop_context_compaction().with_default_pipeline(
@@ -465,6 +481,12 @@ class LoopGraphBuilder:
             )
         self._prepared = True
 
+    def _resolve_session_headless(self) -> bool:
+        return infer_session_headless(
+            headless=self._raw_headless,
+            container_type=self._raw_container_type,
+        )
+
     def _resolve_model_session_and_logger(
         self,
     ) -> tuple[BaseChatModel, str, ObservabilityLoggerAdapter]:
@@ -513,9 +535,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 +563,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 +1348,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 +1443,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 +1452,8 @@ 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,
+    headless: bool | None = None,
 ) -> CompiledStateGraph[
     AgentState[ResponseT], ContextT, _InputAgentState, _OutputAgentState[ResponseT]
 ]:
@@ -1447,6 +1494,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 +1503,8 @@ 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,
+        headless=headless,
     )
     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.1}/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.1}/langchain_agentx/session/factory.py

@@ -24,6 +24,7 @@ from langchain_core.language_models.chat_models import BaseChatModel
 from ..loop.graph.factory import create_loop_agent
 from ..loop.hook import HookEngine, HooksConfigSnapshot, HookRegistry, WorkspaceTrustChecker
 from ..loop.subagent.transcript import SubagentTranscriptStore
+from ..tool_runtime.prompt.session_mode import infer_session_headless
 from ..workspace import resolve_agent_workspace_config
 from .agent_session import AgentSession
 
@@ -40,6 +41,7 @@ def create_agent_session(
     transcript_writer: SubagentTranscriptStore | None = None,
     container_type: str = "interactive",
     enable_trace: bool = True,
+    headless: bool | None = None,
     **loop_kwargs: Any,
 ) -> AgentSession:
     """创建默认走 graph_factory 注入路径的 AgentSession。
@@ -48,6 +50,10 @@ def create_agent_session(
     （环境变量 ``LANGCHAIN_AGENTX_*`` 与产品默认 ``.langchain_agentx``）。
     """
     resolved_session_id = session_id or f"session-{uuid4().hex}"
+    resolved_headless = infer_session_headless(
+        headless=headless,
+        container_type=container_type,
+    )
     workspace_cfg = resolve_agent_workspace_config(
         workspace_root=workspace_root,
         agent_home=agent_home,
@@ -65,7 +71,7 @@ def create_agent_session(
         hook_engine = HookEngine(
             snapshot,
             trust_checker=WorkspaceTrustChecker(
-                headless=_is_headless_container(container_type),
+                headless=resolved_headless,
                 workspace_trust_accepted=workspace_cfg.workspace_trust_accepted,
             ),
         )
@@ -86,7 +92,9 @@ 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,
+            headless=resolved_headless,
             **loop_kwargs,
         )
 

{langchain-agentx-python-0.5.3 → langchain-agentx-python-0.6.1}/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.1/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())}>"