agentengine-sdk-python 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/a2a/adk_tools.py

@@ -0,0 +1,319 @@
+"""Managed ADK tool execution with native call identity and run-owned events."""
+
+import asyncio
+from contextlib import aclosing, contextmanager
+from contextvars import ContextVar
+
+from google.adk.tools.function_tool import FunctionTool
+
+from ksadk.a2a.adk import _project
+from ksadk.a2a.adk_invocation_context import ADKInvocationContextProvider, _path
+from ksadk.a2a.exposure import compile_exposure_plan
+from ksadk.a2a.invocation_types import RemoteAgentSpec
+from ksadk.a2a.presentation import ScopeTriggerRef
+from ksadk.events.identity import stable_item_id, stable_scope_id
+
+_binding = ContextVar("managed_adk_tools", default=None)
+
+
+def native_tool_trigger(tool_context, tool_name="call_a2a_agent"):
+    ctx = tool_context._invocation_context
+    call_id = tool_context.function_call_id
+    if not call_id:
+        raise ValueError("A2A_NATIVE_TRIGGER_ID_REQUIRED")
+    for event in reversed(ctx.session.events):
+        if (
+            event.invocation_id != ctx.invocation_id
+            or event.author != ctx.agent.name
+            or event.branch != ctx.branch
+        ):
+            continue
+        calls = [
+            part.function_call
+            for part in (getattr(event.content, "parts", None) or ())
+            if part.function_call is not None and part.function_call.id == call_id
+        ]
+        if not calls:
+            continue
+        if len(calls) != 1 or calls[0].name != tool_name or not event.id:
+            raise ValueError("A2A_NATIVE_TRIGGER_AMBIGUOUS")
+        path = _path(event)
+        return ScopeTriggerRef(
+            scope_id=stable_scope_id("adk", event.invocation_id, path),
+            item_id=stable_item_id(
+                "adk", event.invocation_id, path, event.id, call_id, "tool_call"
+            ),
+            call_id=call_id,
+        )
+    raise ValueError("A2A_NATIVE_TRIGGER_CALL_MISSING")
+
+
+class ManagedA2ACallTool(FunctionTool):
+    def __init__(self):
+        from ksadk.toolsets.a2a import call_a2a_agent
+
+        super().__init__(call_a2a_agent)
+
+    async def run_async(self, *, args, tool_context):
+        runtime = _binding.get()
+        if runtime is None:
+            return {"ok": False, "error_type": "A2A_MANAGED_INVOCATION_CONTEXT_REQUIRED"}
+        try:
+            spec = getattr(self, "remote_spec", None)
+            if spec is not None:
+                return await runtime.call(args, tool_context, fixed_spec=spec)
+            return await runtime.call(args, tool_context)
+        except Exception as exc:
+            code = str(exc)
+            if not code.startswith("A2A_") or len(code) >= 128:
+                code = "A2A_INVOCATION_FAILED"
+            return {
+                "ok": False,
+                "error_type": code,
+                "error_message": "Managed A2A invocation failed",
+            }
+
+
+class ManagedA2AHandoffTool(ManagedA2ACallTool):
+    """A fixed remote expert; the model supplies only the message."""
+
+    def __init__(self, spec):
+        spec = RemoteAgentSpec.model_validate(spec.model_dump())
+        compile_exposure_plan([spec], framework="adk", consumer_id=spec.local_name)
+
+        async def invoke(message: str):
+            raise RuntimeError("A2A_MANAGED_INVOCATION_CONTEXT_REQUIRED")
+
+        invoke.__name__ = spec.local_name
+        invoke.__doc__ = spec.description or "Delegate to this fixed remote expert and receive its result."
+        FunctionTool.__init__(self, invoke)
+        self.remote_spec = spec
+
+
+def adk_exposure_plan(root):
+    pending, seen, specs = [root], set(), []
+    while pending:
+        node = pending.pop()
+        if id(node) in seen:
+            continue
+        seen.add(id(node))
+        spec = getattr(node, "remote_spec", None)
+        if spec is not None:
+            specs.append(spec)
+        pending.extend(getattr(node, "sub_agents", ()) or ())
+        pending.extend(getattr(node, "tools", ()) or ())
+    if len({spec.target_agent_id for spec in specs}) != len(specs):
+        raise ValueError("A2A_EXPOSURE_CONFLICT")
+    return compile_exposure_plan(specs, framework="adk", consumer_id=root.name)
+
+
+class ManagedA2ADiscoveryTool(FunctionTool):
+    def __init__(self, func):
+        super().__init__(func)
+        self._detail = func.__name__ == "get_a2a_agent_card"
+
+    async def run_async(self, *, args, tool_context):
+        runtime = _binding.get()
+        if runtime is None:
+            return {"ok": False, "error_type": "A2A_MANAGED_INVOCATION_CONTEXT_REQUIRED"}
+        try:
+            if self._detail and (
+                not isinstance(args.get("agent"), str) or not args["agent"].strip()
+            ):
+                raise ValueError("A2A_AGENT_REQUIRED")
+            return await runtime.discover(args.get("agent") if self._detail else None)
+        except Exception as exc:
+            code = str(exc)
+            if not code.startswith("A2A_") or len(code) >= 128:
+                code = "A2A_DISCOVERY_FAILED"
+            return {
+                "ok": False,
+                "error_type": code,
+                "error_message": "Managed A2A discovery failed",
+            }
+
+
+def install_managed_tools(root):
+    """Replace only the SDK function, never an unrelated tool with the same name."""
+    from ksadk.toolsets.a2a import call_a2a_agent, get_a2a_agent_card, list_a2a_agents
+
+    pending, seen = [root], set()
+    while pending:
+        node = pending.pop()
+        if id(node) in seen:
+            continue
+        seen.add(id(node))
+        if hasattr(node, "tools"):
+            replaced = []
+            for tool in node.tools:
+                func = getattr(tool, "func", None) or getattr(tool, "coroutine", None) or tool
+                if func is call_a2a_agent:
+                    tool = ManagedA2ACallTool()
+                elif func is list_a2a_agents or func is get_a2a_agent_card:
+                    tool = ManagedA2ADiscoveryTool(func)
+                replaced.append(tool)
+            node.tools = replaced
+        pending.extend(getattr(node, "sub_agents", ()) or ())
+
+
+class ManagedADKTools:
+    def __init__(self, *, bootstrap, authority, services, emit):
+        self.bootstrap, self.authority = bootstrap, authority
+        self.services, self.emit = services, emit
+
+    async def discover(self, agent_ref=None):
+        from ksadk.toolsets.a2a import _a2a_space_id, _normalize_agent_ref
+
+        self.authority.require_session(self.authority.session_id)
+        space = _a2a_space_id()
+        if not space:
+            raise ValueError("A2A_SPACE_REQUIRED")
+        discovered = await self.bootstrap.client_for_space(space).discover()
+        # Only public discovery metadata is returned to the model. Connection
+        # origins, credentials and prepared routes belong to the runtime client.
+        agents = [
+            {
+                "agent_id": agent.agent_id,
+                "name": agent.agent_card.name,
+                "description": getattr(agent.agent_card, "description", ""),
+                "version_id": agent.version_id,
+                "card_sha256": getattr(agent, "card_sha256", ""),
+                "source": getattr(agent, "source", "hosted"),
+            }
+            for agent in discovered
+        ]
+        if agent_ref is None:
+            return {"ok": True, "space_id": space, "agents": agents}
+        target = _normalize_agent_ref(str(agent_ref))
+        matches = [
+            agent
+            for agent in agents
+            if target
+            and target
+            in {_normalize_agent_ref(agent["agent_id"]), _normalize_agent_ref(agent["name"])}
+        ]
+        if len(matches) != 1:
+            raise ValueError("A2A_AGENT_NOT_FOUND" if not matches else "A2A_AGENT_AMBIGUOUS")
+        return {"ok": True, "agent": matches[0]}
+
+    async def call(self, args, tool_context, *, fixed_spec=None):
+        from ksadk.a2a.runtime_input import invoke_with_input
+        from ksadk.events.content import TextContent, ToolCallContent
+        from ksadk.toolsets.a2a import _a2a_space_id, _normalize_agent_ref
+
+        message = args.get("message")
+        if not isinstance(message, str) or not message.strip():
+            raise ValueError("A2A_MESSAGE_REQUIRED")
+        tool_name = fixed_spec.local_name if fixed_spec is not None else "call_a2a_agent"
+        trigger = native_tool_trigger(tool_context, tool_name)
+        ctx = tool_context._invocation_context
+        self.authority.require_session(self.authority.session_id)
+        # Native session IDs may be mapped from the public session. Bind the
+        # actual native call to its already-persisted public fact instead of
+        # assuming those session strings are equal (or trusting another run's
+        # ToolContext merely because its call_id has the same spelling).
+        facts = await self.authority.list(self.authority.session_id)
+        bound = False
+        for event in facts:
+            if (
+                event.scope_id != trigger.scope_id
+                or getattr(event, "item_id", None) != trigger.item_id
+            ):
+                continue
+            snapshot = getattr(event, "initial", None) or getattr(event, "snapshot", None)
+            if snapshot is not None and any(
+                isinstance(part, ToolCallContent)
+                and part.call_id == trigger.call_id
+                and part.name == tool_name
+                for part in snapshot.parts
+            ):
+                bound = True
+                break
+        if not bound:
+            raise ValueError("A2A_NATIVE_TRIGGER_NOT_PERSISTED")
+        if fixed_spec is not None:
+            spec = RemoteAgentSpec.model_validate(fixed_spec.model_dump())
+            if set(args) != {"message"}:
+                raise ValueError("A2A_FIXED_TARGET_ARGUMENT_INVALID")
+            declarations = [tool.remote_spec for tool in ctx.agent.tools
+                            if isinstance(tool, ManagedA2AHandoffTool) and tool.name == tool_name]
+            if declarations != [spec]:
+                raise ValueError("A2A_BINDING_MISMATCH")
+            adk_exposure_plan(ctx.agent)
+        else:
+            space = _a2a_space_id()
+            if not space:
+                raise ValueError("A2A_SPACE_REQUIRED")
+            discovered = await self.bootstrap.client_for_space(space).discover()
+            target = _normalize_agent_ref(str(args.get("agent") or ""))
+            matches = [
+                agent
+                for agent in discovered
+                if target
+                in {_normalize_agent_ref(agent.agent_id), _normalize_agent_ref(agent.agent_card.name)}
+            ]
+            if len(matches) != 1:
+                raise ValueError("A2A_AGENT_NOT_FOUND" if not matches else "A2A_AGENT_AMBIGUOUS")
+            agent = matches[0]
+            plan = adk_exposure_plan(ctx.agent)
+            if any(isinstance(tool, ManagedA2AHandoffTool) and tool.remote_spec.target_agent_id == agent.agent_id
+                   for tool in ctx.agent.tools):
+                raise ValueError("A2A_EXPOSURE_CONFLICT")
+            plan.assert_generic_target_allowed(agent.agent_id)
+            spec = RemoteAgentSpec(
+                local_name="call_a2a_agent",
+                binding_id=stable_item_id("a2a", space, agent.agent_id),
+                space_id=space,
+                target_agent_id=agent.agent_id,
+                expected_version_id=agent.version_id,
+                exposure="tool",
+            )
+        provider = ADKInvocationContextProvider(
+            authority=self.authority,
+            service_for_space=self.services,
+            caller_agent_id=self.bootstrap.runtime_metadata.agent_id,
+            message_selector=lambda *_: (message,),
+            workflow_trigger=lambda *_: (trigger, ()),
+        )
+        resolved = await provider(ctx, spec)
+        service, request = resolved.service, resolved.request
+        texts = {}
+        item_kinds = {}
+        try:
+            async with aclosing(invoke_with_input(service, request, trigger_ref=trigger)) as events:
+                async for event in events:
+                    if event.event_type == "item.completed" and event.item_kind in {
+                        "message",
+                        "artifact",
+                    }:
+                        item_kinds[(event.scope_id, event.item_id)] = event.item_kind
+                        texts[(event.scope_id, event.item_id)] = {
+                            part.part_id: part.text
+                            for part in event.snapshot.parts
+                            if isinstance(part, TextContent)
+                        }
+                    await self.emit(_project(event, ctx.agent.name, ctx))
+        except (asyncio.CancelledError, TimeoutError):
+            try:
+                await asyncio.shield(service.cancel(service.handle(request.scope_id)))
+            finally:
+                raise
+        snapshot = service.snapshot(service.handle(request.scope_id))
+        from ksadk.a2a.result_text import select_terminal_reply
+
+        return {
+            "ok": snapshot.status == "completed",
+            "agent": spec.target_agent_id,
+            "task_id": snapshot.handle.platform_task_id,
+            "state": snapshot.status,
+            "reply": select_terminal_reply(snapshot.output_refs, texts, item_kinds),
+        }
+
+
+@contextmanager
+def bind_managed_adk_tools(runtime):
+    token = _binding.set(runtime)
+    try:
+        yield
+    finally:
+        _binding.reset(token)

