arbora 0.1.8.dev2__tar.gz → 0.1.8.dev3__tar.gz

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arbora
-Version: 0.1.8.dev2
+Version: 0.1.8.dev3
 Summary: The deployable MCP, REST, control-plane, fleet, WebUI, and operations composition for the Knuckles agent platform.
 Author-email: Repository Maintainers <maintainers@knuckles.team>
 License-Expression: MIT
@@ -20,10 +20,10 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: pyjwt>=2.15.1
 Requires-Dist: joserfc>=1.7.5
 Requires-Dist: python-multipart>=0.0.32
-Requires-Dist: agent-connector-sdk[a2a,mcp]<0.4.0,>=0.3.19
+Requires-Dist: agent-connector-sdk[a2a,mcp]<0.6.0,>=0.5.4
 Requires-Dist: aiohttp>=3.14.5
 Requires-Dist: anyio>=4.15.1
-Requires-Dist: epistemic-graph[server]<3.0.0,>=2.27.5
+Requires-Dist: epistemic-graph[server]<3.0.0,>=2.27.6
 Requires-Dist: fastapi>=0.143.3
 Requires-Dist: filelock>=4.2.0
 Requires-Dist: msgpack>=1.2.1
@@ -49,10 +49,10 @@ Requires-Dist: types-PyYAML>=6.0.12.20260906; extra == "test"
 Requires-Dist: python-telegram-bot>=22.8; extra == "test"
 Requires-Dist: setuptools>=84.0.0; extra == "test"
 Provides-Extra: webui
-Requires-Dist: agent-webui<3.0.0,>=2.7.1; extra == "webui"
+Requires-Dist: agent-webui<3.0.0,>=2.8.2; extra == "webui"
 Requires-Dist: uvicorn>=0.54.0; extra == "webui"
 Provides-Extra: gateway-widgets
-Requires-Dist: agent-connector-sdk[a2a,mcp]<0.4.0,>=0.3.19; extra == "gateway-widgets"
+Requires-Dist: agent-connector-sdk[a2a,mcp]<0.6.0,>=0.5.4; extra == "gateway-widgets"
 Provides-Extra: vault
 Requires-Dist: hvac>=2.4.0; extra == "vault"
 Provides-Extra: messaging-telegram

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/arbora/_version.py

@@ -3,4 +3,4 @@
 Updated only by `bump-my-version` (see `.bumpversion.toml`) — never hand-edited.
 """
 
-__version__ = "0.1.8.dev2"
+__version__ = "0.1.8.dev3"

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/arbora/a2a/application.py

@@ -29,7 +29,7 @@ from .terminal_event import A2ATerminalEventUnavailable
 if TYPE_CHECKING:
     from arbora.api.http.auth import AmbientHTTPAuthenticator
     from arbora.api.invoke.pipeline import InvokeServices
-    from arbora.api.invoke.steps import VerifiedCaller
+    from arbora.api.invoke.steps import RequestCaller
 
 __all__ = [
     "A2AAuthenticator",
@@ -43,19 +43,19 @@ __all__ = [
 class A2AAuthenticator(Protocol):
     async def authenticate(
         self, request: Request, *, scope: str
-    ) -> VerifiedCaller | None:
+    ) -> RequestCaller | None:
         """Verify authority; an injected adapter may own its dispatch binding."""
 
 
 class AmbientA2AAuthenticator:
     """Resolve each HTTP request through AU's verified bearer/session flow."""
 
-    async def authenticate(self, request: Request, *, scope: str) -> VerifiedCaller:
+    async def authenticate(self, request: Request, *, scope: str) -> RequestCaller:
         caller = await _request_caller(request)
         return _require_caller_scope(caller, scope)
 
 
-async def _request_caller(request: Request) -> VerifiedCaller:
+async def _request_caller(request: Request) -> RequestCaller:
     from arbora.api.http.auth import (
         AmbientHTTPAuthenticator,
         verified_bearer_session_for_request,
@@ -66,13 +66,13 @@ async def _request_caller(request: Request) -> VerifiedCaller:
     ).authenticate(request)
 
 
-def _require_caller_scope(caller: VerifiedCaller, scope: str) -> VerifiedCaller:
+def _require_caller_scope(caller: RequestCaller, scope: str) -> RequestCaller:
     if scope not in caller.effective_scopes:
         raise PermissionError("Required A2A scope unavailable")
     return caller
 
 
