agentplane-runtime 0.0.1__py3-none-any.whl

agentplane_runtime/definitions.py

@@ -0,0 +1,280 @@
+"""Definition lifecycle service (SPEC §6.1/§6.2): draft -> versions -> endpoints."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import UTC, datetime
+
+from sqlalchemy import select
+
+from agentplane_core import (
+    DefinitionInfo,
+    DeploymentInfo,
+    FlowDefinition,
+    ValidationResult,
+)
+from agentplane_runtime.db import (
+    Database,
+    DefinitionRow,
+    VersionRow,
+    dump_definition,
+    latest_version,
+    load_definition,
+)
+from agentplane_runtime.registration import RegistryRegistrar
+from agentplane_runtime.resources import ResourceService
+from agentplane_runtime.serving import EndpointManager
+from agentplane_runtime.validation import validate_full
+
+
+class DefinitionNotFoundError(Exception):
+    pass
+
+
+class DefinitionConflictError(Exception):
+    pass
+
+
+class DefinitionStateError(Exception):
+    """Operation not allowed in the current lifecycle state."""
+
+
+class DefinitionInvalidError(Exception):
+    def __init__(self, result: ValidationResult) -> None:
+        super().__init__("definition validation failed")
+        self.result = result
+
+
+class DefinitionService:
+    """Owns definitions and their lifecycle: draft, deploy, undeploy, delete."""
+
+    def __init__(
+        self,
+        db: Database,
+        resources: ResourceService,
+        endpoints: EndpointManager,
+        registrar: RegistryRegistrar,
+    ) -> None:
+        self._db = db
+        self._resources = resources
+        self._endpoints = endpoints
+        self._registrar = registrar
+
+    async def validate(self, defn: FlowDefinition | dict[str, object]) -> ValidationResult:
+        return await validate_full(defn, self._resources)
+
+    async def _row(self, name: str) -> DefinitionRow:
+        async with self._db.session() as session:
+            row = await session.get(DefinitionRow, name)
+        if row is None:
+            raise DefinitionNotFoundError(name)
+        return row
+
+    async def create_draft(self, defn: FlowDefinition, owner: str) -> DefinitionInfo:
+        result = await self.validate(defn)
+        if not result.valid:
+            raise DefinitionInvalidError(result)
+        async with self._db.session() as session:
+            existing = await session.get(DefinitionRow, defn.name)
+        if existing is not None:
+            raise DefinitionConflictError(defn.name)
+        now = datetime.now(UTC)
+        row = DefinitionRow(
+            name=defn.name,
+            owner=owner,
+            status="draft",
+            draft_json=dump_definition(defn),
+            created_at=now,
+            updated_at=now,
+        )
+        async with self._db.session() as session, session.begin():
+            session.add(row)
+        return await self.info(defn.name)
+
+    async def update_draft(self, name: str, defn: FlowDefinition) -> DefinitionInfo:
+        if defn.name != name:
+            raise DefinitionConflictError(
+                f"definition name {defn.name!r} does not match path {name!r}"
+            )
+        result = await self.validate(defn)
+        if not result.valid:
+            raise DefinitionInvalidError(result)
+        async with self._db.session() as session, session.begin():
+            row = await session.get(DefinitionRow, name)
+            if row is None:
+                raise DefinitionNotFoundError(name)
+            row.draft_json = dump_definition(defn)
+            row.updated_at = datetime.now(UTC)
+        return await self.info(name)
+
+    async def deploy(
+        self, name: str, *, version: int | None = None, ephemeral: bool = False
+    ) -> DeploymentInfo:
+        row = await self._row(name)
+        if ephemeral:
+            return await self._deploy_ephemeral(row)
+
+        if version is None:
+            draft = load_definition(row.draft_json)
+            result = await self.validate(draft)
+            if not result.valid:
+                raise DefinitionInvalidError(result)
+            async with self._db.session() as session, session.begin():
+                new_version = await latest_version(session, name) + 1
+                session.add(
+                    VersionRow(
+                        name=name,
+                        version=new_version,
+                        definition_json=dump_definition(draft),
+                    )
+                )
+            defn, active_version = draft, new_version
+        else:
+            defn, active_version = await self._load_version(name, version), version
+
+        endpoint = await self._endpoints.start(defn, active_version)
+        registry_id = await self._registrar.register(
+            defn, endpoint.public_url, uuid.UUID(row.registry_id) if row.registry_id else None
+        )
+        async with self._db.session() as session, session.begin():
+            fresh = await session.get(DefinitionRow, name)
+            if fresh is not None:
+                fresh.status = "deployed"
+                fresh.deployed_version = active_version
+                fresh.registry_id = str(registry_id) if registry_id else fresh.registry_id
+                fresh.updated_at = datetime.now(UTC)
+        return DeploymentInfo(
+            name=name,
+            version=active_version,
+            endpoint_url=endpoint.public_url,
+            registry_id=registry_id,
+        )
+
+    async def _deploy_ephemeral(self, row: DefinitionRow) -> DeploymentInfo:
+        """Playground endpoint for the draft: no registry entry, TTL-bound (§6.2)."""
+        draft = load_definition(row.draft_json)
+        result = await self.validate(draft)
+        if not result.valid:
+            raise DefinitionInvalidError(result)
+        endpoint = await self._endpoints.start(draft, 0, ephemeral=True)
+        return DeploymentInfo(
+            name=row.name, version=0, endpoint_url=endpoint.public_url, registry_id=None
+        )
+
+    async def _load_version(self, name: str, version: int) -> FlowDefinition:
+        async with self._db.session() as session:
+            result = await session.execute(
+                select(VersionRow).where(VersionRow.name == name, VersionRow.version == version)
+            )
+            row = result.scalar_one_or_none()
+        if row is None:
+            raise DefinitionNotFoundError(f"{name} version {version}")
+        return load_definition(row.definition_json)
+
+    async def undeploy(self, name: str) -> None:
+        row = await self._row(name)
+        if row.status != "deployed":
+            raise DefinitionStateError(f"{name} is not deployed")
+        await self._endpoints.stop(name)
+        await self._registrar.deregister(uuid.UUID(row.registry_id) if row.registry_id else None)
+        async with self._db.session() as session, session.begin():
+            fresh = await session.get(DefinitionRow, name)
+            if fresh is not None:
+                fresh.status = "undeployed"
+                fresh.deployed_version = None
+                fresh.registry_id = None
+                fresh.updated_at = datetime.now(UTC)
+
+    async def delete(self, name: str) -> None:
+        row = await self._row(name)
+        if row.status == "deployed":
+            raise DefinitionStateError(f"{name} is deployed; undeploy first")
+        async with self._db.session() as session, session.begin():
+            fresh = await session.get(DefinitionRow, name)
+            if fresh is not None:
+                await session.delete(fresh)
+            versions = (
+                (await session.execute(select(VersionRow).where(VersionRow.name == name)))
+                .scalars()
+                .all()
+            )
+            for version_row in versions:
+                await session.delete(version_row)
+
+    async def info(self, name: str, *, include_definition: bool = False) -> DefinitionInfo:
+        row = await self._row(name)
+        return await self._to_info(row, include_definition=include_definition)
+
+    async def _to_info(
+        self, row: DefinitionRow, *, include_definition: bool = False
+    ) -> DefinitionInfo:
+        draft = load_definition(row.draft_json)
+        async with self._db.session() as session:
+            latest = await latest_version(session, row.name)
+        endpoint = self._endpoints.endpoint_for(row.name)
+        status = row.status
+        if status not in ("draft", "deployed", "undeployed"):  # pragma: no cover
+            status = "draft"
+        return DefinitionInfo.model_validate(
+            {
+                "name": row.name,
+                "display_name": draft.display_name,
+                "description": draft.description,
+                "tags": draft.tags,
+                "expose_kind": draft.expose.kind,
+                "status": status,
+                "latest_version": latest or None,
+                "deployed_version": row.deployed_version,
+                "endpoint_url": endpoint.public_url if endpoint is not None else None,
+                "owner": row.owner,
+                "created_at": row.created_at,
+                "updated_at": row.updated_at,
+                "definition": draft if include_definition else None,
+            }
+        )
+
+    async def list(self, status: str | None = None) -> list[DefinitionInfo]:
+        stmt = select(DefinitionRow).order_by(DefinitionRow.name)
+        if status is not None:
+            stmt = stmt.where(DefinitionRow.status == status)
+        async with self._db.session() as session:
+            rows = (await session.execute(stmt)).scalars().all()
+        return [await self._to_info(row) for row in rows]
+
+    async def export(self, name: str, version: int | None = None) -> FlowDefinition:
+        if version is not None:
+            return await self._load_version(name, version)
+        row = await self._row(name)
+        return load_definition(row.draft_json)
+
+    async def restore_deployed_endpoints(self) -> None:
+        """On startup: restart endpoints for deployed definitions and re-register."""
+        async with self._db.session() as session:
+            rows = (
+                (
+                    await session.execute(
+                        select(DefinitionRow).where(DefinitionRow.status == "deployed")
+                    )
+                )
+                .scalars()
+                .all()
+            )
+        for row in rows:
+            if row.deployed_version is None:
+                continue
+            defn = await self._load_version(row.name, row.deployed_version)
+            endpoint = await self._endpoints.start(defn, row.deployed_version)
+            await self._registrar.register(
+                defn,
+                endpoint.public_url,
+                uuid.UUID(row.registry_id) if row.registry_id else None,
+            )
+
+
+__all__ = [
+    "DefinitionConflictError",
+    "DefinitionInvalidError",
+    "DefinitionNotFoundError",
+    "DefinitionService",
+    "DefinitionStateError",
+]

agentplane_runtime/engine.py

@@ -0,0 +1,407 @@
+"""Flow execution engine (SPEC §6.4): a deployed version compiles to a LangGraph
+graph once (cached); every node execution is one OTel span.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Awaitable, Callable
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from operator import or_
+from typing import Annotated, Protocol, TypedDict
+
+from langgraph.graph import END, START, StateGraph
+from opentelemetry import trace
+from pydantic import JsonValue
+
+from agentplane_core import (
+    Document,
+    EndNode,
+    FlowDefinition,
+    JsonObject,
+    LlmCallNode,
+    McpServerResource,
+    McpToolNode,
+    ModelProviderResource,
+    Node,
+    RetrievalNode,
+    RouterNode,
+    RouterNodeConfig,
+    StartNode,
+    TemplateNode,
+    VectorDBResource,
+    input_ports,
+    render_documents,
+    split_port_ref,
+)
+from agentplane_runtime.llm import OpenAICompatibleClient
+from agentplane_runtime.resources import ResourceService
+from agentplane_runtime.settings import RuntimeSettings
+from agentplane_runtime.vector import reader_for
+
+tracer = trace.get_tracer("agentplane-runtime")
+
+# A port value: JSON-serializable data or a list of retrieved documents.
+PortValue = JsonValue | list[Document]
+
+StreamCallback = Callable[[str], Awaitable[None]]
+
+
+class FlowError(RuntimeError):
+    """A node failed during execution."""
+
+
+# Per-run token stream callback. A ContextVar (not runner state) because the
+# compiled runner is shared across concurrent requests.
+_stream_var: ContextVar[StreamCallback | None] = ContextVar("agentplane_stream", default=None)
+
+
+class FlowState(TypedDict):
+    """LangGraph state: values keyed by 'node_id.port'."""
+
+    values: Annotated[dict[str, PortValue], or_]
+
+
+class _NodeFn(Protocol):
+    """A LangGraph node callable (named ``state`` parameter, async update)."""
+
+    def __call__(self, state: FlowState) -> Awaitable[dict[str, object]]: ...
+
+
+@dataclass
+class ExecutionContext:
+    """Per-run context: resource access and optional token streaming."""
+
+    resources: ResourceService
+    settings: RuntimeSettings
+    stream: StreamCallback | None = None
+    flow_name: str = ""
+    flow_version: int = 0
+    extra_attributes: dict[str, str] = field(default_factory=dict)
+
+
+def _as_text(value: PortValue) -> str:
+    """Implicit conversion to a text port (documents render, json stringifies)."""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list) and value and all(isinstance(v, Document) for v in value):
+        return render_documents([v for v in value if isinstance(v, Document)])
+    if isinstance(value, list) and not value:
+        return ""
+    return json.dumps(value, ensure_ascii=False, default=str)
+
+
+def _as_json(value: PortValue) -> JsonValue:
+    if isinstance(value, list) and value and all(isinstance(v, Document) for v in value):
+        return [v.model_dump(mode="json") for v in value if isinstance(v, Document)]
+    if isinstance(value, list):
+        return [
+            item.model_dump(mode="json") if isinstance(item, Document) else item for item in value
+        ]
+    return value
+
+
+class FlowRunner:
+    """Compiles a FlowDefinition into a LangGraph graph and runs it."""
+
+    def __init__(self, defn: FlowDefinition, context: ExecutionContext) -> None:
+        self._defn = defn
+        self._context = context
+        self._nodes = defn.node_map()
+        # inbound edges per node: input port -> source refs. A port may be fed
+        # by several edges (branch convergence on `end.input`); at runtime the
+        # first ref present in the state wins — with a router upstream exactly
+        # one branch produced a value.
+        self._inputs: dict[str, dict[str, list[str]]] = {node_id: {} for node_id in self._nodes}
+        for edge in defn.edges:
+            dst_node, dst_port = split_port_ref(edge.to)
+            if dst_node in self._inputs:
+                self._inputs[dst_node].setdefault(dst_port, []).append(edge.from_)
+        self._graph = self._compile()
+
+    def _compile(self) -> object:
+        builder = StateGraph(FlowState)
+        for node in self._defn.nodes:
+            builder.add_node(node.id, self._executor_for(node))
+        start = next(n for n in self._defn.nodes if isinstance(n, StartNode))
+        end = next(n for n in self._defn.nodes if isinstance(n, EndNode))
+        routers = [n for n in self._defn.nodes if isinstance(n, RouterNode)]
+        router_ids = {n.id for n in routers}
+        builder.add_edge(START, start.id)
+        seen: set[tuple[str, str]] = set()
+        for edge in self._defn.edges:
+            src, _ = split_port_ref(edge.from_)
+            dst, _ = split_port_ref(edge.to)
+            if src in router_ids:
+                continue  # routers wire conditionally below
+            if (src, dst) not in seen and src in self._nodes and dst in self._nodes:
+                builder.add_edge(src, dst)
+                seen.add((src, dst))
+        for router in routers:
+            self._wire_router(builder, router)
+        # output_from creates an implicit dependency when no edge exists yet
+        out_src, _ = split_port_ref(end.config.output_from)
+        if (out_src, end.id) not in seen and out_src in self._nodes and out_src != end.id:
+            builder.add_edge(out_src, end.id)
+        builder.add_edge(end.id, END)
+        return builder.compile()
+
+    def _wire_router(self, builder: StateGraph[FlowState], router: RouterNode) -> None:
+        """Only the chosen branch's downstream nodes execute (conditional edges)."""
+        targets_by_branch: dict[str, list[str]] = {}
+        for edge in self._defn.edges:
+            src, src_port = split_port_ref(edge.from_)
+            if src != router.id:
+                continue
+            dst, _ = split_port_ref(edge.to)
+            if dst in self._nodes:
+                targets_by_branch.setdefault(src_port, []).append(dst)
+        router_id = router.id
+
+        def selector(state: FlowState) -> list[str] | str:
+            values = state["values"]
+            for branch, targets in targets_by_branch.items():
+                if f"{router_id}.{branch}" in values:
+                    return targets
+            return END  # chosen branch has no wired targets — this path ends
+
+        path_map = sorted({t for targets in targets_by_branch.values() for t in targets})
+        builder.add_conditional_edges(router_id, selector, [*path_map, END])
+
+    def _executor_for(self, node: Node) -> _NodeFn:
+        async def run_node(state: FlowState) -> dict[str, object]:
+            with tracer.start_as_current_span(
+                "agentplane.node",
+                attributes={
+                    "flow.name": self._context.flow_name,
+                    "flow.version": self._context.flow_version,
+                    "node.id": node.id,
+                    "node.type": node.type,
+                },
+            ):
+                outputs = await self._run(node, state["values"])
+            return {"values": outputs}
+
+        return run_node
+
+    def _gather_inputs(self, node: Node, values: dict[str, PortValue]) -> dict[str, PortValue]:
+        gathered: dict[str, PortValue] = {}
+        for port, source_refs in self._inputs.get(node.id, {}).items():
+            for source_ref in source_refs:
+                if source_ref in values:
+                    gathered[port] = values[source_ref]
+                    break
+        return gathered
+
+    async def _run(  # noqa: PLR0911 - one return per node type
+        self, node: Node, values: dict[str, PortValue]
+    ) -> dict[str, PortValue]:
+        inputs = self._gather_inputs(node, values)
+        match node:
+            case StartNode():
+                return {}  # start outputs are seeded before invocation
+            case EndNode():
+                if node.config.output_from:
+                    return {f"{node.id}.output": values.get(node.config.output_from)}
+                # empty output_from: take the value wired into `input` —
+                # branched flows feed end from whichever branch executed
+                return {f"{node.id}.output": inputs.get("input")}
+            case LlmCallNode():
+                return await self._run_llm(node, inputs)
+            case RetrievalNode():
+                return await self._run_retrieval(node, inputs)
+            case McpToolNode():
+                return await self._run_mcp_tool(node, inputs)
+            case RouterNode():
+                value = inputs.get("input")
+                branch = _route(node.config, value)
+                return {f"{node.id}.{branch}": value}
+            case TemplateNode():
+                rendered = {port: _as_text(value) for port, value in inputs.items()}
+                for port in input_ports(node):
+                    rendered.setdefault(port, "")
+                return {f"{node.id}.text": _format_prompt(node.config.text, rendered)}
+
+    async def _llm_client(self, resource_name: str) -> tuple[OpenAICompatibleClient, str]:
+        resource = await self._context.resources.get_raw(resource_name)
+        if not isinstance(resource, ModelProviderResource):
+            raise FlowError(f"resource {resource_name!r} is not a model provider")
+        api_key = ""
+        if resource.api_key_secret:
+            try:
+                api_key = await self._context.resources.secret_value(
+                    resource_name, "api_key_secret"
+                )
+            except KeyError:
+                api_key = ""
+        base_url = resource.base_url or self._context.settings.llm_base_url
+        if not base_url:
+            raise FlowError(
+                f"model provider {resource_name!r} has no base_url and no "
+                "AGENTPLANE_RUNTIME_LLM_BASE_URL default is configured"
+            )
+        client = OpenAICompatibleClient(
+            base_url, api_key, timeout=self._context.settings.http_timeout_s
+        )
+        return client, resource.default_model
+
+    async def _run_llm(
+        self, node: LlmCallNode, inputs: dict[str, PortValue]
+    ) -> dict[str, PortValue]:
+        config = node.config
+        rendered = {port: _as_text(value) for port, value in inputs.items()}
+        for port in input_ports(node):
+            rendered.setdefault(port, "")
+        prompt = _format_prompt(config.prompt, rendered)
+        system_prompt = _format_prompt(config.system_prompt, rendered)
+        client, default_model = await self._llm_client(config.resource)
+        model = config.model or default_model
+        if not model:
+            raise FlowError(f"node {node.id!r}: no model configured (node or resource default)")
+
+        stream_cb = _stream_var.get() or self._context.stream
+        if config.stream and stream_cb is not None:
+            chunks: list[str] = []
+            async for delta in client.stream(
+                model, prompt, system_prompt, config.structured_output
+            ):
+                chunks.append(delta)
+                await stream_cb(delta)
+            text = "".join(chunks)
+        else:
+            text = await client.complete(model, prompt, system_prompt, config.structured_output)
+
+        outputs: dict[str, PortValue] = {f"{node.id}.text": text}
+        if config.structured_output is not None:
+            try:
+                outputs[f"{node.id}.json"] = json.loads(text)
+            except ValueError as exc:
+                raise FlowError(f"node {node.id!r}: structured output is not JSON") from exc
+        return outputs
+
+    async def _run_retrieval(
+        self, node: RetrievalNode, inputs: dict[str, PortValue]
+    ) -> dict[str, PortValue]:
+        config = node.config
+        query = _as_text(inputs.get("query", ""))
+        resource = await self._context.resources.get_raw(config.resource)
+        if not isinstance(resource, VectorDBResource):
+            raise FlowError(f"resource {config.resource!r} is not a vector DB")
+        embed_client, _ = await self._llm_client(resource.embedding.resource)
+        vector = await embed_client.embed(resource.embedding.model, query)
+        api_key, dsn = "", ""
+        if resource.api_key_secret:
+            api_key = await self._context.resources.secret_value(config.resource, "api_key_secret")
+        if resource.dsn_secret:
+            dsn = await self._context.resources.secret_value(config.resource, "dsn_secret")
+        reader = await reader_for(resource, api_key=api_key, dsn=dsn)
+        documents = await reader.search(config.collection, vector, config.top_k, config.filter)
+        return {f"{node.id}.documents": documents}
+
+    async def _run_mcp_tool(
+        self, node: McpToolNode, inputs: dict[str, PortValue]
+    ) -> dict[str, PortValue]:
+        from fastmcp import Client  # noqa: PLC0415 - deferred: heavy import
+
+        config = node.config
+        url = config.url
+        auth: str | None = None
+        if config.resource:
+            resource = await self._context.resources.get_raw(config.resource)
+            if not isinstance(resource, McpServerResource):
+                raise FlowError(f"resource {config.resource!r} is not an MCP server")
+            url = resource.url
+            if resource.auth_secret:
+                auth = await self._context.resources.secret_value(config.resource, "auth_secret")
+        if not url:
+            raise FlowError(f"node {node.id!r}: no MCP server url")
+        arguments = {arg_name: _as_json(inputs.get(port)) for port, arg_name in config.args.items()}
+        client = Client(url, auth=auth) if auth else Client(url)
+        async with client:
+            result = await client.call_tool(config.tool, arguments)
+        return {f"{node.id}.result": _tool_result_to_json(result)}
+
+    async def execute(
+        self, start_values: JsonObject, *, stream: StreamCallback | None = None
+    ) -> PortValue:
+        """Run the flow; returns the value of the end node's output."""
+        token = _stream_var.set(stream)
+        try:
+            return await self._execute(start_values)
+        finally:
+            _stream_var.reset(token)
+
+    async def _execute(self, start_values: JsonObject) -> PortValue:
+        start = next(n for n in self._defn.nodes if isinstance(n, StartNode))
+        end = next(n for n in self._defn.nodes if isinstance(n, EndNode))
+        seeded: dict[str, PortValue] = {
+            f"{start.id}.{key}": value for key, value in start_values.items()
+        }
+        with tracer.start_as_current_span(
+            "agentplane.flow",
+            attributes={
+                "flow.name": self._context.flow_name,
+                "flow.version": self._context.flow_version,
+            },
+        ):
+            graph = self._graph
+            result = await graph.ainvoke({"values": seeded})  # type: ignore[attr-defined]
+        values: dict[str, PortValue] = result["values"]
+        return values.get(f"{end.id}.output")
+
+
+def _is_empty(value: PortValue | None) -> bool:
+    """Router emptiness: None, blank text, empty list/object count as empty."""
+    if value is None:
+        return True
+    if isinstance(value, str):
+        return value.strip() == ""
+    if isinstance(value, (list, dict)):
+        return len(value) == 0
+    return False
+
+
+def _route(config: RouterNodeConfig, value: PortValue | None) -> str:
+    """First matching rule wins; otherwise the default branch."""
+    for rule in config.rules:
+        matched = _is_empty(value) if rule.when == "empty" else not _is_empty(value)
+        if matched:
+            return rule.branch
+    return config.default_branch
+
+
+def _format_prompt(template: str, values: dict[str, str]) -> str:
+    rendered = template
+    for name, value in values.items():
+        rendered = rendered.replace("{" + name + "}", value)
+    return rendered.replace("{{", "{").replace("}}", "}")
+
+
+def _tool_result_to_json(result: object) -> JsonValue:
+    """Map a FastMCP CallToolResult to a JSON port value."""
+    data = getattr(result, "data", None)
+    if data is not None:
+        try:
+            dumped = json.dumps(data, default=str)
+        except (TypeError, ValueError):
+            return str(data)
+        loaded: JsonValue = json.loads(dumped)
+        return loaded
+    content = getattr(result, "content", None)
+    if isinstance(content, list) and content:
+        first = content[0]
+        text = getattr(first, "text", None)
+        if isinstance(text, str):
+            return text
+    return None
+
+
+__all__ = [
+    "ExecutionContext",
+    "FlowError",
+    "FlowRunner",
+    "FlowState",
+    "PortValue",
+    "StreamCallback",
+]