ksadk/a2a/bootstrap.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 
+import asyncio
 import inspect
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Any, Protocol, Sequence
 from urllib.parse import urlsplit
@@ -26,10 +28,15 @@ from ksadk.a2a.resume_store import A2AResumeStateStore
 from ksadk.a2a.routes import A2AConfig, add_a2a_protocol_routes
 from ksadk.a2a.task_adapter import A2ARuntimeTaskAdapter
 from ksadk.a2a.task_event_dispatcher import A2ATaskEventDispatcher
+from ksadk.a2a.product_kernel_facts import ProductKernelFactSink, ProductKernelReconciler
 from ksadk.a2a.task_event_outbox import A2ATaskEventOutbox
 from ksadk.a2a.task_store import A2AOwnerContextBuilder
+from ksadk.a2a.tool_activity import PublicToolActivityPolicy
+from ksadk.managed_a2a_card import ManagedA2ACardConfig, ManagedA2ACardMount
 from ksadk.runtime.adapter import RuntimeAdapter
 
+MANAGED_MODEL_READ_TIMEOUT_SECONDS = 300.0
+
 
 @dataclass(frozen=True)
 class RuntimeA2AMetadata:
@@ -44,7 +51,7 @@ class RuntimeA2AMetadata:
     skills: Sequence[AgentSkill]
     description: str = ""
 
