langchain-agentx-python 1.5.8__tar.gz → 1.6.0__tar.gz

{langchain-agentx-python-1.5.8/langchain_agentx_python.egg-info → langchain-agentx-python-1.6.0}/PKG-INFO

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

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/loop/graph/factory.py

@@ -289,6 +289,8 @@ def _flatten_config_for_runtime(config: AgentLoopConfig) -> _FlatLoopConfig:
         workspace_root=config.workspace.workspace_root,
         runtime_cwd=config.workspace.runtime_cwd,  # P0-2: 新增 runtime_cwd
         agent_home_segment=config.workspace.agent_home_segment,
+        read_roots=config.workspace.read_roots,
+        write_roots=config.workspace.write_roots,
         cwd=None,  # 由 boundary_view.resolve_cwd() 动态计算
         enable_dynamic_root_grant=config.workspace.enable_dynamic_root_grant,
         session_id=config.session_id,
@@ -850,6 +852,7 @@ class LoopGraphBuilder:
         trace_collector: Any | None = None,
     ) -> MemoryExtractionCoordinator:
         from ..subagent.context import ForkedParentRuntime
+        from ..subagent.boundary_snapshot import BoundarySnapshotPropagator
         from ..subagent.forked_runner import ForkedAgentRunner
         from ...memory.memdir.memory_saved import build_combined_memory_saved_callback
 
@@ -873,6 +876,14 @@ class LoopGraphBuilder:
             system_prompt=self._base_prompt,
             capabilities=self._services.capabilities,
             cwd=runtime_cwd,
+            boundary_snapshot=BoundarySnapshotPropagator.from_workspace_boundary(
+                boundary=self._workspace_boundary,
+                runtime_cwd=runtime_cwd,
+                enable_dynamic_root_grant=self._config.workspace.enable_dynamic_root_grant,
+                granted_roots=tuple(session_store.granted_roots)
+                if hasattr(session_store, "granted_roots")
+                else (),
+            ),
         )
         from ...memory.memdir.fork_concurrency import default_fork_concurrency_limiter
         from ...memory.memdir.metrics import default_memory_fork_metrics
@@ -906,6 +917,7 @@ class LoopGraphBuilder:
         from pathlib import Path as StdPath
 
         from ..subagent.context import ForkedParentRuntime
+        from ..subagent.boundary_snapshot import BoundarySnapshotPropagator
         from ..subagent.forked_runner import ForkedAgentRunner
         from ...memory.memdir.fork_concurrency import default_fork_concurrency_limiter
         from ...memory.session.extractor import SessionMemoryExtractor
@@ -926,6 +938,14 @@ class LoopGraphBuilder:
             system_prompt=base_prompt,
             capabilities=self._services.capabilities,
             cwd=runtime_cwd,
