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

ksadk/events/adapters/codex.py

@@ -48,6 +48,7 @@ from ksadk.events.canonical import (
     ContinuationCreated,
     ContinuationResumed,
     ErrorInfo,
+    InteractionRequested,
     ItemCompleted,
     ItemFailed,
     ItemStarted,
@@ -56,10 +57,12 @@ from ksadk.events.canonical import (
     RunCanceled,
     RunCompleted,
     RunFailed,
+    RunInterrupted,
     RunProgress,
     RunStarted,
     RuntimeEvent,
     SourceRef,
+    StructuredInputRequest,
     UsageReported,
 )
 from ksadk.events.content import (
@@ -191,6 +194,20 @@ class CodexEventAdapter(_CodexInteractionMixin):
             return self._map_server_request_resolved(
                 params=params, context=context, cursor=cursor, timestamp=timestamp
             )
+        if method == "a2ui/surface":
+            return self._map_a2ui_surface(
+                params=params,
+                context=context,
+                cursor=cursor,
+                timestamp=timestamp,
+            )
+        if method == "a2ui/interaction":
+            return self._map_a2ui_interaction(
+                params=params,
+                context=context,
+                cursor=cursor,
+                timestamp=timestamp,
+            )
         if method in _CONTROL_INTERACTION_METHODS:
             return self._map_control_interaction_request(
                 message=message,
@@ -255,6 +272,179 @@ class CodexEventAdapter(_CodexInteractionMixin):
             )
         _fail("unsupported_method", "method", f"Unsupported Codex app-server method: {method}")
 
+    @staticmethod
+    def _a2ui_scope(
+        params: Mapping[str, Any],
+        context: CodexAdapterContext,
+        *,
+        surface_id: str,
+    ) -> tuple[str, str, str]:
+        thread_value = params.get("threadId", params.get("thread_id"))
+        turn_value = params.get("turnId", params.get("turn_id"))
+        thread_id = (
+            _required_string(thread_value, "params.threadId")
+            if thread_value is not None
+            else f"runtime:{context.run_id}"
+        )
+        turn_id = (
+            _required_string(turn_value, "params.turnId")
+            if turn_value is not None
+            else "a2ui"
+        )
+        return thread_id, turn_id, stable_scope_id("codex", thread_id, turn_id, surface_id)
+
+    @staticmethod
+    def _a2ui_source(
+        *,
+        method: str,
+        cursor: str,
+        thread_id: str,
+        turn_id: str,
+        native_item_id: str,
+        surface_id: str,
+        metadata: Mapping[str, Any] | None = None,
+    ) -> SourceRef:
+        source = _protocol_source(
+            method=method,
+            cursor=cursor,
+            thread_id=thread_id,
+            turn_id=turn_id,
+            native_item_id=native_item_id,
+            native_event_id=native_item_id,
+        )
+        return source.model_copy(
+            update={
+                "protocol": "a2ui",
+                "metadata": {
+                    **source.metadata,
+                    "surface_id": surface_id,
+                    **dict(metadata or {}),
+                },
+            }
+        )
+
+    def _map_a2ui_surface(
+        self,
+        *,
+        params: Mapping[str, Any],
+        context: CodexAdapterContext,
+        cursor: str,
+        timestamp: float,
+    ) -> tuple[RuntimeEvent, ...]:
+        """Map one complete A2UI surface description as an immutable operation batch."""
+
+        surface_id = _required_string(params.get("surface_id"), "params.surface_id")
+        surface = _mapping(params.get("surface"), "params.surface")
+        thread_id, turn_id, scope_id = self._a2ui_scope(
+            params, context, surface_id=surface_id
+        )
+        item_id = stable_item_id("codex", scope_id, "a2ui-surface", surface_id)
+        source = self._a2ui_source(
+            method="a2ui/surface",
+            cursor=cursor,
+            thread_id=thread_id,
+            turn_id=turn_id,
+            native_item_id=surface_id,
+            surface_id=surface_id,
+            metadata={
+                "operation_batch": True,
+                "surface_lifecycle": "begin",
+                "catalog_id": str(surface.get("catalog_id") or surface.get("catalogId") or ""),
+            },
+        )
+        snapshot = ContentSnapshot(
+            parts=(
+                DataContent(
+                    part_id="a2ui-surface",
+                    data={"surface_id": surface_id, **_json_value(surface)},
+                ),
+            )
+        )
+        env = _envelope(context, cursor, timestamp)
+        return (
+            ItemStarted(
+                **env(scope_id, item_id, "item.started", "a2ui-surface", source),
+                item_id=item_id,
+                item_kind="data",
+                initial=snapshot,
+            ),
+            ItemCompleted(
+                **env(scope_id, item_id, "item.completed", "a2ui-surface", source),
+                item_id=item_id,
+                item_kind="data",
+                snapshot=snapshot,
+            ),
+        )
+
+    def _map_a2ui_interaction(
+        self,
+        *,
+        params: Mapping[str, Any],
+        context: CodexAdapterContext,
+        cursor: str,
+        timestamp: float,
+    ) -> tuple[RuntimeEvent, ...]:
+        """Map the client-owned A2UI input request without changing its live call id."""
+
+        surface_id = _required_string(params.get("surface_id"), "params.surface_id")
+        interaction_id = _required_string(
+            params.get("interaction_id"), "params.interaction_id"
+        )
+        kind = _required_string(params.get("kind"), "params.kind")
+        schema = _mapping(params.get("input_schema"), "params.input_schema")
+        is_blocking = params.get("is_blocking", True)
+        if not isinstance(is_blocking, bool):
+            _fail(
+                "invalid_interaction_request",
+                "params.is_blocking",
+                "A2UI is_blocking must be a boolean",
+            )
+        thread_id, turn_id, scope_id = self._a2ui_scope(
+            params, context, surface_id=surface_id
+        )
+        source = self._a2ui_source(
+            method="a2ui/interaction",
+            cursor=cursor,
+            thread_id=thread_id,
+            turn_id=turn_id,
+            native_item_id=interaction_id,
+            surface_id=surface_id,
+            metadata={"kind": kind, "is_blocking": is_blocking},
+        )
+        env = _envelope(context, cursor, timestamp)
+        requested = InteractionRequested(
+            **env(
+                scope_id,
+                interaction_id,
+                "interaction.requested",
+                "structured_input",
+                source,
+            ),
+            interaction_id=interaction_id,
+            interaction_kind="structured_input",
+            request=StructuredInputRequest(prompt=None, schema=_json_value(schema)),
+        )
+        if not is_blocking:
+            return (requested,)
+        return (
+            requested,
+            RunInterrupted(
+                **env(
+                    scope_id,
+                    turn_id,
+                    "run.interrupted",
+                    interaction_id,
+                    source,
+                ),
+                status="interrupted",
+                reason="Codex requires user interaction",
+                interaction_id=interaction_id,
+                continuation_id=self._thread_continuations.setdefault(
+                    thread_id, _thread_continuation_identity(thread_id)[1]
+                ),
+            ),
+        )
+
     def _map_token_usage(
         self,
         *,

ksadk/events/adapters/langgraph.py

@@ -87,6 +87,7 @@ class LangGraphEventAdapter:
     def __init__(self) -> None:
         self._messages: dict[tuple[str, str], _MessageState] = {}
         self._tools: dict[tuple[str, str], _ToolState] = {}
+        self._tool_occurrences: dict[tuple[str, str], int] = {}
         self._lifecycles: dict[str, _LifecycleState] = {}
 
     async def stream_run(
@@ -331,7 +332,20 @@ class LangGraphEventAdapter:
                     f"LangGraph tool call {call_id!r} started twice",
                 )
             name = _required_string(payload.get("tool_name"), "tools tool_name")
-            item_id = stable_item_id("langgraph", frame.scope_id, "tool_result", call_id)
+            occurrence = self._tool_occurrences.get(state_key, 0)
+            self._tool_occurrences[state_key] = occurrence + 1
+            item_id = (
+                stable_item_id("langgraph", frame.scope_id, "tool_result", call_id)
+                if occurrence == 0
+                else stable_item_id(
+                    "langgraph",
+                    frame.scope_id,
+                    "tool_result",
+                    call_id,
+                    "occurrence",
+                    frame.occurrence_key,
+                )
+            )
             self._tools[state_key] = _ToolState(
                 scope_id=frame.scope_id,
                 parent_scope_id=frame.parent_scope_id,

ksadk/events/canonical_store.py

@@ -158,7 +158,9 @@ class RuntimeEventStore:
             self._typed_session_id = session_id
         else:
             self._event_store = None
-            self._service = store
+            # A live-first session wrapper may expose one durable authority for
+            # canonical facts without claiming that its dual writes are atomic.
+            self._service = getattr(store, "canonical_event_service", store)
             self._typed_session_id = session_id
 
     @property

ksadk/events/projections.py

@@ -23,7 +23,7 @@ canonical store（``ksadk/events/canonical_store.py`` 及 ``canonical.py`` 的
 | Responses 历史 | ``conversations/context.py::project_responses_history`` | Responses API 请求回放 input | OpenAI Responses input items（``type``/``call_id``/``output``/role 消息），仅可靠 call_id 的 tool 项 |
 | 模型 history | ``conversations/context.py::project_model_messages`` | 运行时模型上下文（内部投喂） | ``role``/``content`` 消息列表；control 事件不进入上下文 |
 | server checkpoint payload | ``server/routes/projection.py::_checkpoint_event_to_action_payload`` | REST 断点续跑/预览接口 | ``EventId``/``SessionId``/``RunId``/``CheckpointId``/``Framework``/``FrameworkRef``/``IsResumable``/``ResumeStatus``/``IsTerminal``/``NextNode``（经 ``run_checkpoint`` 元数据或 ``continuation.created`` 投影） |
-| server 动作事件 payload | ``server/routes/projection.py::_event_to_action_payload`` | REST 会话动作接口（事件原始形态透传） | ``EventId``/``SessionId``/``Author``/``EventType``/``Content``/``Timestamp``/``SeqId``（可选 ``InvocationId``）——序列化存储形态本身，非 canonical 派生 |
+| server 动作事件 payload | ``server/routes/projection.py::_event_to_action_payload`` | REST 会话动作接口（事件原始形态透传） | ``EventId``/``SessionId``/``Author``/``EventType``/``Content``/``Timestamp``/``SeqId``（可选 ``InvocationId``）——序列化存储形态本身，非 canonical 派生；canonical runtime 事件额外注入 ``Content.parts[0].text`` 兼容旧前端 |
 
 内部不保证（任何投影都不承诺、消费方不得依赖）：
 - ``seq``/``run_seq`` 的具体数值与连续性（仅保序语义）；

ksadk/harness/__init__.py

@@ -1,35 +1,45 @@
-"""HarnessApp — 统一 Runtime 的可部署交付物 / composition root (goal-08)。"""
-
-from ksadk.harness.app import HarnessApp, HarnessCapabilities, HarnessPlugin
-from ksadk.harness.config import (
-    HarnessConfig,
-    HarnessConfigError,
-    McpToolSpec,
-    SandboxPolicy,
-)
-from ksadk.harness.reasoner import (
-    HarnessReasoner,
-    HarnessReasoningTurn,
-    HarnessToolCall,
-    LiteLLMHarnessReasoner,
-)
-from ksadk.harness.runtime import HarnessRuntime, HarnessRuntimeAdapter
-from ksadk.harness.sandbox import HarnessSandboxExecutor, SandboxPolicyDenied
-
-__all__ = [
-    "HarnessApp",
-    "HarnessCapabilities",
-    "HarnessConfig",
-    "HarnessConfigError",
-    "HarnessPlugin",
-    "HarnessReasoner",
-    "HarnessRuntime",
-    "HarnessRuntimeAdapter",
-    "HarnessReasoningTurn",
-    "HarnessSandboxExecutor",
-    "HarnessToolCall",
-    "LiteLLMHarnessReasoner",
-    "McpToolSpec",
-    "SandboxPolicy",
-    "SandboxPolicyDenied",
-]
+"""Public Harness surface without eagerly requiring an ADK runtime.
+
+Studio must be usable for Codex and DSH Providers from a base ``ksadk``
+installation. Harness keeps ADK as an optional execution dependency, so
+importing its configuration types cannot import the full Harness runtime.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import Any
+
+_EXPORTS = {
+    "HarnessApp": ("ksadk.harness.app", "HarnessApp"),
+    "HarnessCapabilities": ("ksadk.harness.app", "HarnessCapabilities"),
+    "HarnessPlugin": ("ksadk.harness.app", "HarnessPlugin"),
+    "HarnessConfig": ("ksadk.harness.config", "HarnessConfig"),
+    "HarnessConfigError": ("ksadk.harness.config", "HarnessConfigError"),
+    "McpToolSpec": ("ksadk.harness.config", "McpToolSpec"),
+    "SandboxPolicy": ("ksadk.harness.config", "SandboxPolicy"),
+    "HarnessReasoner": ("ksadk.harness.reasoner", "HarnessReasoner"),
+    "HarnessReasoningTurn": ("ksadk.harness.reasoner", "HarnessReasoningTurn"),
+    "HarnessToolCall": ("ksadk.harness.reasoner", "HarnessToolCall"),
+    "LiteLLMHarnessReasoner": ("ksadk.harness.reasoner", "LiteLLMHarnessReasoner"),
+    "HarnessRuntime": ("ksadk.harness.runtime", "HarnessRuntime"),
+    "HarnessRuntimeAdapter": ("ksadk.harness.runtime", "HarnessRuntimeAdapter"),
+    "HarnessSandboxExecutor": ("ksadk.harness.sandbox", "HarnessSandboxExecutor"),
+    "SandboxPolicyDenied": ("ksadk.harness.sandbox", "SandboxPolicyDenied"),
+}
+
+__all__ = list(_EXPORTS)
+
+
+def __getattr__(name: str) -> Any:
+    try:
+        module_name, attribute = _EXPORTS[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+    value = getattr(import_module(module_name), attribute)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *__all__})

ksadk/harness/config.py

@@ -41,8 +41,8 @@ class McpToolSpec:
     """MCP 工具条目(最小子集)。"""
 
     name: str
-    url: str
-    api_key: Optional[str] = None
+    url: str = field(repr=False)
+    api_key: Optional[str] = field(default=None, repr=False)
     tool_filter: tuple[str, ...] = ()
     tool_name_prefix: Optional[str] = None
 

ksadk/harness/runtime.py

@@ -72,6 +72,19 @@ class _HarnessRun:
     done: bool = False
 
 
+@dataclass
+class _HarnessSession:
+    """Process-local transcript and serialization boundary for one Session.
+
+    The public capability matrix deliberately advertises process-scoped,
+    non-durable continuity.  Keeping this state on the adapter makes that
+    declaration true without pretending that a restart can recover it.
+    """
+
+    messages: list[dict[str, Any]]
+    lock: asyncio.Lock
+
+
 class HarnessRuntimeAdapter(RuntimeAdapter):
     """Execute a YAML Harness config directly as RuntimeEvent streams."""
 
@@ -95,6 +108,9 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
         self._tools: tuple[HarnessTool, ...] | None = None
         self._tool_lock = asyncio.Lock()
         self._mcp_toolsets: list[Any] = []
+        self._sessions: dict[tuple[str, str, str], _HarnessSession] = {}
+        self._lifecycle_lock = asyncio.Lock()
+        self._closed = False
 
     @property
     def harness_config(self) -> HarnessConfig:
@@ -109,10 +125,13 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
         return self._sandbox.workspace_root
 
     async def start(self, request: StartRequest) -> RunHandle:
-        run_id = str(request.metadata.get("invocation_id") or f"harness_{uuid.uuid4().hex}")
-        if run_id in self._runs:
-            raise ValueError(f"duplicate Harness invocation: {run_id}")
-        self._runs[run_id] = _HarnessRun(request=request)
+        async with self._lifecycle_lock:
+            if self._closed:
+                raise RuntimeError("Harness runtime adapter is closed")
+            run_id = str(request.metadata.get("invocation_id") or f"harness_{uuid.uuid4().hex}")
+            if run_id in self._runs:
+                raise ValueError(f"duplicate Harness invocation: {run_id}")
+            self._runs[run_id] = _HarnessRun(request=request)
         return RunHandle(
             run_id=run_id,
             session_id=request.session_id,
@@ -160,23 +179,51 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
         )
 
     async def close(self, handle: RunHandle) -> None:
-        run = self._runs.pop(handle.run_id, None)
+        async with self._lifecycle_lock:
+            run = self._runs.pop(handle.run_id, None)
+            has_runs = bool(self._runs)
         if run is not None and run.task is not None and not run.task.done():
             run.task.cancel()
             await asyncio.gather(run.task, return_exceptions=True)
-        if not self._runs:
+        if not has_runs:
             await self._close_tools()
 
+    async def close_all(self) -> None:
+        """Dispose every process-local run owned by this adapter instance."""
+
+        async with self._lifecycle_lock:
+            self._closed = True
+            runs = tuple(self._runs.values())
+            self._runs.clear()
+            self._sessions.clear()
+        tasks = [run.task for run in runs if run.task is not None and not run.task.done()]
+        for task in tasks:
+            task.cancel()
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        await self._close_tools()
+
     def is_handle_attached(self, handle: RunHandle) -> bool:
         return handle.run_id in self._runs
 
     async def execute_request(self, request: StartRequest) -> dict[str, Any]:
+        session = self._session_for(request)
+        async with session.lock:
+            return await self._execute_session_request(request, session)
+
+    async def _execute_session_request(
+        self,
+        request: StartRequest,
+        session: _HarnessSession,
+    ) -> dict[str, Any]:
         tools = await self._ensure_tools()
         model, prompt = self._effective(request)
         messages: list[dict[str, Any]] = [
             {"role": "system", "content": prompt},
-            {"role": "user", "content": str(request.input or "")},
+            *[dict(message) for message in session.messages],
         ]
+        user_message = {"role": "user", "content": str(request.input or "")}
+        messages.append(user_message)
         execution_log: list[dict[str, Any]] = []
 
         for _turn_number in range(_MAX_REASONING_TURNS):
@@ -235,6 +282,12 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
                 raise RuntimeError(
                     "Harness reasoner returned neither a final response nor a tool call"
                 )
+            final_message = {"role": "assistant", "content": turn.final_text}
+            messages.append(final_message)
+            # Failed or cancelled turns never commit a partial transcript.
+            # A successful turn atomically replaces the process-local history
+            # while the per-session lock is still held.
+            session.messages[:] = [dict(message) for message in messages[1:]]
             return {
                 "output": turn.final_text,
                 "model": model,
@@ -244,11 +297,21 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
             }
         raise RuntimeError(f"Harness reasoning exceeded {_MAX_REASONING_TURNS} turns")
 
+    def _session_for(self, request: StartRequest) -> _HarnessSession:
+        key = (
+            str(request.agent_id or self._agent_name),
+            str(request.user_id),
+            str(request.session_id),
+        )
+        session = self._sessions.get(key)
+        if session is None:
+            session = _HarnessSession(messages=[], lock=asyncio.Lock())
+            self._sessions[key] = session
+        return session
+
     def _effective(self, request: StartRequest) -> tuple[str, str]:
         metadata = request.metadata or {}
-        model = str(
-            metadata.get("model_override") or request.model or self._config.model
-        ).strip()
+        model = str(metadata.get("model_override") or request.model or self._config.model).strip()
         prompt = str(
             metadata.get("prompt_override")
             or request.config.get("base_instructions")
@@ -285,9 +348,7 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
                 },
             )
 
-        def env_kwargs(
-            item_id: str, event_type: str, part_id: str
-        ) -> dict[str, Any]:
+        def env_kwargs(item_id: str, event_type: str, part_id: str) -> dict[str, Any]:
             n = next_seq()
             return {
                 "schema_version": 2,
@@ -386,9 +447,7 @@ class HarnessRuntimeAdapter(RuntimeAdapter):
                 **env_kwargs(message_item_id, "item.completed", "text-0"),
                 item_id=message_item_id,
                 item_kind="message",
-                snapshot=ContentSnapshot(
-                    parts=(TextContent(part_id="text-0", text=text),)
-                ),
+                snapshot=ContentSnapshot(parts=(TextContent(part_id="text-0", text=text),)),
             )
             run.done = True
             yield RunCompleted(

ksadk/harness/tools.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import uuid
 from dataclasses import dataclass
@@ -14,6 +15,13 @@ from ksadk.mcp_runtime import MCPServerConfig, build_mcp_toolset
 
 ToolHandler = Callable[[dict[str, Any], str | None], Awaitable[Any]]
 
+HARNESS_SANDBOX_TOOL_NAMES = frozenset(
+    {
+        "sandbox_read_file",
+        "sandbox_run_command",
+    }
+)
+
 
 @dataclass(frozen=True)
 class HarnessTool:
@@ -89,11 +97,25 @@ async def load_mcp_tools(spec: McpToolSpec) -> tuple[Any, list[HarnessTool]]:
     toolset = build_mcp_toolset(config)
     try:
         native_tools = await toolset.get_tools_with_prefix()
-    except Exception as exc:
-        await toolset.close()
+    except BaseException as error:
+        cleanup = asyncio.create_task(toolset.close())
+        interrupted = False
+        while not cleanup.done():
+            try:
+                await asyncio.shield(cleanup)
+            except asyncio.CancelledError:
+                interrupted = True
+        try:
+            cleanup.result()
+        except Exception:
+            pass
+        if interrupted or isinstance(error, asyncio.CancelledError):
+            raise asyncio.CancelledError
+        if not isinstance(error, Exception):
+            raise
         raise RuntimeError(
-            f"Harness MCP server {spec.name!r} at {spec.url!r} failed to start: {exc}"
-        ) from exc
+            f"Harness MCP server {spec.name!r} at {spec.url} failed to start"
+        ) from None
 
     available_names = {str(tool.name) for tool in native_tools}
     expected_names = {
@@ -104,14 +126,11 @@ async def load_mcp_tools(spec: McpToolSpec) -> tuple[Any, list[HarnessTool]]:
     if missing_names:
         await toolset.close()
         raise RuntimeError(
-            f"Harness MCP server {spec.name!r} at {spec.url!r} did not expose configured "
-            f"tool(s): {missing_names}"
+            f"Harness MCP server {spec.name!r} did not expose configured tool(s): {missing_names}"
         )
     if not native_tools:
         await toolset.close()
-        raise RuntimeError(
-            f"Harness MCP server {spec.name!r} at {spec.url!r} exposed no callable tools"
-        )
+        raise RuntimeError(f"Harness MCP server {spec.name!r} exposed no callable tools")
 
     tools: list[HarnessTool] = []
     for native_tool in native_tools:
@@ -139,10 +158,10 @@ async def load_mcp_tools(spec: McpToolSpec) -> tuple[Any, list[HarnessTool]]:
                 context = await _new_tool_context(call_id or _tool_name)
                 result = await _native_tool.run_async(args=arguments, tool_context=context)
                 return _normalize_tool_result(result, context)
-            except Exception as exc:
+            except Exception:
                 raise RuntimeError(
-                    f"Harness MCP tool {_tool_name!r} on server {spec.name!r} failed: {exc}"
-                ) from exc
+                    f"Harness MCP tool {_tool_name!r} on server {spec.name!r} failed"
+                ) from None
 
         tools.append(
             HarnessTool(
@@ -219,4 +238,10 @@ def _normalize_json_schema(value: Any) -> Any:
     return value
 
 
-__all__ = ["HarnessTool", "load_mcp_tools", "sandbox_tools", "tool_result_text"]
+__all__ = [
+    "HARNESS_SANDBOX_TOOL_NAMES",
+    "HarnessTool",
+    "load_mcp_tools",
+    "sandbox_tools",
+    "tool_result_text",
+]

ksadk/interaction/provider.py

@@ -44,6 +44,7 @@ class InteractionResolveContext:
     handle: RunHandle
     activation_id: str
     fencing_token: int
+    session_context: dict | None = None
 
 
 @runtime_checkable

ksadk/interaction/providers/langgraph.py

@@ -47,6 +47,7 @@ class LangGraphInteractionProvider:
             kind=payload_kind,
             call_id=str(native_target.get("call_id") or record.interaction_id),
             data=submission.response,
+            session_context=context.session_context,
         )
         return await context.adapter.resume(
             context.handle,