-    def validate(self) -> None:
+    def validate(self, *, inbound_enabled: bool = True) -> None:
         values = {
             "account_id": self.account_id,
             "agent_id": self.agent_id,
@@ -54,16 +61,22 @@ class RuntimeA2AMetadata:
             "name": self.name,
             "version": self.version,
         }
-        missing = [name for name, value in values.items() if not str(value).strip()]
+        inbound_fields = {"a2a_agent_id", "internal_base_url", "name", "version"}
+        missing = [
+            name
+            for name, value in values.items()
+            if not str(value).strip() and (inbound_enabled or name not in inbound_fields)
+        ]
         if missing:
             raise ValueError(f"RuntimeA2AMetadata is missing required fields: {', '.join(missing)}")
         if not self.agent_id.startswith("ar-"):
             raise ValueError("RuntimeA2AMetadata.agent_id must be an ar-* Agent ID")
-        require_a2a_resource_id(
-            self.a2a_agent_id,
-            "a2a-agent-",
-            field_name="RuntimeA2AMetadata.a2a_agent_id",
-        )
+        if inbound_enabled or self.a2a_agent_id:
+            require_a2a_resource_id(
+                self.a2a_agent_id,
+                "a2a-agent-",
+                field_name="RuntimeA2AMetadata.a2a_agent_id",
+            )
         for field_name, limit in (
             ("account_id", 64),
             ("tenant_id", 64),
@@ -82,6 +95,8 @@ class RuntimeA2AMetadata:
             raise ValueError(
                 "RuntimeA2AMetadata.skills must contain at most 100 AgentSkill objects"
             )
+        if not inbound_enabled and not self.internal_base_url:
+            return
         parsed = urlsplit(self.internal_base_url)
         try:
             port = parsed.port
@@ -98,7 +113,8 @@ class RuntimeA2AMetadata:
             or parsed.query
             or parsed.fragment
             or parsed.netloc.rsplit("@", 1)[-1].endswith(":")
-            or port is not None and not 1 <= port <= 65535
+            or port is not None
+            and not 1 <= port <= 65535
         ):
             raise ValueError(
                 "RuntimeA2AMetadata.internal_base_url must be an absolute HTTP(S) origin"
@@ -128,12 +144,15 @@ class AgentEngineA2ABootstrap:
         control_plane: Any | None = None,
         hosted_http_client: httpx.AsyncClient | None = None,
         event_outbox: A2ATaskEventOutbox | None = None,
+        invocation_checkpoint_store: Any | None = None,
+        public_tool_policy: PublicToolActivityPolicy | None = None,
         inbound_enabled: bool = True,
         outbound_enabled: bool = True,
         public_egress_enabled: bool = False,
         outbox_retry_interval_seconds: float = 1.0,
+        managed_resource_closers: Sequence[Callable[[], Awaitable[None]]] = (),
     ) -> None:
-        runtime_metadata.validate()
+        runtime_metadata.validate(inbound_enabled=inbound_enabled)
         required: dict[str, Any] = {}
         if outbound_enabled:
             required.update(
@@ -156,9 +175,7 @@ class AgentEngineA2ABootstrap:
             )
         missing = [name for name, value in required.items() if value is None]
         if missing:
-            raise ValueError(
-                "AgentEngineA2ABootstrap requires: " + ", ".join(missing)
-            )
+            raise ValueError("AgentEngineA2ABootstrap requires: " + ", ".join(missing))
         if external_transport is not None and not isinstance(
             external_transport, RuntimeLocalA2AExternalTransport
         ):
@@ -174,12 +191,17 @@ class AgentEngineA2ABootstrap:
             _require_initializable(checkpoint_store, "checkpoint_store")
             _require_initializable(resume_state_store, "resume_state_store")
         self.runtime_metadata = runtime_metadata
-        self._target_binding = A2AIngressTargetBinding(
-            account_id=runtime_metadata.account_id,
-            tenant_id=runtime_metadata.tenant_id,
-            agent_id=runtime_metadata.agent_id,
-            runtime_id=runtime_metadata.runtime_id,
-            a2a_agent_id=runtime_metadata.a2a_agent_id,
+        self.public_tool_policy = public_tool_policy or PublicToolActivityPolicy()
+        self._target_binding = (
+            A2AIngressTargetBinding(
+                account_id=runtime_metadata.account_id,
+                tenant_id=runtime_metadata.tenant_id,
+                agent_id=runtime_metadata.agent_id,
+                runtime_id=runtime_metadata.runtime_id,
+                a2a_agent_id=runtime_metadata.a2a_agent_id,
+            )
+            if inbound_enabled
+            else None
         )
         self.inbound_enabled = inbound_enabled
         self.outbound_enabled = outbound_enabled
@@ -192,18 +214,21 @@ class AgentEngineA2ABootstrap:
         self._gateway_probe_verifier = gateway_probe_verifier
         self._external_transport = external_transport
         self._control_plane = control_plane
+        self._invocation_checkpoint_store = invocation_checkpoint_store
         self._hosted_http_client = hosted_http_client
         self._dispatcher = (
             A2ATaskEventDispatcher(
                 _require(event_outbox, "event_outbox"),
-                _require(control_plane, "control_plane"),
+                ProductKernelFactSink(_require(control_plane, "control_plane")),
                 retry_interval_seconds=outbox_retry_interval_seconds,
             )
-            if outbound_enabled
+            if outbound_enabled or (inbound_enabled and event_outbox is not None)
             else None
         )
+        self._kernel_reconciler = None
         self._mounted = False
         self._server: Any = None
+        self._managed_resource_closers = tuple(managed_resource_closers)
 
     @classmethod
     def from_platform(cls, **kwargs: Any) -> "AgentEngineA2ABootstrap":
@@ -221,6 +246,10 @@ class AgentEngineA2ABootstrap:
     def server(self) -> Any:
         return self._server
 
+    @property
+    def invocation_checkpoint_store(self):
+        return _require(self._invocation_checkpoint_store, "invocation_checkpoint_store")
+
     def client_for_space(self, space_id: str):
         """Create a Space-scoped client sharing Runtime identity, clients, and outbox."""
 
@@ -237,6 +266,31 @@ class AgentEngineA2ABootstrap:
             event_dispatcher=self.event_dispatcher,
         )
 