+            boundary_snapshot=BoundarySnapshotPropagator.from_workspace_boundary(
+                boundary=self._workspace_boundary,
+                runtime_cwd=runtime_cwd,
+                enable_dynamic_root_grant=self._config.workspace.enable_dynamic_root_grant,
+                granted_roots=tuple(session_store.granted_roots)
+                if hasattr(session_store, "granted_roots")
+                else (),
+            ),
         )
         forked_runner = ForkedAgentRunner(
             parent_runtime=parent_runtime,

langchain-agentx-python-1.6.0/langchain_agentx/loop/subagent/boundary_snapshot.py

@@ -0,0 +1,261 @@
+"""
+loop/subagent/boundary_snapshot.py — 子 Agent spawn 时刻 boundary 快照
+
+职责：
+    冻结父 loop 的 static boundary 字段，供 create_subagent_graph 写入 AgentStateConfig。
+
+链路位置：
+    BoundarySnapshotPropagator.from_parent → SubagentContext.boundary_snapshot
+    → create_subagent_graph → AgentStateConfig → WorkspaceBoundary.build
+
+当前裁剪范围：
+    static roots + runtime_cwd + spawn 时刻 grant 快照（via session_store.clone inherit_grants）。
+"""
+
+from __future__ import annotations
+
+import copy
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from langchain_agentx.loop.config.loop_config import AgentStateConfig
+from langchain_agentx.workspace.grant import GrantedRoot
+
+logger = logging.getLogger(__name__)
+
+
+def _is_workspace_boundary(obj: Any) -> bool:
+    from langchain_agentx.workspace.boundary import WorkspaceBoundary
+
+    return isinstance(obj, WorkspaceBoundary)
+
+
+def _read_loop_config(parent_ctx: Any) -> Any | None:
+    runnable_config = getattr(parent_ctx, "runnable_config", None)
+    if not isinstance(runnable_config, dict):
+        return None
+    configurable = runnable_config.get("configurable")
+    if not isinstance(configurable, dict):
+        return None
+    return configurable.get("loop_config")
+
+
+def _path_tuple(paths: tuple[Path, ...] | list[Path] | tuple[str, ...]) -> tuple[str, ...]:
+    return tuple(str(p) for p in paths)
+
+
+@dataclass(frozen=True, slots=True)
+class BoundarySnapshot:
+    """spawn 时刻冻结的父 static boundary 视图（不可变）。"""
+
+    workspace_root: str
+    runtime_cwd: str | None
+    read_roots: tuple[str, ...]
+    write_roots: tuple[str, ...]
+    enable_dynamic_root_grant: bool
+    granted_roots: tuple[GrantedRoot, ...] = ()  # spawn 时刻 grant 快照（与 session clone 对齐）
+
+    def to_agent_state_config(self, *, agent_home_segment: str) -> AgentStateConfig:
+        return AgentStateConfig(
+            workspace_root=self.workspace_root,
+            runtime_cwd=self.runtime_cwd,
+            agent_home_segment=agent_home_segment,
+            read_roots=self.read_roots,
+            write_roots=self.write_roots,
+            enable_dynamic_root_grant=self.enable_dynamic_root_grant,
+        )
+
+
+class BoundarySnapshotPropagator:
+    """从父 loop 运行时视图构造 BoundarySnapshot。"""
+
+    @classmethod
+    def from_parent(
+        cls,
+        parent_ctx: Any,
+        *,
+        effective_cwd: str | None = None,
+    ) -> BoundarySnapshot:
+        loop_config = _read_loop_config(parent_ctx)
+        boundary = cls._resolve_boundary(parent_ctx, loop_config)
+        enable_grant = cls._resolve_enable_dynamic_root_grant(parent_ctx, loop_config)
+
+        if boundary is not None:
+            workspace_root = str(boundary.workspace_root)
+            read_roots = _path_tuple(boundary.initial_read_roots)
+            write_roots = _path_tuple(boundary.initial_write_roots)
+        else:
+            workspace_root, read_roots, write_roots = cls._fallback_roots_from_loop_config(
+                parent_ctx, loop_config
+            )
+            if not read_roots and not write_roots:
+                logger.warning(
+                    "BoundarySnapshotPropagator: parent has no boundary; "
+                    "subagent will default read/write to workspace_root=%s",
+                    workspace_root,
+                )
+
+        runtime_cwd = cls._resolve_runtime_cwd(
+            parent_ctx,
+            loop_config,
+            effective_cwd=effective_cwd,
+            workspace_root=workspace_root,
+        )
+        granted_roots = cls._snapshot_grants(parent_ctx)
+        return BoundarySnapshot(
+            workspace_root=workspace_root,
+            runtime_cwd=runtime_cwd,
+            read_roots=read_roots,
+            write_roots=write_roots,
+            enable_dynamic_root_grant=enable_grant,
+            granted_roots=granted_roots,
+        )
+
+    @classmethod
+    def from_workspace_boundary(
+        cls,
+        *,
+        boundary: Any,
+        runtime_cwd: str | None,
+        enable_dynamic_root_grant: bool = False,
+        granted_roots: tuple[GrantedRoot, ...] = (),
+    ) -> BoundarySnapshot:
+        """ForkedParentRuntime / LoopGraphBuilder 路径：直接传入已编译 boundary。"""
+        return BoundarySnapshot(
+            workspace_root=str(boundary.workspace_root),
+            runtime_cwd=runtime_cwd,
+            read_roots=_path_tuple(boundary.initial_read_roots),
+            write_roots=_path_tuple(boundary.initial_write_roots),
+            enable_dynamic_root_grant=enable_dynamic_root_grant,
+            granted_roots=granted_roots,
+        )
+
+    @classmethod
+    def from_fork_parent_runtime(
+        cls,
+        parent_runtime: Any,
+        *,
+        effective_cwd: str | None,
+    ) -> BoundarySnapshot:
+        snapshot = getattr(parent_runtime, "boundary_snapshot", None)
+        if isinstance(snapshot, BoundarySnapshot):
+            if effective_cwd and snapshot.runtime_cwd != effective_cwd:
+                return BoundarySnapshot(
+                    workspace_root=snapshot.workspace_root,
+                    runtime_cwd=effective_cwd,
+                    read_roots=snapshot.read_roots,
+                    write_roots=snapshot.write_roots,
+                    enable_dynamic_root_grant=snapshot.enable_dynamic_root_grant,
+                    granted_roots=snapshot.granted_roots,
+                )
+            return snapshot
+        workspace_root = str(getattr(parent_runtime, "workspace_root", "") or "")
+        if not workspace_root:
+            raise ValueError(
+                "ForkedParentRuntime.workspace_root is required for boundary propagation"
+            )
+        return BoundarySnapshot(
+            workspace_root=workspace_root,
+            runtime_cwd=effective_cwd,
+            read_roots=(),
+            write_roots=(),
+            enable_dynamic_root_grant=False,
+            granted_roots=(),
+        )
+
+    @staticmethod
+    def _resolve_boundary(parent_ctx: Any, loop_config: Any | None) -> Any | None:
+        if loop_config is not None:
+            boundary = getattr(loop_config, "boundary", None)
+            if _is_workspace_boundary(boundary):
+                return boundary
+        view = getattr(parent_ctx, "boundary_view", None)
+        if view is not None:
+            boundary = getattr(view, "boundary", None)
+            if _is_workspace_boundary(boundary):
+                return boundary
+        return None
+
+    @staticmethod
+    def _resolve_enable_dynamic_root_grant(parent_ctx: Any, loop_config: Any | None) -> bool:
+        if loop_config is not None:
+            workspace_cfg = getattr(loop_config, "workspace", None)
+            if workspace_cfg is not None:
+                return bool(getattr(workspace_cfg, "enable_dynamic_root_grant", False))
+            flag = getattr(loop_config, "enable_dynamic_root_grant", None)
+            if flag is not None:
+                return bool(flag)
+        session_store = getattr(parent_ctx, "session_store", None)
+        if session_store is not None:
+            return bool(getattr(session_store, "enable_dynamic_root_grant", False))
+        return False
+
+    @staticmethod
+    def _fallback_roots_from_loop_config(
+        parent_ctx: Any,
+        loop_config: Any | None,
+    ) -> tuple[str, tuple[str, ...], tuple[str, ...]]:
+        from langchain_agentx.loop.runtime.subagent_execution_paths import (
+            resolve_subagent_workspace_root,
+        )
+
+        workspace_root = str(resolve_subagent_workspace_root(parent_ctx))
+        read_roots: tuple[str, ...] = ()
+        write_roots: tuple[str, ...] = ()
+
+        if loop_config is not None:
+            workspace_cfg = getattr(loop_config, "workspace", None)
+            if workspace_cfg is not None:
+                read_roots = tuple(str(p) for p in (workspace_cfg.read_roots or ()))
+                write_roots = tuple(str(p) for p in (workspace_cfg.write_roots or ()))
+                ws = getattr(workspace_cfg, "workspace_root", None)
+                if ws is not None:
+                    workspace_root = str(ws)
+            else:
+                flat_read = getattr(loop_config, "read_roots", None)
+                flat_write = getattr(loop_config, "write_roots", None)
+                if flat_read:
+                    read_roots = tuple(str(p) for p in flat_read)
+                if flat_write:
+                    write_roots = tuple(str(p) for p in flat_write)
+                ws = getattr(loop_config, "workspace_root", None)
+                if ws is not None:
+                    workspace_root = str(ws)
+
+        return workspace_root, read_roots, write_roots
+
+    @staticmethod
+    def _resolve_runtime_cwd(
+        parent_ctx: Any,
+        loop_config: Any | None,
+        *,
+        effective_cwd: str | None,
+        workspace_root: str,
+    ) -> str | None:
+        if isinstance(effective_cwd, str) and effective_cwd.strip():
+            return effective_cwd.strip()
+        if loop_config is not None:
+            workspace_cfg = getattr(loop_config, "workspace", None)
+            if workspace_cfg is not None:
+                rc = getattr(workspace_cfg, "runtime_cwd", None)
+                if rc is not None:
+                    return str(rc)
+            rc = getattr(loop_config, "runtime_cwd", None)
+            if rc is not None:
+                return str(rc)
+        parent_cwd = getattr(parent_ctx, "cwd", None)
+        if isinstance(parent_cwd, str) and parent_cwd.strip():
+            return parent_cwd.strip()
+        return workspace_root or None
+
+    @staticmethod
+    def _snapshot_grants(parent_ctx: Any) -> tuple[GrantedRoot, ...]:
+        session_store = getattr(parent_ctx, "session_store", None)
+        if session_store is None or not hasattr(session_store, "granted_roots"):
+            return ()
+        return tuple(copy.deepcopy(g) for g in session_store.granted_roots)
+
+
+__all__ = ["BoundarySnapshot", "BoundarySnapshotPropagator"]

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/loop/subagent/context.py

@@ -19,7 +19,7 @@ Fork 路径区分（对齐 CC）：
       ``path_prep`` 与遗留 ``cwd``/worktree 自建二选一（编排层须传 ``path_prep``）；
       fork + worktree 时可选注入 CC 等价 ``buildWorktreeNotice`` user 消息（见 ``fork_worktree_notice``）；
       create_subagent_context 在 fork_from_parent=True 时注入 fork-boilerplate 行为规范；
-      P0-1: 子代理默认隔离 session_store（父为 AgentSessionStore 时使用 clone(file_state_only=True)）。
+      P0-1: 子代理默认隔离 session_store（父为 AgentSessionStore 时使用 clone(file_state_only=True, inherit_grants=True)）。
 """
 
 import os
@@ -36,6 +36,10 @@ from langchain_agentx.loop.runtime.subagent_execution_paths import (
     resolve_subagent_effective_cwd,
     resolve_subagent_workspace_root,
 )
+from langchain_agentx.loop.subagent.boundary_snapshot import (
+    BoundarySnapshot,
+    BoundarySnapshotPropagator,
+)
 from langchain_agentx.loop.subagent.fork_boilerplate import build_fork_boilerplate
 from langchain_agentx.loop.subagent.fork_worktree_notice import build_worktree_notice
 from langchain_agentx.loop.message_contract import to_record
@@ -87,6 +91,7 @@ class SubagentContext:
     workspace_root: str = ""
     agent_home_segment: str = ".langchain_agentx"
     cwd: str | None = None  # 辅助镜像（用于 prompt/日志/debug）；权威源在 session_store.cwd_override
+    boundary_snapshot: BoundarySnapshot | None = None
     capabilities: Any = None  # RuntimeCapabilities，从父会话继承
     available_tools: list[Any] = field(default_factory=list)
     """子 loop 实际注册工具池（assemble_tool_pool 结果）；供 scope 裁决与 adapter 对齐。"""
@@ -251,10 +256,10 @@ def create_subagent_context(
     parent_store = getattr(parent_ctx, "session_store", None)
     session_store: Any = parent_store
     # P0-1 修复：子代理默认隔离 session_store
-    # 无论 plain 还是 fork 模式，子代理都应使用 clone(file_state_only=True)
-    # 来继承文件读状态，但隔离 cwd_override、granted_roots、权限缓存等运行态
+    # 无论 plain 还是 fork 模式，子代理都应使用 clone(file_state_only=True, inherit_grants=True)
+    # 来继承文件读状态 + spawn 时刻 grant 快照，但隔离 cwd_override、权限缓存等运行态
     if isinstance(parent_store, AgentSessionStore):
-        session_store = parent_store.clone(file_state_only=True)
+        session_store = parent_store.clone(file_state_only=True, inherit_grants=True)
 
     # 写入 cwd 到子会话 session_store.cwd_override（runtime state SSOT）
     # 这确保后续 LangChainAdapter.build_tool_execution_context() 和
@@ -275,6 +280,11 @@ def create_subagent_context(
         else QuerySource.for_agent(subagent_type, is_builtin=is_builtin_subagent)
     )
 
+    boundary_snapshot = BoundarySnapshotPropagator.from_parent(
+        parent_ctx,
+        effective_cwd=effective_cwd,
+    )
+
     return SubagentContext(
         agent_id=agent_id,
         initial_messages=initial_messages,
@@ -301,6 +311,7 @@ def create_subagent_context(
         workspace_root=str(parent_workspace_root),
         agent_home_segment=str(parent_agent_home),
         cwd=effective_cwd,
+        boundary_snapshot=boundary_snapshot,
         capabilities=getattr(parent_ctx, "capabilities", None),
         runnable_config=getattr(parent_ctx, "runnable_config", None),
         available_tools=list(available_tools or []),
@@ -331,13 +342,14 @@ class ForkedParentRuntime:
     capabilities: Any = None
     cwd: str | None = None
     thinking_generation_enabled: bool | None = None
+    boundary_snapshot: BoundarySnapshot | None = None
 
 
 def _clone_parent_session_store(parent_store: Any) -> Any:
     from langchain_agentx.tool_runtime.session_store import AgentSessionStore
 
     if isinstance(parent_store, AgentSessionStore):
-        return parent_store.clone(file_state_only=True)
+        return parent_store.clone(file_state_only=True, inherit_grants=True)
     return parent_store
 
 
@@ -422,6 +434,11 @@ class SubagentContextFactory:
         if hasattr(session_store, "set_cwd"):
             session_store.set_cwd(effective_cwd)
 
+        boundary_snapshot = BoundarySnapshotPropagator.from_fork_parent_runtime(
+            parent_runtime,
+            effective_cwd=effective_cwd,
+        )
+
         return SubagentContext(
             agent_id=agent_id,
             initial_messages=initial_messages,
@@ -443,6 +460,7 @@ class SubagentContextFactory:
             workspace_root=workspace_root,
             agent_home_segment=agent_home_segment,
             cwd=effective_cwd,
+            boundary_snapshot=boundary_snapshot,
             capabilities=parent_runtime.capabilities,
             available_tools=self._list_registry_tools(parent_runtime.tool_registry),
             query_source=normalized_source,

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/loop/subagent/graph.py

@@ -69,9 +69,15 @@ def create_subagent_graph(
             system=ctx.system_prompt or None,
             thinking_generation_enabled=ctx.thinking_generation_enabled,
         ),
-        workspace=AgentStateConfig(
-            workspace_root=ctx.workspace_root or None,
-            agent_home_segment=ctx.agent_home_segment,
+        workspace=(
+            ctx.boundary_snapshot.to_agent_state_config(
+                agent_home_segment=ctx.agent_home_segment,
+            )
+            if ctx.boundary_snapshot is not None
+            else AgentStateConfig(
+                workspace_root=ctx.workspace_root or None,
+                agent_home_segment=ctx.agent_home_segment,
+            )
         ),
         trace=TraceConfig(
             enabled=ctx.enable_trace,

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/tool_runtime/session_store.py

@@ -343,13 +343,22 @@ class AgentSessionStore:
         parent = self.get_denial_tracker()
         return parent.fork_local()
 
-    # ---- fork：仅克隆文件读状态（权限 / cwd / glob / denial 不共享）----
+    # ---- fork：克隆文件读状态；可选继承 spawn 时刻 grant 快照 ----
 
-    def clone(self, *, file_state_only: bool = True) -> AgentSessionStore:
+    def clone(
+        self,
+        *,
+        file_state_only: bool = True,
+        inherit_grants: bool = False,
+    ) -> AgentSessionStore:
         new = AgentSessionStore(session_id=str(uuid.uuid4()))
         new._file_read_state = {
             k: copy.deepcopy(v) for k, v in self._file_read_state.items()
         }
+        if inherit_grants:
+            new._granted_roots = copy.deepcopy(self._granted_roots)
+            new.enable_dynamic_root_grant = self.enable_dynamic_root_grant
+            new._boundary_for_grant = self._boundary_for_grant
         if not file_state_only:
             new._audit_log = copy.deepcopy(self._audit_log)
             new._file_history = copy.deepcopy(self._file_history)

{langchain-agentx-python-1.5.8 → langchain-agentx-python-1.6.0}/langchain_agentx/workflow/base.py

@@ -261,6 +261,18 @@ class BaseWorkflow(ABC):
         """导出 event adapter 所需的 workflow_structure（子类 override）。"""
         return {}
 
+    def _build_effective_event_adapter_structure(
+        self,
+        workflow_structure: dict | None,
+    ) -> dict:
+        """合并 derived + caller override，并对 Structured Workflow 做 fail-fast 校验。"""
+        from .structure_validation import validate_event_adapter_structure
+
+        derived_structure = self.export_event_adapter_structure()
+        effective_structure = {**derived_structure, **(workflow_structure or {})}
+        validate_event_adapter_structure(self, effective_structure)
+        return effective_structure
+
     async def run(
         self,
         initial_state: dict,
@@ -518,8 +530,7 @@ class BaseWorkflow(ABC):
         workflow_adapter_config = config.get("workflow_adapter")
         if not isinstance(workflow_adapter_config, dict):
             workflow_adapter_config = {}
-        derived_structure = self.export_event_adapter_structure()
-        effective_structure = {**derived_structure, **(workflow_structure or {})}
+        effective_structure = self._build_effective_event_adapter_structure(workflow_structure)
         if effective_structure:
             workflow_adapter_config = {
                 **workflow_adapter_config,