acpkit 0.9.2__tar.gz → 0.9.3__tar.gz

acpkit-0.9.3/COVERAGE

@@ -0,0 +1,2 @@
+Line coverage: 100.00% (8781 / 8781)
+Branch coverage: 100.00% (2942 / 2942)

{acpkit-0.9.2 → acpkit-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acpkit
-Version: 0.9.2
+Version: 0.9.3
 Summary: ACP Kit provides a common adapter for Agent Frameworks.
 Project-URL: Homepage, https://vcoderun.github.io/acpkit/
 Project-URL: Issues, https://github.com/vcoderun/acpkit/issues
@@ -16,31 +16,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.8
-Requires-Dist: fast-agent-mcp>=0.2.25
-Requires-Dist: mcp>=1.27.0
 Requires-Dist: typing-extensions>=4.12.0
 Provides-Extra: all
 Requires-Dist: acpremote; extra == 'all'
-Requires-Dist: agent-client-protocol>=0.9.0; extra == 'all'
-Requires-Dist: basedpyright; extra == 'all'
 Requires-Dist: codex-auth-helper; extra == 'all'
 Requires-Dist: langchain-acp; extra == 'all'
 Requires-Dist: langchain-acp[deepagents]; extra == 'all'
-Requires-Dist: langchain-openai>=0.3.26; extra == 'all'
-Requires-Dist: mkdocs-material; extra == 'all'
-Requires-Dist: mkdocstrings[python]; extra == 'all'
-Requires-Dist: pre-commit; extra == 'all'
 Requires-Dist: pydantic-acp; extra == 'all'
-Requires-Dist: pydantic-ai-slim; extra == 'all'
-Requires-Dist: pydantic-graph; extra == 'all'
-Requires-Dist: pydantic>=2.7; extra == 'all'
-Requires-Dist: pytest; extra == 'all'
-Requires-Dist: pytest-asyncio; extra == 'all'
-Requires-Dist: pytest-cov; extra == 'all'
-Requires-Dist: python-dotenv; extra == 'all'
-Requires-Dist: ruff; extra == 'all'
-Requires-Dist: ty; extra == 'all'
-Requires-Dist: typing-extensions>=4.12.0; extra == 'all'
 Requires-Dist: uv>=0.8.3; extra == 'all'
 Provides-Extra: codex
 Requires-Dist: codex-auth-helper; extra == 'codex'
@@ -65,6 +47,29 @@ Requires-Dist: python-dotenv; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: ty; extra == 'dev'
 Requires-Dist: typing-extensions>=4.12.0; extra == 'dev'
+Provides-Extra: dev-all
+Requires-Dist: acpremote; extra == 'dev-all'
+Requires-Dist: agent-client-protocol>=0.9.0; extra == 'dev-all'
+Requires-Dist: basedpyright; extra == 'dev-all'
+Requires-Dist: codex-auth-helper; extra == 'dev-all'
+Requires-Dist: langchain-acp; extra == 'dev-all'
+Requires-Dist: langchain-acp[deepagents]; extra == 'dev-all'
+Requires-Dist: langchain-openai>=0.3.26; extra == 'dev-all'
+Requires-Dist: mkdocs-material; extra == 'dev-all'
+Requires-Dist: mkdocstrings[python]; extra == 'dev-all'
+Requires-Dist: pre-commit; extra == 'dev-all'
+Requires-Dist: pydantic-acp; extra == 'dev-all'
+Requires-Dist: pydantic-ai-slim; extra == 'dev-all'
+Requires-Dist: pydantic-graph; extra == 'dev-all'
+Requires-Dist: pydantic>=2.7; extra == 'dev-all'
+Requires-Dist: pytest; extra == 'dev-all'
+Requires-Dist: pytest-asyncio; extra == 'dev-all'
+Requires-Dist: pytest-cov; extra == 'dev-all'
+Requires-Dist: python-dotenv; extra == 'dev-all'
+Requires-Dist: ruff; extra == 'dev-all'
+Requires-Dist: ty; extra == 'dev-all'
+Requires-Dist: typing-extensions>=4.12.0; extra == 'dev-all'
+Requires-Dist: uv>=0.8.3; extra == 'dev-all'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material; extra == 'docs'
 Requires-Dist: mkdocstrings[python]; extra == 'docs'

acpkit-0.9.3/VERSION

@@ -0,0 +1 @@
+0.9.3

{acpkit-0.9.2 → acpkit-0.9.3}/docs/langchain-acp.md

@@ -82,10 +82,13 @@ called inside `graph_factory=...`.
 - `AdapterConfig`
 - explicit session stores and transcript replay
 - provider-owned models, modes, and config options
+- prompt capability advertisement
 - native ACP plan state with `TaskPlan`
-- approval bridging
+- approval bridging with projection-aware permission cards
 - capability bridges
+- built-in and host-defined slash commands
 - projection maps and event projection maps
+- external hook event projection
 - ACP-facing type exports in `langchain_acp.types`
 
 The important difference is upstream shape, not ACP Kit architecture. On the LangChain side the adapter deals in graphs and middleware instead of model profiles and tool preparers.
@@ -133,6 +136,51 @@ The point is not to make the adapter magical. The point is to keep the host,
 the graph, and the ACP surface aligned without inventing runtime state the graph
 cannot really honor.
 
+## Prompt Capabilities And Slash Commands
+
+Prompt capability advertisement is configurable instead of hardcoded:
+
+```python
+from langchain_acp import AdapterConfig, AdapterPromptCapabilities
+
+config = AdapterConfig(
+    prompt_capabilities=AdapterPromptCapabilities(
+        audio=False,
+        image=False,
+        embedded_context=True,
+    )
+)
+```
+
+The adapter also owns an ACP-native slash-command layer:
+
+- mode commands such as `/ask`
+- `/model`
+- `/tools`
+- `/mcp-servers`
+- custom host commands through `slash_command_provider`
+
+```python
+from acp.schema import AvailableCommand
+from langchain_acp import (
+    AdapterConfig,
+    SlashCommandResult,
+    StaticSlashCommand,
+    StaticSlashCommandProvider,
+)
+
+config = AdapterConfig(
+    slash_command_provider=StaticSlashCommandProvider(
+        commands=[
+            StaticSlashCommand(
+                command=AvailableCommand(name="ping", description="Return pong."),
+                handler=lambda _request: SlashCommandResult(text="pong"),
+            )
+        ]
+    )
+)
+```
+
 ## Session Lifecycle And Replay
 
 Session lifecycle is first-class:
@@ -209,10 +257,23 @@ The adapter surface is:
 
 - `ApprovalBridge`
 - `NativeApprovalBridge`
+- `ProjectionAwareApprovalBridge`
+- `PermissionToolCallBuilder`
+- `ApprovalPolicyStore`
 - ACP permission requests and resume flow
 
 When the runtime really pauses for approval, the ACP session pauses for approval too.
 
+Remembered approval choices and permission card rendering live on `NativeApprovalBridge`:
+
+```python
+from langchain_acp import NativeApprovalBridge
+
+config = AdapterConfig(
+    approval_bridge=NativeApprovalBridge(enable_persistent_choices=True),
+)
+```
+
 ## Capability Bridges And Graph Build Contributions
 
 ACP Kit's bridge architecture remains intact in the LangChain adapter.
@@ -224,6 +285,7 @@ Built-in bridges:
 - `ConfigOptionsBridge`
 - `ToolSurfaceBridge`
 - `DeepAgentsCompatibilityBridge`
+- `ExternalHookEventBridge`
 
 Graph-build contributions are aggregated through:
 

{acpkit-0.9.2 → acpkit-0.9.3}/packages/adapters/langchain-acp/README.md

@@ -105,10 +105,14 @@ acp_agent = create_acp_agent(graph_factory=graph_from_session)
 
 - session stores and transcript replay
 - model, mode, and config-option providers
+- prompt capability advertisement through `prompt_capabilities`
 - native plan state through `TaskPlan`
 - approval bridging from `HumanInTheLoopMiddleware`
+- remembered approval policies and permission card rendering on `NativeApprovalBridge`
 - capability bridges and graph-build contributions
+- built-in and host-defined slash commands
 - tool projection maps and event projection maps
+- external hook/event projection through `ExternalHookEventBridge`
 - `graph`, `graph_factory`, and `graph_source`
 - DeepAgents compatibility helpers where they add truthful ACP behavior
 
@@ -120,6 +124,64 @@ That means the adapter can expose:
 
 without collapsing everything into a bespoke ACP runtime.
 
+## Runtime Controls
+
+The adapter now owns a small ACP-native slash-command layer instead of leaving that surface entirely to the graph:
+
+- mode commands such as `/ask` or `/review` when the session publishes modes
+- `/model` for ACP-owned model selection
+- `/tools` for the active graph tool node
+- `/mcp-servers` for attached session MCP servers
+- custom host commands through `slash_command_provider`
+
+Example:
+
+```python
+from acp.schema import AvailableCommand
+from langchain_acp import (
+    AdapterConfig,
+    SlashCommandResult,
+    StaticSlashCommand,
+    StaticSlashCommandProvider,
+)
+
+config = AdapterConfig(
+    slash_command_provider=StaticSlashCommandProvider(
+        commands=[
+            StaticSlashCommand(
+                command=AvailableCommand(name="ping", description="Return pong."),
+                handler=lambda _request: SlashCommandResult(text="pong"),
+            )
+        ]
+    )
+)
+```
+
+Prompt capability advertisement is also explicit now:
+
+```python
+from langchain_acp import AdapterConfig, AdapterPromptCapabilities
+
+config = AdapterConfig(
+    prompt_capabilities=AdapterPromptCapabilities(
+        audio=False,
+        image=False,
+        embedded_context=True,
+    )
+)
+```
+
+If the graph uses approval middleware, remembered choices and ACP permission presentation stay on
+`NativeApprovalBridge`, not on `AdapterConfig`:
+
+```python
+from langchain_acp import NativeApprovalBridge
+
+config = AdapterConfig(
+    approval_bridge=NativeApprovalBridge(enable_persistent_choices=True),
+)
+```
+
 ## Session-owned Graph Rebuilds
 
 If ACP session state should decide which graph gets built, `graph_factory=` is the intended seam:

acpkit-0.9.3/packages/adapters/langchain-acp/VERSION

@@ -0,0 +1 @@
+0.9.3

{acpkit-0.9.2 → acpkit-0.9.3}/packages/adapters/langchain-acp/pyproject.toml

@@ -18,6 +18,7 @@ dependencies = [
     "agent-client-protocol>=0.9.0",
     "langchain>=1.0.0",
     "langgraph>=1.0.0",
+    "pydantic>=2.7",
     "typing-extensions>=4.12.0",
 ]
 

{acpkit-0.9.2 → acpkit-0.9.3}/packages/adapters/langchain-acp/src/langchain_acp/__init__.py

@@ -1,12 +1,26 @@
 from __future__ import annotations as _annotations
 
 from ._version import __version__
-from .approvals import ApprovalBridge, ApprovalDecision, NativeApprovalBridge
+from .approval_store import (
+    ApprovalPolicy,
+    ApprovalPolicyStore,
+    PermissionOptionSet,
+    SessionMetadataApprovalPolicyStore,
+)
+from .approvals import (
+    ApprovalBridge,
+    ApprovalDecision,
+    NativeApprovalBridge,
+    ProjectionAwareApprovalBridge,
+    supports_projection_aware_approval_bridge,
+)
 from .bridges import (
     BufferedCapabilityBridge,
     CapabilityBridge,
     ConfigOptionsBridge,
     DeepAgentsCompatibilityBridge,
+    EventEmissionMode,
+    ExternalHookEventBridge,
     ModelSelectionBridge,
     ModeSelectionBridge,
     ToolSurfaceBridge,
@@ -26,6 +40,12 @@ from .graph_source import (
     GraphSource,
     StaticGraphSource,
 )
+from .hook_projection import HookEvent, HookProjectionMap
+from .permission_presentation import (
+    DefaultPermissionToolCallBuilder,
+    PermissionRequestContext,
+    PermissionToolCallBuilder,
+)
 from .plan import (
     NativePlanGeneration,
     PlanGenerationType,
@@ -46,6 +66,7 @@ from .projection import (
     FileSystemProjectionMap,
     FinanceProjectionMap,
     HttpRequestProjectionMap,
+    ProjectionAwareToolClassifier,
     ProjectionMap,
     ToolClassifier,
     WebFetchProjectionMap,
@@ -55,6 +76,7 @@ from .projection import (
     compose_projection_maps,
     extract_tool_call_locations,
 )
+from .prompt_capabilities import AdapterPromptCapabilities
 from .providers import (
     ConfigOption,
     ConfigOptionsProvider,
@@ -73,6 +95,14 @@ from .session import (
     MemorySessionStore,
     SessionStore,
 )
+from .slash import (
+    SlashCommandHandler,
+    SlashCommandProvider,
+    SlashCommandRequest,
+    SlashCommandResult,
+    StaticSlashCommand,
+    StaticSlashCommandProvider,
+)
 from .types import (
     AcpAgent,
     AgentPromptBlock,
@@ -94,8 +124,11 @@ __all__ = (
     "AcpAgent",
     "AcpSessionContext",
     "AdapterConfig",
+    "AdapterPromptCapabilities",
     "AgentPromptBlock",
     "ApprovalBridge",
+    "ApprovalPolicy",
+    "ApprovalPolicyStore",
     "CompositeEventProjectionMap",
     "ApprovalDecision",
     "AudioContentBlock",
@@ -117,7 +150,9 @@ __all__ = (
     "DeepAgentsProjectionMap",
     "DeepAgentsCompatibilityBridge",
     "EmbeddedResourceContentBlock",
+    "EventEmissionMode",
     "EventProjectionMap",
+    "ExternalHookEventBridge",
     "FactoryGraphSource",
     "FileSessionStore",
     "FileSystemProjectionMap",
@@ -126,6 +161,8 @@ __all__ = (
     "GraphBridgeBuilder",
     "GraphBuildContributions",
     "GraphSource",
+    "HookEvent",
+    "HookProjectionMap",
     "HttpRequestProjectionMap",
     "HttpMcpServer",
     "ImageContentBlock",
@@ -143,14 +180,27 @@ __all__ = (
     "PlanEntry",
     "PlanGenerationType",
     "PlanProvider",
+    "ProjectionAwareApprovalBridge",
+    "ProjectionAwareToolClassifier",
     "ProjectionMap",
+    "PermissionOptionSet",
+    "PermissionRequestContext",
+    "PermissionToolCallBuilder",
+    "DefaultPermissionToolCallBuilder",
     "ResourceContentBlock",
+    "SessionMetadataApprovalPolicyStore",
     "SessionModelsProvider",
     "SessionModesProvider",
     "SessionStore",
     "StaticGraphSource",
     "StructuredEventProjectionMap",
     "SseMcpServer",
+    "SlashCommandHandler",
+    "SlashCommandProvider",
+    "SlashCommandRequest",
+    "SlashCommandResult",
+    "StaticSlashCommand",
+    "StaticSlashCommandProvider",
     "TaskPlan",
     "TextContentBlock",
     "TextResourceContents",
@@ -170,4 +220,5 @@ __all__ = (
     "extract_tool_call_locations",
     "native_plan_tools",
     "run_acp",
+    "supports_projection_aware_approval_bridge",
 )

acpkit-0.9.3/packages/adapters/langchain-acp/src/langchain_acp/_slash_commands.py

@@ -0,0 +1,46 @@
+from __future__ import annotations as _annotations
+
+from collections.abc import Iterable
+
+__all__ = (
+    "MCP_SERVERS_COMMAND_NAME",
+    "MODEL_COMMAND_NAME",
+    "RESERVED_SLASH_COMMAND_NAMES",
+    "TOOLS_COMMAND_NAME",
+    "validate_mode_command_ids",
+)
+
+MODEL_COMMAND_NAME = "model"
+TOOLS_COMMAND_NAME = "tools"
+MCP_SERVERS_COMMAND_NAME = "mcp-servers"
+RESERVED_SLASH_COMMAND_NAMES = frozenset(
+    {
+        MODEL_COMMAND_NAME,
+        TOOLS_COMMAND_NAME,
+        MCP_SERVERS_COMMAND_NAME,
+    }
+)
+
+
+def validate_mode_command_ids(mode_ids: Iterable[str]) -> None:
+    normalized_ids: list[str] = []
+    for mode_id in mode_ids:
+        normalized_id = mode_id.strip().lower()
+        if not normalized_id:
+            raise ValueError("Mode slash command ids must be non-empty after normalization.")
+        if any(character.isspace() for character in normalized_id):
+            raise ValueError(
+                f"Mode slash command id {mode_id!r} cannot contain whitespace after normalization."
+            )
+        normalized_ids.append(normalized_id)
+    duplicate_ids = sorted(
+        mode_id for mode_id in set(normalized_ids) if normalized_ids.count(mode_id) > 1
+    )
+    if duplicate_ids:
+        raise ValueError(f"Duplicate ids: {', '.join(duplicate_ids)}.")
+    reserved_ids = sorted(set(normalized_ids) & RESERVED_SLASH_COMMAND_NAMES)
+    if reserved_ids:
+        raise ValueError(
+            "Mode slash command ids cannot reuse reserved slash command names "
+            f"({', '.join(reserved_ids)})."
+        )

{acpkit-0.9.2/packages/adapters/pydantic-acp/src/pydantic_acp → acpkit-0.9.3/packages/adapters/langchain-acp/src/langchain_acp}/_version.py

@@ -2,4 +2,4 @@ from __future__ import annotations as _annotations
 
 __all__ = ("__version__",)
 
-__version__ = "0.9.2"
+__version__ = "0.9.3"

acpkit-0.9.3/packages/adapters/langchain-acp/src/langchain_acp/approvals.py

@@ -0,0 +1,208 @@
+from __future__ import annotations as _annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from acp.exceptions import RequestError
+from acp.interfaces import Client as AcpClient
+from acp.schema import PermissionOption
+from typing_extensions import TypeIs
+
+from .approval_store import (
+    ApprovalPolicy,
+    ApprovalPolicyStore,
+    PermissionOptionSet,
+    SessionMetadataApprovalPolicyStore,
+)
+from .permission_presentation import (
+    DefaultPermissionToolCallBuilder,
+    PermissionRequestContext,
+    PermissionToolCallBuilder,
+)
+from .projection import ProjectionMap, ToolClassifier
+from .session.state import AcpSessionContext
+
+__all__ = (
+    "ApprovalBridge",
+    "ApprovalDecision",
+    "NativeApprovalBridge",
+    "ProjectionAwareApprovalBridge",
+    "supports_projection_aware_approval_bridge",
+)
+
+
+@dataclass(slots=True, frozen=True, kw_only=True)
+class ApprovalDecision:
+    decisions: list[dict[str, Any]]
+    cancelled: bool = False
+
+
+class ApprovalBridge(Protocol):
+    async def resolve_action_requests(
+        self,
+        *,
+        client: AcpClient,
+        session: AcpSessionContext,
+        action_requests: list[dict[str, Any]],
+        review_configs: list[dict[str, Any]],
+        classifier: ToolClassifier,
+    ) -> ApprovalDecision: ...
+
+
+class ProjectionAwareApprovalBridge(Protocol):
+    async def resolve_action_requests(
+        self,
+        *,
+        client: AcpClient,
+        session: AcpSessionContext,
+        action_requests: list[dict[str, Any]],
+        review_configs: list[dict[str, Any]],
+        classifier: ToolClassifier,
+        projection_map: ProjectionMap | None,
+    ) -> ApprovalDecision: ...
+
+
+def supports_projection_aware_approval_bridge(
+    bridge: ApprovalBridge | ProjectionAwareApprovalBridge | None,
+) -> TypeIs[ProjectionAwareApprovalBridge]:
+    if bridge is None:
+        return False
+    return hasattr(bridge, "_supports_projection_aware_approval_bridge")
+
+
+@dataclass(slots=True, kw_only=True)
+class NativeApprovalBridge:
+    enable_persistent_choices: bool = False
+    option_set: PermissionOptionSet = field(default_factory=PermissionOptionSet)
+    policy_store: ApprovalPolicyStore = field(default_factory=SessionMetadataApprovalPolicyStore)
+    tool_call_builder: PermissionToolCallBuilder = field(
+        default_factory=DefaultPermissionToolCallBuilder
+    )
+    _supports_projection_aware_approval_bridge: bool = field(
+        default=True,
+        init=False,
+        repr=False,
+    )
+
+    async def resolve_action_requests(
+        self,
+        *,
+        client: AcpClient,
+        session: AcpSessionContext,
+        action_requests: list[dict[str, Any]],
+        review_configs: list[dict[str, Any]],
+        classifier: ToolClassifier,
+        projection_map: ProjectionMap | None = None,
+    ) -> ApprovalDecision:
+        decisions: list[dict[str, Any]] = []
+        config_by_action = {
+            config.get("action_name"): config
+            for config in review_configs
+            if isinstance(config, dict)
+        }
+        for action_request in action_requests:
+            if not isinstance(action_request, dict):
+                raise RequestError.invalid_request({"action_request": action_request})
+            tool_name = action_request.get("name")
+            tool_args = action_request.get("args", {})
+            if not isinstance(tool_name, str) or not isinstance(tool_args, dict):
+                raise RequestError.invalid_request({"action_request": action_request})
+            policy_key = classifier.approval_policy_key(tool_name, tool_args)
+            remembered_policy = (
+                self.policy_store.get_policy(session, policy_key)
+                if self.enable_persistent_choices
+                else None
+            )
+            if remembered_policy == "allow":
+                decisions.append({"type": "approve"})
+                continue
+            if remembered_policy == "reject":
+                decisions.append({"type": "reject"})
+                continue
+            review_config = config_by_action.get(tool_name, {})
+            allowed_decisions = review_config.get("allowed_decisions", ["approve", "reject"])
+            if "edit" in allowed_decisions and set(allowed_decisions) == {"edit"}:
+                raise RequestError.invalid_request(
+                    {"reason": "ACP permission prompts cannot collect edited tool arguments."}
+                )
+            permission = await client.request_permission(
+                session_id=session.session_id,
+                options=self._build_permission_options(),
+                tool_call=self.tool_call_builder.build_tool_call_update(
+                    PermissionRequestContext(
+                        session=session,
+                        tool_call_id=self._tool_call_id(action_request, tool_name),
+                        tool_name=tool_name,
+                        raw_input=tool_args,
+                        cwd=session.cwd,
+                        classifier=classifier,
+                        projection_map=projection_map,
+                    )
+                ),
+            )
+            outcome = permission.outcome
+            if outcome.outcome == "cancelled":
+                return ApprovalDecision(decisions=decisions, cancelled=True)
+            option_id = getattr(outcome, "option_id", None)
+            if option_id == "allow_once":
+                decisions.append({"type": "approve"})
+                continue
+            if option_id == "reject_once":
+                decisions.append({"type": "reject"})
+                continue
+            if option_id == "allow_always":
+                self._remember_policy(session, policy_key, "allow")
+                decisions.append({"type": "approve"})
+                continue
+            if option_id == "reject_always":
+                self._remember_policy(session, policy_key, "reject")
+                decisions.append({"type": "reject"})
+                continue
+            raise RequestError.invalid_request({"optionId": option_id})
+        return ApprovalDecision(decisions=decisions)
+
+    def _build_permission_options(self) -> list[PermissionOption]:
+        options = [
+            PermissionOption(
+                option_id="allow_once",
+                name=self.option_set.allow_once_name,
+                kind="allow_once",
+            ),
+            PermissionOption(
+                option_id="reject_once",
+                name=self.option_set.reject_once_name,
+                kind="reject_once",
+            ),
+        ]
+        if self.enable_persistent_choices:
+            options.extend(
+                [
+                    PermissionOption(
+                        option_id="allow_always",
+                        name=self.option_set.allow_always_name,
+                        kind="allow_always",
+                    ),
+                    PermissionOption(
+                        option_id="reject_always",
+                        name=self.option_set.reject_always_name,
+                        kind="reject_always",
+                    ),
+                ]
+            )
+        return options
+
+    def _remember_policy(
+        self,
+        session: AcpSessionContext,
+        policy_key: str,
+        policy: ApprovalPolicy,
+    ) -> None:
+        if not self.enable_persistent_choices:
+            return
+        self.policy_store.set_policy(session, policy_key, policy)
+
+    def _tool_call_id(self, action_request: dict[str, Any], tool_name: str) -> str:
+        action_id = action_request.get("id")
+        if isinstance(action_id, str) and action_id:
+            return action_id
+        return f"hitl:{tool_name}"

{acpkit-0.9.2 → acpkit-0.9.3}/packages/adapters/langchain-acp/src/langchain_acp/bridges/__init__.py

@@ -8,12 +8,15 @@ from .builtin import (
     ModeSelectionBridge,
     ToolSurfaceBridge,
 )
+from .external_hooks import EventEmissionMode, ExternalHookEventBridge
 
 __all__ = (
     "BufferedCapabilityBridge",
     "CapabilityBridge",
     "ConfigOptionsBridge",
     "DeepAgentsCompatibilityBridge",
+    "EventEmissionMode",
+    "ExternalHookEventBridge",
     "ModeSelectionBridge",
     "ModelSelectionBridge",
     "ToolSurfaceBridge",