+    @property
+    def scoped_cancel_available(self):
+        return self.outbound_enabled and self._invocation_checkpoint_store is not None
+
+    def invocation_service_for_space(
+        self, space_id: str, *, event_store, policy, recover_checkpoint_leases=False,
+    ):
+        """Product-owned caller service; policy and canonical ownership stay explicit."""
+        from ksadk.a2a.invocation_service import A2AInvocationService, A2AInvocationTimeouts
+
+        return A2AInvocationService.from_space_client(
+            self.client_for_space(space_id),
+            event_store=event_store,
+            policy=policy,
+            checkpoint_store=self.invocation_checkpoint_store,
+            recover_checkpoint_leases=recover_checkpoint_leases,
+            # A model may be silent between status/tool events. Match the
+            # managed data-plane transport ceiling; _timed still caps every
+            # wait at the invocation's original absolute deadline.
+            timeouts=A2AInvocationTimeouts(
+                first_event_seconds=MANAGED_MODEL_READ_TIMEOUT_SECONDS,
+                idle_seconds=MANAGED_MODEL_READ_TIMEOUT_SECONDS,
+            ),
+        )
+
     def mount(
         self,
         app: FastAPI,
@@ -251,6 +305,16 @@ class AgentEngineA2ABootstrap:
         self._mounted = True
         app.state.a2a_bootstrap = self
         if not self.inbound_enabled:
+            ManagedA2ACardMount(
+                ManagedA2ACardConfig(
+                    base_url=self.runtime_metadata.internal_base_url
+                    or "http://localhost:8080",
+                    agent_name=self.runtime_metadata.name or self.runtime_metadata.runtime_id,
+                    description=self.runtime_metadata.description,
+                    version=self.runtime_metadata.version or "0.1.0",
+                    skills=self.runtime_metadata.skills,
+                )
+            ).mount(app)
             return None
         app.add_middleware(
             A2AGatewayIdentityMiddleware,
@@ -266,12 +330,24 @@ class AgentEngineA2ABootstrap:
             version=self.runtime_metadata.version,
             skills=self.runtime_metadata.skills,
             create_table=False,
+            public_tool_policy=self.public_tool_policy,
         )
-        task_adapter = A2ARuntimeTaskAdapter(
+        from ksadk.kernel.ingress import authority_mode, kernel_ingress_enabled
+        task_adapter_class = A2ARuntimeTaskAdapter
+        task_adapter_options = {}
+        if kernel_ingress_enabled() and authority_mode() == "hosted":
+            from ksadk.a2a.kernel_task_adapter import ManagedKernelA2ATaskAdapter
+            self._kernel_reconciler = ProductKernelReconciler(self._control_plane, _ManagedKernelEvents())
+            task_adapter_class = ManagedKernelA2ATaskAdapter
+            task_adapter_options = {"control_plane": _require(self._control_plane, "control_plane"),
+                                    "session_events": _ManagedKernelEvents(),
+                                    "event_dispatcher": self._dispatcher}
+        task_adapter = task_adapter_class(
             runtime_adapter,
             runtime_type=runtime_type,
             context_store=_require(self._context_store, "context_store"),
             resume_state_store=_require(self._resume_state_store, "resume_state_store"),
+            **task_adapter_options,
         )
         self._server = add_a2a_protocol_routes(
             app,
@@ -285,9 +361,35 @@ class AgentEngineA2ABootstrap:
                 allow_unverified_identity=False,
             ),
         )
+        # Probe evidence for the platform's registration reconciler. This is
+        # public identity, not an authorization credential; the probe itself
+        # still passes through Gateway identity verification.
+        from a2a.types import AgentExtension
+        from google.protobuf.json_format import ParseDict
+        from google.protobuf.struct_pb2 import Struct
+
+        self._server.agent_card.capabilities.extensions.append(
+            AgentExtension(
+                uri="urn:ksadk:a2a:managed-runtime:v1",
+                required=False,
+                params=ParseDict(
+                    {
+                        "agent_id": self.runtime_metadata.agent_id,
+                        "registration_id": self.runtime_metadata.a2a_agent_id,
+                        "runtime_id": self.runtime_metadata.runtime_id,
+                        "version": self.runtime_metadata.version,
+                    },
+                    Struct(),
+                ),
+            )
+        )
         return self._server
 
     async def start(self) -> None:
+        if self.outbound_enabled and self._invocation_checkpoint_store is not None:
+            await _initialize_required(
+                self._invocation_checkpoint_store, "invocation_checkpoint_store"
+            )
         if self.inbound_enabled:
             await _initialize_required(_require(self._task_store, "task_store"), "task_store")
             await _initialize_required(
@@ -302,10 +404,34 @@ class AgentEngineA2ABootstrap:
             )
         if self._dispatcher is not None:
             await self._dispatcher.start()
+        if self._kernel_reconciler is not None:
+            await self._kernel_reconciler.start()
 
     async def stop(self, *, flush_timeout_seconds: float = 5.0) -> None:
-        if self._dispatcher is not None:
-            await self._dispatcher.stop(flush_timeout_seconds=flush_timeout_seconds)
+        try:
+            if self._kernel_reconciler is not None:
+                await self._kernel_reconciler.stop()
+            if self._dispatcher is not None:
+                await self._dispatcher.stop(flush_timeout_seconds=flush_timeout_seconds)
+        finally:
+            for closer in self._managed_resource_closers:
+                await asyncio.wait_for(closer(), timeout=max(0.1, flush_timeout_seconds))
+
+
+class _ManagedKernelEvents:
+    """Resolve the Kernel after app lifespan startup, never fall back to an adapter."""
+
+    async def subscribe(self, session_id, after_seq):
+        from ksadk.kernel.bootstrap import get_agent_kernel_runtime
+        from ksadk.a2a.inbound_kernel import ManagedKernelRequestError
+        runtime = get_agent_kernel_runtime()
+        if runtime is None:
+            raise ManagedKernelRequestError("managed A2A Kernel is not ready")
+        try:
+            async for fact in runtime.session_events.subscribe(session_id, after_seq):
+                yield fact
+        except (OSError, TimeoutError) as exc:
+            raise ManagedKernelRequestError("Kernel event observation was interrupted") from exc
 
 
 def _require_initializable(value: Any, name: str) -> None: