agentengine-sdk-python 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ksadk/a2ui/core.py

@@ -0,0 +1,186 @@
+"""A2UICore — Agent-facing interface + RuntimeEvent 产出 (goal-13,canonical §5.1/§5.2)。
+
+**硬约束(canonical §1 / H2 P0-C):A2UI 必须先进入 RuntimeEvent,不得以 A2A executor
+绕过**——本类的 ``display_ui`` / ``request_ui_input`` / ``submit_action`` 全部经 A7
+``RuntimeEventStore`` 产出并持久化 A2UI 事件(``a2ui.surface.*`` / ``a2ui.interaction`` /
+``a2ui.action``),由 session 级订阅承载(A2UI 依赖,可 run 后非阻塞 action 与回放)。
+
+冻结 schema 映射(G0.2 已冻结,不改):surface 首显 ``a2ui.surface.begin`` / 更新
+``a2ui.surface.update`` / 结束 ``a2ui.surface.end``;请求输入 ``a2ui.interaction``;
+action ``a2ui.action``。均带 ``surface_id``(G0.2 必填键)。
+"""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from typing import Any, Optional
+
+from ksadk.a2ui.models import (
+    BASIC_CATALOG,
+    ActionReceipt,
+    PendingInteraction,
+    Surface,
+)
+from ksadk.events.runtime_event import EventType, RuntimeEvent
+from ksadk.events.store import RuntimeEventStore
+
+logger = logging.getLogger(__name__)
+
+
+class A2UICore:
+    """A2UI Agent-facing interface:display / request_input / submit_action。
+
+    所有 A2UI 事件经 :class:`RuntimeEventStore` 持久化(**不另开通道、不经 A2A 绕过**),
+    供 session 级订阅 / replay / 审计消费。
+    """
+
+    def __init__(
+        self,
+        store: RuntimeEventStore,
+        *,
+        agent_id: str,
+        user_id: str,
+        session_id: str,
+        catalog: dict[str, frozenset[str]] = BASIC_CATALOG,
+    ) -> None:
+        self._store = store
+        self._agent_id = agent_id
+        self._user_id = user_id
+        self._session_id = session_id
+        self._catalog = catalog
+        self._seq = 0
+        self._seen_surfaces: set[str] = set()
+        self._pending: dict[str, PendingInteraction] = {}
+
+    # ---- 内部:产出并持久化一个 A2UI RuntimeEvent ----
+
+    async def _emit(
+        self, event_type: str, invocation_id: str, payload: dict[str, Any]
+    ) -> RuntimeEvent:
+        self._seq += 1
+        event = RuntimeEvent.create(
+            event_type,
+            agent_id=self._agent_id,
+            user_id=self._user_id,
+            session_id=self._session_id,
+            invocation_id=invocation_id,
+            seq_id=self._seq,
+            payload=payload,
+        )
+        # 经 RuntimeEvent 持久化(A7 store)——canonical,不绕过。
+        await self._store.append_one(event)
+        return event
+
+    # ---- 三种交互 ----
+
+    async def display_ui(
+        self,
+        surface: Surface,
+        *,
+        invocation_id: str,
+        origin: str = "local",
+    ) -> str:
+        """展示 surface(不阻塞)。首显发 surface.begin,重复显发 surface.update。"""
+        surface.validate(self._catalog)
+        event_type = (
+            EventType.A2UI_SURFACE_BEGIN
+            if surface.surface_id not in self._seen_surfaces
+            else EventType.A2UI_SURFACE_UPDATE
+        )
+        self._seen_surfaces.add(surface.surface_id)
+        await self._emit(
+            event_type,
+            invocation_id,
+            {
+                "surface_id": surface.surface_id,
+                "catalog_id": surface.catalog_id,
+                "surface": surface.to_dict(),
+                "origin": origin,
+            },
+        )
+        return surface.surface_id
+
+    async def request_ui_input(
+        self,
+        surface: Surface,
+        *,
+        schema: dict[str, Any],
+        kind: str,
+        invocation_id: str,
+        origin: str = "local",
+    ) -> PendingInteraction:
+        """等待用户输入(input_required 语义):先展示 surface,再登记 pending interaction。
+
+        返回的 :class:`PendingInteraction` 是一次等待输入的持久化身份;用户上行
+        ``SubmitA2UIAction`` 命中后 resume(由 RuntimeBridge/adapter 处理,不在本层)。
+        """
+        # 先展示(确保 surface 已渲染),再请求输入。
+        await self.display_ui(surface, invocation_id=invocation_id, origin=origin)
+        interaction = PendingInteraction(
+            interaction_id=f"int_{uuid.uuid4().hex[:12]}",
+            surface_id=surface.surface_id,
+            kind=kind,
+            input_schema=dict(schema),
+        )
+        self._pending[interaction.interaction_id] = interaction
+        await self._emit(
+            EventType.A2UI_INTERACTION,
+            invocation_id,
+            {
+                "surface_id": surface.surface_id,
+                "interaction_id": interaction.interaction_id,
+                "kind": kind,
+                "input_schema": dict(schema),
+            },
+        )
+        return interaction
+
+    async def submit_action(
+        self,
+        action: dict[str, Any],
+        *,
+        invocation_id: str,
+        origin: str = "local",
+    ) -> ActionReceipt:
+        """非阻塞 action(原 run 可已结束):登记 action.received,返回幂等回执。
+
+        ``action``: ``{"action_id","surface_id","name","actor"?,"component_id"?}``。
+        """
+        receipt = ActionReceipt(
+            action_id=str(action.get("action_id") or f"act_{uuid.uuid4().hex[:12]}"),
+            surface_id=str(action["surface_id"]),
+            name=str(action["name"]),
+            actor=str(action.get("actor") or "user"),
+            status="received",
+        )
+        await self._emit(
+            EventType.A2UI_ACTION,
+            invocation_id,
+            {
+                "surface_id": receipt.surface_id,
+                "action_id": receipt.action_id,
+                "name": receipt.name,
+                "actor": receipt.actor,
+                "component_id": action.get("component_id"),
+                "origin": origin,
+            },
+        )
+        return receipt
+
+    async def end_surface(self, surface_id: str, *, invocation_id: str) -> None:
+        """结束 surface(surface.end)。"""
+        await self._emit(
+            EventType.A2UI_SURFACE_END,
+            invocation_id,
+            {"surface_id": surface_id},
+        )
+        self._seen_surfaces.discard(surface_id)
+
+    # ---- 查询 ----
+
+    def pending_interaction(self, interaction_id: str) -> Optional[PendingInteraction]:
+        return self._pending.get(interaction_id)
+
+
+__all__ = ["A2UICore"]

