langchain-agentx-python 1.0.7__tar.gz → 1.0.9__tar.gz

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/PKG-INFO

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

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/__init__.py

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

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/loop/graph/factory.py

@@ -365,13 +365,16 @@ class LoopGraphBuilder:
         self._dynamic_sections: list[SystemPromptSection] = list(self._config.prompt.dynamic_sections)
         append_system_prompt = self._config.prompt.append_system
         self._resolve_workspace_config()
-        self._setup_loader_tools()
+        self._setup_loader_tools(
+            session_store=session_store,
+            model=model,
+            schema_cache_namespace=session_id or "",
+        )
         from ...loop.prompt.tool_aware_sections import (
             build_tool_aware_prompt_sections,
-            collect_enabled_tool_names,
         )
 
-        self._enabled_tool_names = collect_enabled_tool_names(self._loader_tools)
+        runtime_tools = getattr(self, "_runtime_tools", None) or []
         # P0-3: 初始化 session_store.cwd
         # 从 config.workspace.runtime_cwd 或回退到 workspace_root
         if session_store is not None and hasattr(session_store, "set_cwd"):
@@ -463,7 +466,7 @@ class LoopGraphBuilder:
             self._dynamic_sections.extend(
                 build_tool_aware_prompt_sections(
                     self._enabled_tool_names,
-                    loader_tools=self._loader_tools,
+                    runtime_tools=runtime_tools,
                     include_session_memory_mechanics=self._config.enable_session_memory,
                     is_subagent=False,
                 )
@@ -644,8 +647,17 @@ class LoopGraphBuilder:
         if self._services.prompt_handler is not None:
             loader.set_prompt_handler(self._services.prompt_handler)
 
-    def _setup_loader_tools(self) -> None:
+    def _setup_loader_tools(
+        self,
+        *,
+        session_store: Any | None = None,
+        model: Any | None = None,
+        schema_cache_namespace: str | None = None,
+    ) -> None:
         self._loader_tools = []
+        self._runtime_tools = []
+        self._tool_prompt_ctx = None
+        self._enabled_tool_names = frozenset()
         self._skill_runtime_tool = None
         self._loop_loader = None
         if self._services.loader is not None:
@@ -665,11 +677,65 @@ class LoopGraphBuilder:
             for tool in self._services.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():
+            self._runtime_tools = self._loop_loader.registry.list()
+            from ...loop.prompt.tool_aware_sections import collect_enabled_tool_names
+
+            self._enabled_tool_names = collect_enabled_tool_names(self._runtime_tools)
+            self._tool_prompt_ctx = self._build_tool_prompt_context(
+                session_store=session_store,
+                model=model,
+                schema_cache_namespace=schema_cache_namespace,
+            )
+            self._loader_tools = self._loop_loader.registry.to_langchain_tools(
+                prompt_ctx=self._tool_prompt_ctx,
+            )
+            for rt in self._runtime_tools:
                 if self._skill_runtime_tool is None and rt.__class__.__name__ == "SkillRuntimeTool":
                     self._skill_runtime_tool = rt
 
+    def _resolve_policy_config(self) -> Any | None:
+        loader = self._loop_loader or self._services.loader
+        if loader is None:
+            return None
+        policy_cfg = getattr(loader, "policy_config", None)
+        if policy_cfg is None and hasattr(loader, "_process"):
+            policy_cfg = getattr(loader._process, "policy_config", None)
+        return policy_cfg
+
+    def _snapshot_permission_context(
+        self,
+        *,
+        session_store: Any | None = None,
+    ) -> Any:
+        from ...tool_runtime.permission_snapshot import build_permission_snapshot
+
+        return build_permission_snapshot(
+            permission_mode=self._config.permission_mode,
+            policy_config=self._resolve_policy_config(),
+            session_store=session_store,
+        )
+
+    def _build_tool_prompt_context(
+        self,
+        *,
+        session_store: Any | None = None,
+        model: Any | None = None,
+        schema_cache_namespace: str | None = None,
+    ) -> Any:
+        from ...tool_runtime.prompt_context import build_tool_prompt_context
+
+        resolved_model = model if model is not None else self._config.model
+        model_name = getattr(resolved_model, "model_name", None)
+        return build_tool_prompt_context(
+            runtime_tools=self._runtime_tools,
+            enabled_tool_names=self._enabled_tool_names,
+            permission_snapshot=self._snapshot_permission_context(session_store=session_store),
+            workspace_cfg=getattr(self, "_workspace_cfg", None),
+            headless=self._config.headless,
+            model_name=model_name,
+            schema_cache_namespace=schema_cache_namespace,
+        )
+
     def _build_memory_extraction_coordinator(
         self,
         *,

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/loop/prompt/builtin.py

@@ -165,9 +165,12 @@ def task_execution_baseline_section() -> SystemPromptSection:
 
 
 def get_coding_sections() -> list[SystemPromptSection]:
-    """编码场景推荐 section 组合（仅返回列表，是否注入由调用方决定）。"""
+    """编码场景推荐 section 组合（仅返回列表，是否注入由调用方决定）。
+
+    不含 tool_routing_guard：专用工具路由由 build_tool_aware_prompt_sections
+    的 using_your_tools 段按 enabled 工具集注入（CLI-E1 / Phase D SSOT）。
+    """
     return [
-        tool_routing_guard_section(),
         git_safety_section(),
         actions_safety_section(),
         failure_diagnosis_section(),

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/loop/prompt/tool_aware_sections.py

@@ -2,16 +2,16 @@
 loop/prompt/tool_aware_sections.py — 工具感知 Prompt 段与纠偏白名单 SSOT。
 
 职责：
-    从 _loader_tools 提取 enabled_tool_names，统一 gate session_memory_mechanics、
+    从 _runtime_tools 提取 enabled_tool_names，统一 gate session_memory_mechanics、
     agent_tool_guidance 注入，并为 ToolCallDegradationCorrector 白名单提供同源集合。
 
 链路位置：
-    LoopGraphBuilder._setup_loader_tools() → collect_enabled_tool_names；
+    LoopGraphBuilder._setup_loader_tools() → _runtime_tools + _tool_prompt_ctx；
     _prepare_compile_context() → build_tool_aware_prompt_sections（Phase B）；
     _prepare_for_model_nodes() → build_degradation_allowed_tool_names（Phase C）。
 
 当前裁剪范围：
-    v1 仅收拢 session_memory_mechanics、agent_tool_guidance 两段 gate；
+    v1 收拢 session_memory_mechanics、using_your_tools、agent_tool_guidance 三段 gate；
     不含 MemoryPromptBootstrap / get_coding_sections / CLI session_guidance。
 """
 
@@ -56,7 +56,7 @@ def has_enabled_tool(
 def build_tool_aware_prompt_sections(
     enabled: set[str] | frozenset[str],
     *,
-    loader_tools: Sequence[Any],
+    runtime_tools: Sequence[Any],
     include_session_memory_mechanics: bool = True,
     is_subagent: bool = False,
 ) -> list[SystemPromptSection]:
@@ -73,13 +73,25 @@ def build_tool_aware_prompt_sections(
         sections.append(
             section("session_memory_mechanics", build_session_memory_mechanics_prompt)
         )
+    from langchain_agentx.loop.prompt.using_your_tools import (
+        build_using_your_tools_section,
+        should_include_using_your_tools_section,
+    )
+
+    if should_include_using_your_tools_section(enabled):
+        sections.append(
+            section(
+                "using_your_tools",
+                lambda: build_using_your_tools_section(enabled),
+            )
+        )
     if has_enabled_tool(enabled, AGENT_TOOL_NAME, legacy=LEGACY_TOOL_NAME):
         from langchain_agentx.tools.agent.prompt import build_agent_guidance_section
 
         sections.append(
             section(
                 "agent_tool_guidance",
-                lambda: build_agent_guidance_section(list(loader_tools)),
+                lambda: build_agent_guidance_section(list(runtime_tools)),
             )
         )
     return sections

langchain-agentx-python-1.0.9/langchain_agentx/loop/prompt/using_your_tools.py

@@ -0,0 +1,126 @@
+"""
+loop/prompt/using_your_tools.py — 跨工具路由 system 段（CC getUsingYourToolsSection）
+
+职责：
+    按 enabled 工具集生成「专用工具优于 bash」路由护栏，供主 Loop system 动态段注入。
+
+链路位置：
+    build_tool_aware_prompt_sections() → section("using_your_tools")；
+    不注入子 agent（factory is_subagent gate）。
+
+CC 对照：
+    C:/git_code/claude-code-main-ghuntley-03-31/src/constants/prompts.ts getUsingYourToolsSection()
+
+当前裁剪范围：
+    按 enabled 逐项 gate read_file/edit/write/glob/grep/bash/TaskCreate；
+    无 REPL / embedded search 分支（本工程 v1 不启用）。
+"""
+
+from __future__ import annotations
+
+from langchain_agentx.tools.bash.prompt import TOOL_NAME as BASH_TOOL_NAME
+from langchain_agentx.tools.edit.prompt import TOOL_NAME as EDIT_TOOL_NAME
+from langchain_agentx.tools.glob.prompt import TOOL_NAME as GLOB_TOOL_NAME
+from langchain_agentx.tools.grep.prompt import TOOL_NAME as GREP_TOOL_NAME
+from langchain_agentx.tools.read.prompt import TOOL_NAME as READ_TOOL_NAME
+from langchain_agentx.tools.task_create.prompt import TOOL_NAME as TASK_CREATE_TOOL_NAME
+from langchain_agentx.tools.write.prompt import TOOL_NAME as WRITE_TOOL_NAME
+
+SECTION_HEADER = "# Using your tools"
+
+_PARALLEL_BULLET = (
+    "You can call multiple tools in a single response. If you intend to call multiple tools "
+    "and there are no dependencies between them, make all independent tool calls in parallel. "
+    "Maximize use of parallel tool calls where possible to increase efficiency. However, if "
+    "some tool calls depend on previous calls to inform dependent values, do NOT call these "
+    "tools in parallel and instead call them sequentially. For instance, if one operation must "
+    "complete before another starts, run these operations sequentially instead."
+)
+
+_TASK_BULLET = (
+    f"Break down and manage your work with the {TASK_CREATE_TOOL_NAME} tool. These tools are "
+    "helpful for planning your work and helping the user track your progress. Mark each task "
+    "as completed as soon as you are done with the task. Do not batch up multiple tasks before "
+    "marking them as completed."
+)
+
+_BASH_CRITICAL_INTRO = (
+    f"Do NOT use the {BASH_TOOL_NAME} to run commands when a relevant dedicated tool is "
+    "provided. Using dedicated tools allows the user to better understand and review your "
+    f"work. This is CRITICAL to assisting the user:"
+)
+
+
+def _collect_routing_subitems(enabled: set[str] | frozenset[str]) -> list[str]:
+    """按 enabled 集收集专用工具路由子项（对齐 CC providedToolSubitems + gate）。"""
+    items: list[str] = []
+    if READ_TOOL_NAME in enabled:
+        items.append(
+            f"To read files use {READ_TOOL_NAME} instead of cat, head, tail, or sed"
+        )
+    if EDIT_TOOL_NAME in enabled:
+        items.append(f"To edit files use {EDIT_TOOL_NAME} instead of sed or awk")
+    if WRITE_TOOL_NAME in enabled:
+        items.append(
+            f"To create files use {WRITE_TOOL_NAME} instead of cat with heredoc or echo redirection"
+        )
+    if GLOB_TOOL_NAME in enabled:
+        items.append(f"To search for files use {GLOB_TOOL_NAME} instead of find or ls")
+    if GREP_TOOL_NAME in enabled:
+        items.append(
+            f"To search the content of files, use {GREP_TOOL_NAME} instead of grep or rg"
+        )
+    if BASH_TOOL_NAME in enabled:
+        items.append(
+            f"Reserve using the {BASH_TOOL_NAME} exclusively for system commands and terminal "
+            "operations that require shell execution. If you are unsure and there is a relevant "
+            f"dedicated tool, default to using the dedicated tool and only fallback on using "
+            f"the {BASH_TOOL_NAME} tool for these if it is absolutely necessary."
+        )
+    return items
+
+
+def _format_top_level_bullet(text: str) -> str:
+    if "\n" in text:
+        head, *rest = text.split("\n")
+        return "- " + head + "\n" + "\n".join(rest)
+    return f"- {text}"
+
+
+def should_include_using_your_tools_section(enabled: set[str] | frozenset[str]) -> bool:
+    """至少有一种可写路由说明的工具 enabled 时才注入段。"""
+    keys = {
+        READ_TOOL_NAME,
+        EDIT_TOOL_NAME,
+        WRITE_TOOL_NAME,
+        GLOB_TOOL_NAME,
+        GREP_TOOL_NAME,
+        BASH_TOOL_NAME,
+        TASK_CREATE_TOOL_NAME,
+    }
+    return bool(keys & set(enabled))
+
+
+def build_using_your_tools_section(enabled: set[str] | frozenset[str]) -> str | None:
+    """生成 using_your_tools 段正文；无相关内容时返回 None（跳过注入）。"""
+    if not should_include_using_your_tools_section(enabled):
+        return None
+
+    subitems = _collect_routing_subitems(enabled)
+    bullets: list[str] = []
+
+    if BASH_TOOL_NAME in enabled and subitems:
+        nested = "\n".join(f"  - {line}" for line in subitems)
+        bullets.append(f"{_BASH_CRITICAL_INTRO}\n{nested}")
+    elif subitems:
+        bullets.extend(subitems)
+
+    if TASK_CREATE_TOOL_NAME in enabled:
+        bullets.append(_TASK_BULLET)
+
+    if not bullets:
+        return None
+
+    bullets.append(_PARALLEL_BULLET)
+    body = "\n".join(_format_top_level_bullet(b) for b in bullets)
+    return f"{SECTION_HEADER}\n{body}"

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/__init__.py

@@ -23,12 +23,22 @@ from .models import (
     ToolErrorInfo,
     ToolExecutionContext,
     ToolHint,
+    PermissionSnapshot,
+    ToolPromptContext,
     ToolResultEnvelope,
     ValidationResult,
 )
 from .identical_call_cache import IdenticalCallMemo
 from .loader import ToolRuntimeLoader
 from .pipeline import PermissionAskInterrupt, ToolExecutorPipeline, ToolOutputManager
+from .prompt_context import (
+    AGENT_TOOL_NAMES,
+    build_minimal_prompt_ctx,
+    build_tool_prompt_context,
+    minimal_prompt_ctx,
+    resolve_agent_registry,
+)
+from .permission_snapshot import build_permission_snapshot, collect_denied_agent_types
 from .path_safety import PathSafetyConfig, PathSafetyEvaluator
 from .policy import DefaultPolicyEngine, PolicyEngine, ToolPolicyConfig
 from .read_ignore_patterns import ReadDenyPatternCollector, normalize_read_deny_pattern
@@ -77,6 +87,15 @@ __all__ = [
     "ToolResultEnvelope",
     "ValidationResult",
     "AuthorizationDecision",
+    "PermissionSnapshot",
+    "ToolPromptContext",
+    "build_minimal_prompt_ctx",
+    "build_tool_prompt_context",
+    "resolve_agent_registry",
+    "AGENT_TOOL_NAMES",
+    "minimal_prompt_ctx",
+    "build_permission_snapshot",
+    "collect_denied_agent_types",
     "ToolErrorInfo",
     "ToolHint",
     "ToolArtifact",

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/adapter.py

@@ -48,7 +48,7 @@ from langgraph.prebuilt.tool_node import ToolRuntime
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import StructuredTool
 
-from .models import ToolExecutionContext, ToolResultEnvelope, PipelineRunResult
+from .models import ToolExecutionContext, ToolPromptContext, ToolResultEnvelope, PipelineRunResult
 from .errors import truncate_error_text
 from .shell_error import wrap_tool_use_error
 from langchain_agentx.observability.replay.store import (
@@ -361,11 +361,13 @@ class LangChainAdapter:
         tool: Any,  # RuntimeTool，避免循环导入用 Any
         pipeline: ToolExecutorPipeline,
         state_getter: Callable[[], MutableMapping[str, Any]] | None = None,
+        prompt_ctx: ToolPromptContext | None = None,
     ) -> StructuredTool:
         """
         将 RuntimeTool 导出为 LangChain StructuredTool。
 
         args_schema 直接使用 tool.input_model，保证模型可见 schema 稳定。
+        description 来自 ``tool.prompt_for_model(prompt_ctx)``（Phase B；对齐 CC toolToAPISchema）。
         内部 func / coroutine 调用 pipeline.run / arun，
         通过 LangChain 的 config 参数获取 RunnableConfig。
 
@@ -380,6 +382,22 @@ class LangChainAdapter:
         ``invoke()`` 对外仍只暴露 content 字符串；artifact 由 ToolNode 写入 ``ToolMessage.artifact``。
         """
         adapter = self
+        if prompt_ctx is None:
+            prompt_ctx = ToolPromptContext(
+                runtime_tools=(tool,),
+                enabled_tool_names=frozenset({tool.name}),
+            )
+        from .tool_schema_cache import get_tool_schema_cache
+        from .prompt_context import compute_schema_cache_variant
+
+        namespace = prompt_ctx.schema_cache_namespace or ""
+        cache_variant = compute_schema_cache_variant(tool, prompt_ctx)
+        model_description = get_tool_schema_cache().get_or_render(
+            namespace=namespace,
+            tool_name=tool.name,
+            render_fn=lambda: tool.prompt_for_model(prompt_ctx),
+            input_schema_hash=cache_variant,
+        )
         # 在 StructuredTool 构造时从类属性提取，避免每次调用重复读取
         _tool_flags: dict[str, Any] = {
             "is_read_only": getattr(tool, "is_read_only", False),
@@ -487,7 +505,7 @@ class LangChainAdapter:
 
         return StructuredTool(
             name=tool.name,
-            description=tool.description,
+            description=model_description,
             args_schema=tool.input_model,
             func=_func,
             coroutine=_afunc,

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/base.py

@@ -109,6 +109,7 @@ from .models import (
     AuthorizationDecision,
     ToolExecutionContext,
     ToolHint,
+    ToolPromptContext,
     ToolResultEnvelope,
     ValidationResult,
 )
@@ -126,9 +127,14 @@ class RuntimeTool(ABC):
 
     子类必须定义：
         name          — 工具名（唯一，面向模型暴露）
-        description   — 工具描述（面向模型暴露）
+        description   — UI 短摘要（类属性；语义同 summary_for_ui，不用于 API schema）
         input_model   — Pydantic BaseModel，直接作为 StructuredTool.args_schema
 
+    Prompt 分层（对齐 CC description vs prompt）：
+        summary_for_ui      — UI/权限短句（类属性或由 description 自动桥接）
+        prompt_for_model    — API schema 文案（子类覆写 get_prompt 等；Adapter 唯一出口）
+        summary_for_ui_call — 单次调用 UI 摘要
+
     子类可覆盖的生命周期 hook（默认均为 fail-open / no-op）：
         normalize_input     — 输入预处理（路径规范化、默认值填充）
         validate_input      — 语义校验（失败告知模型，可重试）
@@ -149,6 +155,10 @@ class RuntimeTool(ABC):
     # ---- 子类必须定义的类属性 ----
     name: str
     description: str
+    """UI 短摘要类属性；语义同 summary_for_ui。API schema 须经 prompt_for_model。"""
+
+    summary_for_ui: str = ""
+    """UI/权限短句真源；子类未显式定义时由 __init_subclass__ 从 description 桥接。"""
 
     # input_model 必须是 pydantic BaseModel 子类
     # 直接作为 StructuredTool.args_schema 暴露给模型
@@ -186,6 +196,53 @@ class RuntimeTool(ABC):
     对应 CC Tool.maxResultSizeChars。
     """
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if cls is RuntimeTool:
+            return
+        if "summary_for_ui" not in cls.__dict__:
+            desc = cls.__dict__.get("description")
+            if isinstance(desc, str):
+                cls.summary_for_ui = desc
+
+    def _resolve_summary_for_ui(self) -> str:
+        """解析 UI 短摘要：summary_for_ui 类属性 → 静态 description → 动态 description property。"""
+        cls = type(self)
+        ui_summary = cls.__dict__.get("summary_for_ui")
+        if isinstance(ui_summary, str) and ui_summary:
+            return ui_summary
+        desc = cls.__dict__.get("description")
+        if isinstance(desc, str):
+            return desc
+        if isinstance(desc, property):
+            value = self.description
+            return value if isinstance(value, str) else str(value)
+        raw = getattr(self, "description", "")
+        return raw if isinstance(raw, str) else str(raw)
+
+    @property
+    def resolved_summary_for_ui(self) -> str:
+        """实例级 UI 短摘要（兼容类属性 summary_for_ui 与动态 description）。"""
+        return self._resolve_summary_for_ui()
+
+    def prompt_for_model(self, ctx: ToolPromptContext) -> str:
+        """
+        面向模型的 API schema 文案；对齐 CC Tool.prompt()。
+
+        默认回落 summary_for_ui；含 get_prompt SSOT 的工具须子类覆写。
+        """
+        _ = ctx
+        return self._resolve_summary_for_ui()
+
+    def summary_for_ui_call(
+        self,
+        data: dict[str, Any],
+        ctx: ToolExecutionContext,
+    ) -> str:
+        """对齐 CC description(input, ctx)；Bash 等工具在 Phase B 覆写。"""
+        _ = data, ctx
+        return self._resolve_summary_for_ui()
+
     # ---- 调用级能力解析（Phase 1+；默认回落到类属性）----
 
     def compute_is_read_only(

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/models.py

@@ -7,6 +7,7 @@ runtime/models.py — 工具运行时框架核心数据模型
     - ToolResultEnvelope：工具执行统一内部结果协议，分离模型可见输出与内部数据
     - ValidationResult：输入语义校验结果（失败时告知模型，模型可修正重试）
     - AuthorizationDecision：权限授权决策（失败时策略拒绝，不可绕过）
+    - PermissionSnapshot / ToolPromptContext：compile 时工具 prompt 上下文（对齐 CC prompt options）
     - ToolErrorInfo / ToolHint / ToolArtifact：辅助结构
 
 与 CC 对比：
@@ -30,6 +31,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal, MutableMapping
 
 if TYPE_CHECKING:
+    from .base import RuntimeTool
     from .prompt.types import PermissionUpdate
 
 
@@ -430,3 +432,41 @@ class AuthorizationDecision:
     updated_input: dict[str, Any] | None = None
     ask_prompt: str | None = None
     metadata: dict[str, Any] | None = None
+
+
+# ---------------------------------------------------------------------------
+# Tool prompt context（compile 时构建；对齐 CC tool.prompt(options)）
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class PermissionSnapshot:
+    """compile 时权限快照；对齐 CC ToolPermissionContext 子集。"""
+
+    mode: str
+    """权限模式：default | acceptEdits | bypassPermissions 等。"""
+
+    denied_agent_types: frozenset[str] = field(default_factory=frozenset)
+    """对应 CC filterDeniedAgents。"""
+
+    auto_approved_tools: frozenset[str] = field(default_factory=frozenset)
+    """自动放行工具名集合。"""
+
+
+@dataclass(frozen=True)
+class ToolPromptContext:
+    """
+    compile 时工具 prompt 上下文；供 RuntimeTool.prompt_for_model() 与 Adapter 消费。
+
+    对齐 CC tool.prompt(options) / toolToAPISchema 传参；在 graph compile 时同步构建，
+    非 invoke 时懒建。
+    """
+
+    runtime_tools: Sequence["RuntimeTool"]
+    enabled_tool_names: frozenset[str]
+    agent_registry: Any | None = None
+    permission_snapshot: PermissionSnapshot | None = None
+    workspace_cfg: Any | None = None
+    headless: bool = False
+    allowed_agent_types: frozenset[str] | None = None
+    model_name: str | None = None
+    schema_cache_namespace: str | None = None

langchain-agentx-python-1.0.9/langchain_agentx/tool_runtime/permission_snapshot.py

@@ -0,0 +1,53 @@
+"""
+tool_runtime/permission_snapshot.py — compile 时 PermissionSnapshot 构建
+
+职责：
+    从 loop_config / ToolPolicyConfig / session_store 同步快照权限上下文，
+    供 ToolPromptContext 与 Agent prompt_scope 过滤消费。
+
+链路位置：
+    LoopGraphBuilder._snapshot_permission_context() → ToolPromptContext.permission_snapshot
+
+当前裁剪范围：
+    denied_agent_types 解析 Agent(subagent) deny_globs；MCP 过滤在 prompt_scope。
+"""
+
+from __future__ import annotations
+
+import re
+
+from .models import PermissionSnapshot
+from .permission_context import get_active_auto_approved_tools
+from .policy import ToolPolicyConfig
+from .session_store import AgentSessionStore
+
+_AGENT_DENY_RE = re.compile(r"^Agent\(([^)]+)\)$", re.I)
+
+
+def collect_denied_agent_types(
+    policy_config: ToolPolicyConfig | None,
+) -> frozenset[str]:
+    """从 deny_globs 提取 Agent(Explore) 等子 agent 拒绝名（≡ CC agentType）。"""
+    if policy_config is None:
+        return frozenset()
+    denied: set[str] = set()
+    for pattern in policy_config.deny_globs:
+        m = _AGENT_DENY_RE.match(pattern.strip())
+        if m:
+            denied.add(m.group(1).strip())
+    return frozenset(denied)
+
+
+def build_permission_snapshot(
+    *,
+    permission_mode: str,
+    policy_config: ToolPolicyConfig | None,
+    session_store: AgentSessionStore | None = None,
+) -> PermissionSnapshot:
+    """compile 时构建权限快照；invoke 时不再重算。"""
+    active = get_active_auto_approved_tools(session_store)
+    return PermissionSnapshot(
+        mode=permission_mode,
+        denied_agent_types=collect_denied_agent_types(policy_config),
+        auto_approved_tools=frozenset(active),
+    )

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/pipeline.py

@@ -1077,6 +1077,7 @@ class ToolExecutorPipeline:
             ctx=ctx,
             ask_decision=auth,
             ask_prompt=auth.ask_prompt,
+            display_label=tool.summary_for_ui_call(parsed_data, ctx),
             suggestions=self._suggestions_from_auth(auth),
             headless=False,
             session_headless=self._headless,

{langchain-agentx-python-1.0.7 → langchain-agentx-python-1.0.9}/langchain_agentx/tool_runtime/prompt/types.py

@@ -104,6 +104,8 @@ class PromptRequest:
     session_headless: bool = False
     """会话级 headless（对齐 CC shouldAvoidPermissionPrompts）。"""
     ask_prompt: str | None = None
+    display_label: str | None = None
+    """UI 短摘要；来自 tool.summary_for_ui_call()。None 时 L3 fallback tool_name。"""
     suggestions: tuple[PermissionUpdate, ...] = field(default_factory=tuple)