-async def _refresh_unary_caller(caller: VerifiedCaller | None) -> None:
+async def _refresh_unary_caller(caller: RequestCaller | None) -> None:
     """Refuse changed authority before entering the task service's session."""
     if caller is None:
         return
@@ -91,7 +91,7 @@ async def _refresh_unary_caller(caller: VerifiedCaller | None) -> None:
 
 
 @contextmanager
-def _caller_session_scope(caller: VerifiedCaller | None) -> Iterator[None]:
+def _caller_session_scope(caller: RequestCaller | None) -> Iterator[None]:
     """Bind a returned caller through legacy dispatch; never resolve a fallback."""
     if caller is None:
         # Explicit injected authenticators already own their admission/binding.

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/arbora/a2a/authority.py

@@ -9,13 +9,14 @@ import logging
 from collections import OrderedDict
 from collections.abc import Callable
 from datetime import UTC, datetime
-from typing import Any, Protocol, runtime_checkable
+from typing import Any, Protocol, cast, runtime_checkable
 
 from agent_connector_sdk.privacy import persistence_reference
 
 from .models import (
     A2AArtifact,
     A2AMessage,
+    A2AReplyUnavailable,
     A2ARouteDecision,
     A2ATask,
     A2ATaskState,
@@ -42,7 +43,8 @@ _RUN_LEASE_SECONDS = 600.0
 _TERMINAL = frozenset({"succeeded", "failed", "cancelled", "dead_letter"})
 #: Agent reply text of recent runs, by task id. A WorkItem holds only the
 #: result reference; the durable record is the run's RunEvents in EG. This
-#: bounded process-local view serves the reply on task reads.
+#: bounded process-local view serves immediate dispatch/list projections;
+#: tasks/get reads the durable record rather than trusting this cache.
 _OUTPUTS: OrderedDict[str, str] = OrderedDict()
 _MAX_OUTPUTS = 1024
 _MAX_OUTPUT_CHARS = 65_536
@@ -53,7 +55,10 @@ def remember_task_output(task_id: str, output: Any) -> None:
     if not task_id or output in (None, ""):
         return
     text = output if isinstance(output, str) else json.dumps(output, default=str)
-    _OUTPUTS[task_id] = text[:_MAX_OUTPUT_CHARS]
+    if len(text) > _MAX_OUTPUT_CHARS:
+        _OUTPUTS.pop(task_id, None)
+        return
+    _OUTPUTS[task_id] = text
     _OUTPUTS.move_to_end(task_id)
     while len(_OUTPUTS) > _MAX_OUTPUTS:
         _OUTPUTS.popitem(last=False)
@@ -85,6 +90,12 @@ _STATE_MAP: dict[str, A2ATaskState] = {
 }
 
 
+class _ReplyUnavailable(RuntimeError):
+    def __init__(self, reason: Any) -> None:
+        super().__init__("durable A2A reply is unavailable")
+        self.availability = A2AReplyUnavailable(reason=reason)
+
+
 class A2AContextUnavailable(RuntimeError):
     """The durable context ownership reader could not supply a bounded answer."""
 
@@ -398,16 +409,14 @@ class WorkItemA2AAuthority:
         outcome, result_ref, error_ref = "succeeded", None, None
         usage = None
         try:
-            from arbora.host_bindings import FLEET_AGENT_NAME, FLEET_TOOLS
+            from arbora.host_bindings import preloaded_agent_tools
 
             result = await self._agent_executor().execute_agent(
                 AgentExecutionRequest(
                     agent_name=agent_name,
                     task=task,
                     run_id=run_id or task_id or None,
-                    allowed_tools=(
-                        FLEET_TOOLS if agent_name == FLEET_AGENT_NAME else None
-                    ),
+                    allowed_tools=preloaded_agent_tools(agent_name),
                 ),
                 session=session,
             )
@@ -593,18 +602,127 @@ class WorkItemA2AAuthority:
             context_id=str(metadata.get("a2a_context_id") or ""),
             status=A2ATaskStatus(
                 state=state,
-                timestamp=WorkItemA2AAuthority._timestamp(item.get("updated_at")),
+                timestamp=WorkItemA2AAuthority._timestamp(
+                    item["updated_at_ms"] / 1000
+                    if isinstance(item.get("updated_at_ms"), (int, float))
+                    else item.get("updated_at")
+                ),
             ),
             artifacts=task_output_artifacts(task_id),
             metadata={"arbora": public_metadata},
         )
 