ksadk/a2ui/models.py

@@ -0,0 +1,166 @@
+"""A2UI 语义模型 + basic catalog (goal-13,canonical 见 docs/A2UI-agent驱动UI技术方案.md)。
+
+模型独立于 transport(RuntimeEvent 是 canonical;Responses/A2A 只是 adapter):
+
+- ``Component`` / ``Surface``:声明式组件树 + 数据模型(props 是**数据**,不含可执行代码)。
+- ``PendingInteraction``:一次 ``request_ui_input`` 的持久化身份(input_required 语义)。
+- ``ActionReceipt``:一次 action 的幂等回执。
+- ``BASIC_CATALOG``:Q3 MVP 渲染集(Card/Text/Form/Select/RadioGroup/CheckboxGroup/
+  ApprovalBar)。**未知组件类型安全降级**(渲染为占位,不执行任意代码),符合设计 §3.1/§3.2。
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+#: pinned A2UI core 版本(goal-13 版本约束:a2ui-core==0.1.1,A2UI v1.0 Candidate)。
+#: 校验期据此断言构建期 pinned 版本未漂移(Q4 治理:upstream commit + schema/catalog SHA)。
+try:
+    from a2ui.core.version import __version__ as A2UI_CORE_VERSION
+except ImportError:  # pragma: no cover - a2ui-core 未安装时显式降级
+    A2UI_CORE_VERSION = "uninstalled"
+
+# ---------------------------------------------------------------------------
+# basic catalog(Q3 MVP 渲染集;未知类型安全降级)
+# ---------------------------------------------------------------------------
+
+#: 允许展示/交互的组件类型及其允许的 prop 键(白名单;props 是数据,不允许代码)。
+BASIC_CATALOG: dict[str, frozenset[str]] = {
+    "Card": frozenset({"title", "body", "footer", "children"}),
+    "Text": frozenset({"text", "variant"}),
+    "Form": frozenset({"title", "fields", "submit_label"}),
+    "Select": frozenset({"label", "options", "value"}),
+    "RadioGroup": frozenset({"label", "options", "value"}),
+    "CheckboxGroup": frozenset({"label", "options", "value"}),
+    "ApprovalBar": frozenset({"tool_name", "summary", "approve_label", "deny_label"}),
+}
+
+#: catalog 标识(对应 pinned basic catalog;构建期校验 SHA 是后续治理项)。
+BASIC_CATALOG_ID = "a2ui.org/catalogs/basic/v1.0"
+
+
+class A2UIValidationError(ValueError):
+    """surface/component 校验失败(未知类型、非法 prop、结构错误)。"""
+
+
+@dataclass
+class Component:
+    """声明式组件(props 是数据,不可执行)。"""
+
+    component_id: str
+    type: str
+    props: dict[str, Any] = field(default_factory=dict)
+    children: list["Component"] = field(default_factory=list)
+
+    def validate(self, catalog: dict[str, frozenset[str]] = BASIC_CATALOG) -> None:
+        """校验组件类型已知 + prop 在白名单 + 无嵌套代码字段。未知类型 → 安全降级错误。"""
+        if self.type not in catalog:
+            raise A2UIValidationError(
+                f"未知组件类型 {self.type!r}(不在 basic catalog;安全降级,不渲染任意代码)"
+            )
+        allowed = catalog[self.type]
+        unknown_props = set(self.props.keys()) - allowed - {"children"}
+        if unknown_props:
+            raise A2UIValidationError(f"组件 {self.type} 含白名单外 prop: {sorted(unknown_props)}")
+        for key, value in self.props.items():
+            if callable(value):
+                raise A2UIValidationError(f"组件 {self.type} prop {key} 不可为可执行代码")
+        for child in self.children:
+            child.validate(catalog)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "component_id": self.component_id,
+            "type": self.type,
+            "props": self.props,
+            "children": [c.to_dict() for c in self.children],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Component":
+        """从 dict(a2ui.surface.* 事件 payload 中的组件)重建;供 renderer 反序列化。"""
+        return cls(
+            component_id=str(data.get("component_id") or ""),
+            type=str(data.get("type") or ""),
+            props=dict(data.get("props") or {}),
+            children=[cls.from_dict(c) for c in data.get("children") or []],
+        )
+
+
+@dataclass
+class Surface:
+    """一个 UI surface(组件树 + 数据模型)。"""
+
+    surface_id: str
+    components: list[Component] = field(default_factory=list)
+    data_model: dict[str, Any] = field(default_factory=dict)
+    catalog_id: str = BASIC_CATALOG_ID
+
+    @classmethod
+    def new(cls, components: list[Component], *, data_model: Optional[dict] = None) -> "Surface":
+        return cls(
+            surface_id=f"surf_{uuid.uuid4().hex[:12]}",
+            components=components,
+            data_model=data_model or {},
+        )
+
+    def validate(self, catalog: dict[str, frozenset[str]] = BASIC_CATALOG) -> None:
+        if not self.surface_id:
+            raise A2UIValidationError("surface_id 不能为空")
+        for component in self.components:
+            component.validate(catalog)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "surface_id": self.surface_id,
+            "catalog_id": self.catalog_id,
+            "components": [c.to_dict() for c in self.components],
+            "data_model": self.data_model,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Surface":
+        """从 dict(a2ui.surface.* 事件 payload["surface"])重建 Surface;供 renderer 反序列化。"""
+        return cls(
+            surface_id=str(data.get("surface_id") or ""),
+            components=[Component.from_dict(c) for c in data.get("components") or []],
+            data_model=dict(data.get("data_model") or {}),
+            catalog_id=str(data.get("catalog_id") or BASIC_CATALOG_ID),
+        )
+
+
+@dataclass
+class PendingInteraction:
+    """一次 request_ui_input 的持久化身份(input_required;命中后 resume)。"""
+
+    interaction_id: str
+    surface_id: str
+    kind: str  # "form" | "select" | "approval" | ...
+    input_schema: dict[str, Any] = field(default_factory=dict)
+    status: str = "pending"  # "pending" | "resolved" | "expired"
+
+
+@dataclass
+class ActionReceipt:
+    """一次 action 的幂等回执(审计用)。"""
+
+    action_id: str
+    surface_id: str
+    name: str
+    actor: str = "user"
+    status: str = "received"  # "received" | "completed" | "failed"
+    response: Optional[dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+__all__ = [
+    "A2UIValidationError",
+    "ActionReceipt",
+    "BASIC_CATALOG",
+    "BASIC_CATALOG_ID",
+    "Component",
+    "PendingInteraction",
+    "Surface",
+]

ksadk/a2ui/renderer.py

@@ -0,0 +1,198 @@
+"""A2UI renderer registry + 流式渲染 + SubmitA2UIAction 回传 (goal-14,canonical §5.4)。
+
+- **registry**:Card / Text / Form / Select / RadioGroup / CheckboxGroup / ApprovalBar 渲染;
+  **未知 catalog/组件类型安全降级**为 ``placeholder``,**不执行任何动态代码**(安全约束)。
+- **Approval 是硬要求**(goal-18 预发演示的人机交互):``ApprovalBar`` 渲染为可交互审批卡,
+  带 approve/deny 动作,经 :func:`submit_a2ui_action`(SubmitA2UIAction)回传到
+  :class:`~ksadk.a2ui.core.A2UICore.submit_action`,形成"渲染→人点选→回传→resume"闭环。
+- **parser 复用 goal-12 共享实现,不在 renderer 复制**(停止条件):surface 状态经
+  goal-13 ``Surface.from_dict`` 从 a2ui.surface.* 事件重建,renderer 只负责渲染。
+- **live/replay 状态一致**:同一 surface 事件流,live 渲染与 replay 渲染产物逐字节一致
+  (``to_json`` 确定性);交互记录(a2ui.action)也经 goal-12 replay 可回放。
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+from ksadk.a2ui.models import BASIC_CATALOG, Component, Surface
+
+# ---------------------------------------------------------------------------
+# RenderedNode:渲染产物(确定性,可 to_json 供 conformance)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class RenderedNode:
+    """一个渲染节点(组件渲染结果;``actions`` 承载可交互动作,如审批卡的 approve/deny)。"""
+
+    type: str
+    props: dict[str, Any] = field(default_factory=dict)
+    children: list["RenderedNode"] = field(default_factory=list)
+    actions: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "type": self.type,
+            "props": self.props,
+            "actions": self.actions,
+            "children": [c.to_dict() for c in self.children],
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+# ---------------------------------------------------------------------------
+# 各类型 renderer(纯函数,无动态代码)
+# ---------------------------------------------------------------------------
+
+
+def _render_text(comp: Component, _r: "A2UIRenderer") -> RenderedNode:
+    return RenderedNode(
+        type="text",
+        props={"text": str(comp.props.get("text") or ""), "variant": comp.props.get("variant")},
+    )
+
+
+def _render_card(comp: Component, r: "A2UIRenderer") -> RenderedNode:
+    return RenderedNode(
+        type="card",
+        props={
+            "title": comp.props.get("title"),
+            "body": comp.props.get("body"),
+            "footer": comp.props.get("footer"),
+        },
+        children=[r.render_component(c) for c in comp.children],
+    )
+
+
+def _render_form(comp: Component, r: "A2UIRenderer") -> RenderedNode:
+    return RenderedNode(
+        type="form",
+        props={
+            "title": comp.props.get("title"),
+            "fields": comp.props.get("fields") or [],
+            "submit_label": comp.props.get("submit_label") or "提交",
+        },
+        actions=[{"name": "submit", "label": comp.props.get("submit_label") or "提交"}],
+        children=[r.render_component(c) for c in comp.children],
+    )
+
+
+def _render_choice(kind: str) -> Callable[[Component, "A2UIRenderer"], RenderedNode]:
+    def _render(comp: Component, _r: "A2UIRenderer") -> RenderedNode:
+        return RenderedNode(
+            type=kind,
+            props={
+                "label": comp.props.get("label"),
+                "options": comp.props.get("options") or [],
+                "value": comp.props.get("value"),
+            },
+            actions=[{"name": "change", "label": comp.props.get("label")}],
+        )
+
+    return _render
+
+
+def _render_approval(comp: Component, _r: "A2UIRenderer") -> RenderedNode:
+    """ApprovalBar → 可交互审批卡(approve/deny 动作;硬要求,goal-18 人机交互用)。"""
+    return RenderedNode(
+        type="approval",
+        props={
+            "tool_name": comp.props.get("tool_name"),
+            "summary": comp.props.get("summary"),
+        },
+        actions=[
+            {"name": "approve", "label": comp.props.get("approve_label") or "批准"},
+            {"name": "deny", "label": comp.props.get("deny_label") or "拒绝"},
+        ],
+    )
+
+
+def _render_placeholder(comp: Component, _r: "A2UIRenderer") -> RenderedNode:
+    """未知类型安全降级:渲染为占位,**不执行任何动态代码**(props 不回显为可执行内容)。"""
+    return RenderedNode(
+        type="placeholder",
+        props={"reason": f"未知组件类型 {comp.type!r},已安全降级"},
+    )
+
+
+# ---------------------------------------------------------------------------
+# A2UIRenderer registry
+# ---------------------------------------------------------------------------
+
+
+class A2UIRenderer:
+    """A2UI renderer registry(类型 → renderer;未知类型安全降级,不执行动态代码)。"""
+
+    def __init__(self, catalog: dict[str, frozenset[str]] = BASIC_CATALOG) -> None:
+        self._catalog = catalog
+        self._renderers: dict[str, Callable[[Component, "A2UIRenderer"], RenderedNode]] = {
+            "Card": _render_card,
+            "Text": _render_text,
+            "Form": _render_form,
+            "Select": _render_choice("select"),
+            "RadioGroup": _render_choice("radio_group"),
+            "CheckboxGroup": _render_choice("checkbox_group"),
+            "ApprovalBar": _render_approval,
+        }
+
+    def register(
+        self, component_type: str, renderer: Callable[[Component, "A2UIRenderer"], RenderedNode]
+    ) -> None:
+        """注册自定义 renderer(扩展 catalog 用;renderer 必须是纯函数,不含动态代码)。"""
+        self._renderers[component_type] = renderer
+
+    def render_component(self, component: Component) -> RenderedNode:
+        renderer = self._renderers.get(component.type, _render_placeholder)
+        return renderer(component, self)
+
+    def render_surface(self, surface: Surface) -> RenderedNode:
+        """渲染一个 surface(流式:组件树递归渲染;产物确定性,供 live/replay conformance)。"""
+        return RenderedNode(
+            type="surface",
+            props={"surface_id": surface.surface_id, "catalog_id": surface.catalog_id},
+            children=[self.render_component(c) for c in surface.components],
+        )
+
+
+# ---------------------------------------------------------------------------
+# SubmitA2UIAction 回传(渲染 → 人点选 → 回传 → resume)
+# ---------------------------------------------------------------------------
+
+
+async def submit_a2ui_action(
+    core: Any,
+    *,
+    action_id: str,
+    surface_id: str,
+    name: str,
+    actor: str = "user",
+    component_id: Optional[str] = None,
+    invocation_id: str,
+) -> Any:
+    """SubmitA2UIAction:把用户对渲染卡(如审批卡 approve/deny)的点选回传到 A2UICore。
+
+    与 :class:`~ksadk.a2ui.core.A2UICore.submit_action` 接口对齐(不在 renderer 侧自造语义):
+    产出 ``a2ui.action`` 事件(经 RuntimeEvent 持久化),供 resume / 审计 / 回放。
+    """
+    return await core.submit_action(
+        {
+            "action_id": action_id,
+            "surface_id": surface_id,
+            "name": name,
+            "actor": actor,
+            "component_id": component_id,
+        },
+        invocation_id=invocation_id,
+    )
+
+
+__all__ = [
+    "A2UIRenderer",
+    "RenderedNode",
+    "submit_a2ui_action",
+]

ksadk/agui/__init__.py

@@ -0,0 +1,9 @@
+"""Official AG-UI transport integration for KSADK runtimes."""
+
+from ksadk.agui.config import (
+    AGUI_PROTOCOL_VERSION,
+    AGUIConfig,
+    agui_dependencies_available,
+)
+
+__all__ = ["AGUIConfig", "AGUI_PROTOCOL_VERSION", "agui_dependencies_available"]

ksadk/agui/a2ui_projection.py

@@ -0,0 +1,92 @@
+"""Project canonical A2UI RuntimeEvents into official AG-UI activity content."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from ksadk.events.runtime_event import EventType
+
+
+def project_a2ui_operations(event_type: str, payload: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Return A2UI v0.9 operations carried by an AG-UI activity event."""
+
+    explicit = payload.get("operations", payload.get("a2ui_operations"))
+    if isinstance(explicit, list):
+        return [dict(operation) for operation in explicit if isinstance(operation, Mapping)]
+
+    surface_id = str(payload.get("surface_id") or payload.get("surfaceId") or "")
+    if not surface_id:
+        return []
+    if event_type == EventType.A2UI_SURFACE_END:
+        return [{"version": "v0.9", "deleteSurface": {"surfaceId": surface_id}}]
+
+    surface = payload.get("surface")
+    surface_data = surface if isinstance(surface, Mapping) else payload
+    components = _flatten_components(surface_data.get("components"))
+    data_model = surface_data.get("data_model", surface_data.get("dataModel"))
+    operations: list[dict[str, Any]] = []
+    if event_type == EventType.A2UI_SURFACE_BEGIN:
+        catalog_id = str(
+            surface_data.get("catalog_id")
+            or surface_data.get("catalogId")
+            or payload.get("catalog_id")
+            or payload.get("catalogId")
+            or "https://a2ui.org/specification/v0_9/basic_catalog.json"
+        )
+        operations.append(
+            {
+                "version": "v0.9",
+                "createSurface": {"surfaceId": surface_id, "catalogId": catalog_id},
+            }
+        )
+    if components:
+        operations.append(
+            {
+                "version": "v0.9",
+                "updateComponents": {"surfaceId": surface_id, "components": components},
+            }
+        )
+    if data_model is not None:
+        operations.append(
+            {
+                "version": "v0.9",
+                "updateDataModel": {
+                    "surfaceId": surface_id,
+                    "path": "/",
+                    "value": data_model,
+                },
+            }
+        )
+    return operations
+
+
+def _flatten_components(raw: Any) -> list[dict[str, Any]]:
+    if not isinstance(raw, list):
+        return []
+    flattened: list[dict[str, Any]] = []
+
+    def visit(component: Any) -> str:
+        if not isinstance(component, Mapping):
+            return ""
+        component_id = str(component.get("id") or component.get("component_id") or "")
+        component_type = str(component.get("component") or component.get("type") or "")
+        if not component_id or not component_type:
+            return ""
+        children = [visit(child) for child in component.get("children") or []]
+        children = [child_id for child_id in children if child_id]
+        entry: dict[str, Any] = {"id": component_id, "component": component_type}
+        props = component.get("props")
+        if isinstance(props, Mapping):
+            entry.update(dict(props))
+        if children and "children" not in entry and "child" not in entry:
+            entry["children"] = children
+        flattened.append(entry)
+        return component_id
+
+    for item in raw:
+        visit(item)
+    return flattened
+
+
+__all__ = ["project_a2ui_operations"]