+    @staticmethod
+    def _read_reply_payload(payload: Any, task_id: str) -> Any:
+        """Decode the bounded durable payload before validating its identity."""
+        from arbora.agent_runs import MAX_RUN_EVENT_PAYLOAD_BYTES
+
+        if not isinstance(payload, str):
+            raise RuntimeError("durable A2A reply is unavailable")
+        try:
+            if len(payload.encode("utf-8")) > MAX_RUN_EVENT_PAYLOAD_BYTES:
+                raise ValueError("run event exceeds its payload bound")
+            event = json.loads(payload)
+        except (ValueError, UnicodeError) as exc:
+            raise RuntimeError("durable A2A reply is unavailable") from exc
+        WorkItemA2AAuthority._check_reply_marker(event, task_id)
+        return event
+
+    @staticmethod
+    def _check_reply_marker(event: Any, task_id: str) -> None:
+        """Refuse malformed markers before exposing a typed availability reason."""
+        from arbora.agent_runs import RUN_EVENT_PAYLOAD_ERROR_SCHEMA
+
+        if (
+            isinstance(event, dict)
+            and event.get("schema") == RUN_EVENT_PAYLOAD_ERROR_SCHEMA
+        ):
+            error = event.get("payload_error")
+            if not (
+                event.get("type") == "graph_complete"
+                and event.get("run_id") == task_id
+                and set(event)
+                <= {"schema", "type", "run_id", "step", "status", "payload_error"}
+                and type(event.get("step")) is int
+                and 0 <= event["step"] <= 2**63 - 1
+            ):
+                raise RuntimeError("durable A2A reply is unavailable")
+            WorkItemA2AAuthority._raise_reply_marker(event, error)
+
+    @staticmethod
+    def _raise_reply_marker(event: dict[str, Any], error: Any) -> None:
+        """Validate marker details before raising their typed refusal."""
+        from arbora.agent_runs import MAX_RUN_EVENT_PAYLOAD_BYTES
+
+        if not (
+            isinstance(error, dict)
+            and set(error) == {"code", "max_bytes"}
+            and type(error["max_bytes"]) is int
+            and error["max_bytes"] == MAX_RUN_EVENT_PAYLOAD_BYTES
+            and isinstance(error["code"], str)
+            and event.get("status") in (None, "completed", "stopped")
+            and error["code"] in {"payload_too_large", "payload_serialization_failed"}
+        ):
+            raise RuntimeError("durable A2A reply is unavailable")
+        raise _ReplyUnavailable(error["code"])
+
+    @staticmethod
+    def _reply_text(event: Any, task_id: str) -> str:
+        """Accept output only from the matching successful terminal run."""
+        result = event.get("result") if isinstance(event, dict) else None
+        if not (
+            isinstance(event, dict)
+            and event.get("type") == "graph_complete"
+            and event.get("run_id") == task_id
+            and isinstance(result, dict)
+            and result.get("run_id") == task_id
+            and result.get("status") in {"completed", "stopped"}
+            and isinstance(result.get("output"), str)
+        ):
+            raise RuntimeError("durable A2A reply is unavailable")
+        return cast(str, result["output"])
+
+    def _persisted_artifacts(
+        self, task_id: str, *, item: dict[str, Any]
+    ) -> list[A2AArtifact] | None:
+        """Read an existing terminal payload, never reconstruct a receipt."""
+        if item.get("status") != "succeeded":
+            return None
+        engine, _work_engine = self._engine()
+        rows = engine.query_cypher(
+            "MATCH (e) WHERE e.type = 'RunEvent' "
+            "AND e.run_id = $run_id AND e.task_id = $run_id "
+            "AND e.event_type = $event_type "
+            "RETURN e.payload AS payload LIMIT 2",
+            {"run_id": task_id, "event_type": "graph_complete"},
+        )
+        if rows == []:
+            return None
+        if not isinstance(rows, list) or len(rows) != 1:
+            raise RuntimeError("durable A2A reply is unavailable")
+        row = rows[0]
+        payload = row.get("payload") if isinstance(row, dict) else None
+        event = self._read_reply_payload(payload, task_id)
+        text = self._reply_text(event, task_id)
+        if len(text) > _MAX_OUTPUT_CHARS:
+            raise _ReplyUnavailable("reply_too_large")
+        if not text:
+            return None
+        return [
+            A2AArtifact(
+                artifact_id=f"{task_id}:reply",
+                name="reply",
+                parts=[A2ATextPart(text=text)],
+            )
+        ]
+
     async def get_committed_task(self, task_id: str) -> A2ATask | None:
         return await self.get(task_id, include_committed_event=True)
 
     async def get(
         self, task_id: str, *, include_committed_event: bool = False
     ) -> A2ATask | None:
+        read_session = self._session("kg:read")
         original = self._session("work:read") if include_committed_event else None
         item = await asyncio.to_thread(self._authorized_item, task_id, "kg:read")
         if item is None:
@@ -614,124 +732,125 @@ class WorkItemA2AAuthority:
             owner_ref = self._owner_ref(original)
             if (
                 current != original
-                or item.get("tenant") != original.tenant
-                or item.get("created_by") != owner_ref
                 or item.get("metadata", {}).get("a2a_owner_ref") != owner_ref
             ):
                 raise PermissionError("A2A caller changed during task read")
+        if self._session("kg:read") != read_session:
+            raise PermissionError("A2A caller changed during task read")
         task = self._project(item, task_id=task_id)
-        if include_committed_event:
-            from .terminal_event import (
-                A2ATerminalEventUnavailable,
-                read_terminal_event,
+        try:
+            task.artifacts = await asyncio.to_thread(
+                self._persisted_artifacts, task_id, item=item
             )
-
-            session = original
-            owner_ref = self._owner_ref(session)
-            engine, _work_engine = self._engine()
-            try:
-                event = await asyncio.wait_for(
-                    read_terminal_event(
-                        engine, session=session, task_id=task_id, owner_ref=owner_ref
-                    ),
-                    timeout=5.0,
-                )
-            except TimeoutError as exc:
-                raise A2ATerminalEventUnavailable(
-                    "committed terminal event is unavailable"
-                ) from exc
-            current = self._session("work:read")
-            if (
-                current != session
-                or current.tenant != session.tenant
-                or current.graph != session.graph
-                or self._owner_ref(current) != owner_ref
-            ):
-                raise PermissionError("A2A caller changed during terminal read")
-            if event["status"] == "available" and (
-                _STATE_MAP[event["outcome"]] != task.status.state
-            ):
-                raise A2ATerminalEventUnavailable(
-                    "committed terminal event is unavailable"
-                )
-            task.metadata["arbora"]["terminalEvent"] = event
+        except _ReplyUnavailable as exc:
+            task.artifacts = None
+            task.metadata["arbora"]["reply"] = exc.availability.model_dump(mode="json")
+        if self._session("kg:read") != read_session:
+            raise PermissionError("A2A caller changed during reply read")
+        if include_committed_event:
+            await self._attach_terminal_event(task, task_id, original)
         return task
 
+    async def _attach_terminal_event(
+        self, task: A2ATask, task_id: str, session: Any
+    ) -> None:
+        """Read and attach a terminal event under the unchanged caller authority."""
+        from .terminal_event import (
+            A2ATerminalEventUnavailable,
+            read_terminal_event,
+        )
+
+        owner_ref = self._owner_ref(session)
+        engine, _work_engine = self._engine()
+        try:
+            event = await asyncio.wait_for(
+                read_terminal_event(
+                    engine, session=session, task_id=task_id, owner_ref=owner_ref
+                ),
+                timeout=5.0,
+            )
+        except TimeoutError as exc:
+            raise A2ATerminalEventUnavailable(
+                "committed terminal event is unavailable"
+            ) from exc
+        current = self._session("work:read")
+        if (
+            current != session
+            or current.tenant != session.tenant
+            or current.graph != session.graph
+            or self._owner_ref(current) != owner_ref
+        ):
+            raise PermissionError("A2A caller changed during terminal read")
+        if event["status"] == "available" and (
+            _STATE_MAP[event["outcome"]] != task.status.state
+        ):
+            raise A2ATerminalEventUnavailable("committed terminal event is unavailable")
+        task.metadata["arbora"]["terminalEvent"] = event
+
     @staticmethod
-    def _cursor(owner_ref: str, tenant: str, item_id: str) -> str:
-        return f"{_digest({'tenant': tenant, 'owner': owner_ref, 'id': item_id})}.{item_id}"
+    def _cursor(owner_ref: str, tenant: str, native_cursor: str) -> str:
+        return f"{_digest({'tenant': tenant, 'owner': owner_ref, 'cursor': native_cursor})}.{native_cursor}"
 
     @classmethod
-    def _decode_cursor(cls, cursor: str | None, *, owner_ref: str, tenant: str) -> str:
+    def _decode_cursor(
+        cls, cursor: str | None, *, owner_ref: str, tenant: str
+    ) -> str | None:
         if cursor is None:
-            return ""
-        digest, separator, item_id = cursor.partition(".")
-        if not separator or digest != _digest(
-            {"tenant": tenant, "owner": owner_ref, "id": item_id}
+            return None
+        digest, separator, native_cursor = cursor.partition(".")
+        if (
+            not separator
+            or not native_cursor
+            or digest
+            != _digest({"tenant": tenant, "owner": owner_ref, "cursor": native_cursor})
         ):
             raise ValueError("A2A task cursor is invalid")
-        cls._work_item_id(item_id.removeprefix(_WORK_ITEM_PREFIX))
-        return item_id
+        return native_cursor
 
-    def _list_rows(self, *, after: str, limit: int, tenant: str, owner_ref: str) -> Any:
+    def _list_rows(
+        self, *, cursor: str | None, limit: int, tenant: str, owner_ref: str
+    ) -> Any:
         _engine, work_engine = self._engine()
-        return work_engine.query_cypher(
-            "MATCH (w:WorkItem) "
-            "WHERE w.kind = $kind AND w.tenant = $tenant "
-            "AND w.created_by = $owner AND w.id > $after "
-            "AND w.id STARTS WITH $id_prefix "
-            "RETURN w.id AS id, w.status AS status, w.updated_at AS updated_at, "
-            "w.metadata AS metadata, w.tenant AS tenant, w.created_by AS created_by "
-            "ORDER BY w.id ASC LIMIT $limit",
-            {
-                "kind": "orchestrator_task",
-                "tenant": tenant,
-                "owner": owner_ref,
-                "after": after,
-                "id_prefix": f"{_WORK_ITEM_PREFIX}{_TASK_PREFIX}",
-                "limit": limit + 1,
+        return work_engine.work_items.list(
+            tenant=tenant,
+            kind="orchestrator_task",
+            metadata_match={
+                "a2a_schema": _A2A_METADATA_SCHEMA,
+                "a2a_owner_ref": owner_ref,
             },
+            cursor=cursor,
+            limit=limit,
         )
 
-    @staticmethod
-    def _validated_list_rows(rows: Any, limit: int) -> list[Any]:
-        if not isinstance(rows, list) or len(rows) > limit + 1:
-            raise RuntimeError("canonical WorkItem list returned invalid data")
-        return rows
-
     @classmethod
-    def _project_list_row(cls, row: Any, *, tenant: str, owner_ref: str) -> A2ATask:
-        if not isinstance(row, dict):
-            raise RuntimeError("canonical WorkItem list returned an invalid row")
-        metadata = row.get("metadata")
-        authorized = (
-            row.get("tenant") == tenant
-            and row.get("created_by") == owner_ref
-            and isinstance(metadata, dict)
-            and metadata.get("a2a_schema") == _A2A_METADATA_SCHEMA
-            and metadata.get("a2a_owner_ref") == owner_ref
-        )
-        if not authorized:
+    def _project_list_row(cls, row: Any, *, owner_ref: str) -> A2ATask:
+        if not cls._owned(row, owner_ref):
             raise RuntimeError("canonical WorkItem list crossed its authority scope")
-        item_id = str(row.get("id") or "")
+        item_id = str(row.get("work_item_id") or "")
         task_id = item_id.removeprefix(_WORK_ITEM_PREFIX)
-        cls._work_item_id(task_id)
+        if cls._work_item_id(task_id) != item_id:
+            raise RuntimeError("canonical WorkItem list returned an invalid identity")
         return cls._project(row, task_id=task_id)
 
-    @classmethod
-    def _next_cursor(
-        cls,
-        rows: list[Any],
-        tasks: list[A2ATask],
-        *,
-        limit: int,
-        owner_ref: str,
-        tenant: str,
-    ) -> str | None:
-        if len(rows) <= limit or not tasks:
-            return None
-        item_id = str(rows[limit - 1].get("id") or "")
-        return cls._cursor(owner_ref, tenant, item_id)
+    @staticmethod
+    def _validated_list_page(
+        page: Any, limit: int, native_cursor: str | None
+    ) -> tuple[list[Any], str | None]:
+        """Validate bounded native rows and forward-only continuation together."""
+        if not isinstance(page, dict) or not isinstance(page.get("items"), list):
+            raise RuntimeError("canonical WorkItem list returned invalid data")
+        rows = page["items"]
+        continuation = page.get("next_cursor")
+        if len(rows) > limit or (
+            continuation is not None
+            and (
+                not isinstance(continuation, str)
+                or not continuation
+                or continuation == native_cursor
+            )
+        ):
+            raise RuntimeError("canonical WorkItem list returned invalid data")
+        return rows, continuation
 
     async def list(
         self, *, cursor: str | None, limit: int
@@ -740,30 +859,26 @@ class WorkItemA2AAuthority:
             raise ValueError("A2A task page limit must be between 1 and 100")
         session = self._session("kg:read")
         owner_ref = self._owner_ref(session)
-        after = self._decode_cursor(cursor, owner_ref=owner_ref, tenant=session.tenant)
-        rows = await asyncio.to_thread(
+        native_cursor = self._decode_cursor(
+            cursor, owner_ref=owner_ref, tenant=session.tenant
+        )
+        page = await asyncio.to_thread(
             self._list_rows,
-            after=after,
+            cursor=native_cursor,
             limit=limit,
             tenant=session.tenant,
             owner_ref=owner_ref,
         )
-        page = self._validated_list_rows(rows, limit)
-        tasks = [
-            self._project_list_row(
-                row,
-                tenant=session.tenant,
-                owner_ref=owner_ref,
-            )
-            for row in page[:limit]
-        ]
-        return tasks, self._next_cursor(
-            page,
-            tasks,
-            limit=limit,
-            owner_ref=owner_ref,
-            tenant=session.tenant,
+        if self._session("kg:read") != session:
+            raise PermissionError("A2A caller changed during task listing")
+        rows, continuation = self._validated_list_page(page, limit, native_cursor)
+        tasks = [self._project_list_row(row, owner_ref=owner_ref) for row in rows]
+        next_cursor = (
+            self._cursor(owner_ref, session.tenant, continuation)
+            if continuation is not None
+            else None
         )
+        return tasks, next_cursor
 
     async def cancel(self, task_id: str) -> A2ATask:
         item = await asyncio.to_thread(self._authorized_item, task_id, "kg:write")

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/arbora/a2a/models.py

@@ -20,6 +20,7 @@ __all__ = [
     "A2AOperationInvokeParams",
     "A2APlanConfirmParams",
     "A2ARouteDecision",
+    "A2AReplyUnavailable",
     "A2ASkill",
     "A2AStreamingAuthority",
     "A2ATask",
@@ -177,6 +178,15 @@ class A2AArtifact(_WireModel):
     parts: list[A2ATextPart] = Field(min_length=1, max_length=32)
 
 
+class A2AReplyUnavailable(_WireModel):
+    """A completed task can have an explicitly unavailable reply artifact."""
+
+    status: Literal["unavailable"] = "unavailable"
+    reason: Literal[
+        "payload_too_large", "payload_serialization_failed", "reply_too_large"
+    ]
+
+
 class A2ATaskStatus(_WireModel):
     state: A2ATaskState
     timestamp: str | None = None

{arbora-0.1.8.dev2 → arbora-0.1.8.dev3}/arbora/agent_host/start_admission.py

@@ -14,6 +14,7 @@ from arbora.agent_host.start_configuration import (
     HostStartConfiguration,
 )
 from arbora.identity.ports import SessionAuthority, SessionState
+from arbora.security.anonymous import session_context
 
 if TYPE_CHECKING:
     from arbora.api.contracts.session import GraphSession
@@ -219,7 +220,7 @@ class HostStartAdmission:
         self._check_credential(credential)
         if not isinstance(graph_session, GraphSession):
             raise PermissionError("workspace_denied")
-        graph_session.engine_verified_context()
+        session_context(graph_session)
         state = await self._sessions.resolve_session(credential)
         self._check_configuration(request, configuration, runtime)
         if not isinstance(state, SessionState) or state.expires_at_ms <= int(
@@ -245,7 +246,7 @@ class HostStartAdmission:
         )
         if not binding.same_binding(final_binding):
             raise PermissionError("workspace_denied")
-        claims = graph_session.engine_verified_context()
+        claims = session_context(graph_session)
         if any(
             claims.get(key) != state.resolution.request_context[key]
             for key in ("principal", "tenant", "audience", "policy_version")