getstack 2.0.0__tar.gz → 3.0.0__tar.gz

{getstack-2.0.0 → getstack-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: getstack
-Version: 2.0.0
+Version: 3.0.0
 Summary: Python SDK for STACK — trust infrastructure for AI agents
 Project-URL: Homepage, https://getstack.run
 Project-URL: Documentation, https://getstack.run/docs/sdk
@@ -125,8 +125,15 @@ stack.agents.list()
 stack.agents.update(agent_id, **fields)
 stack.agents.unblock(agent_id)
 
+# Missions (every passport is issued for exactly one Mission)
+stack.missions.open(intent_summary, agent_id=None, intent_services=None, ...)
+stack.missions.start(agent_id=agent_id, mission={"intent_summary": "..."}, passport=None)
+stack.missions.complete(mission_id)  # also revokes the Mission's passports
+stack.missions.revoke(mission_id, reason="operator_initiated_clean")
+
 # Passports
-stack.passports.issue(agent_id, intent=None, services=None, ...)
+stack.passports.issue(agent_id, mission_ids=[mission_id], intent=None, services=None, ...)
+stack.passports.mission(agent_id, intent, services, ...)  # context manager: Mission + passport, closed on exit
 stack.passports.verify(token)
 stack.passports.revoke(jti, reason=None)
 stack.passports.checkpoint(jti, services_used, actions_count, ...)
@@ -148,9 +155,9 @@ stack.reviews.list(status="flagged")
 stack.reviews.decide(checkout_id, decision, notes=None, block_future=False)
 
 # Drop-offs
-stack.dropoffs.create(from_agent_id, to_agent_id, schema, ...)
-stack.dropoffs.deposit(dropoff_id, data, agent_id)
-stack.dropoffs.collect(dropoff_id, agent_id)
+stack.dropoffs.create(from_agent_id, to_agent_id, schema, ..., passport_token=None)
+stack.dropoffs.deposit(dropoff_id, data, agent_id, passport_token=None)
+stack.dropoffs.collect(dropoff_id, agent_id, passport_token=None)
 
 # Notifications
 stack.notifications.list()

{getstack-2.0.0 → getstack-3.0.0}/README.md

@@ -98,8 +98,15 @@ stack.agents.list()
 stack.agents.update(agent_id, **fields)
 stack.agents.unblock(agent_id)
 
+# Missions (every passport is issued for exactly one Mission)
+stack.missions.open(intent_summary, agent_id=None, intent_services=None, ...)
+stack.missions.start(agent_id=agent_id, mission={"intent_summary": "..."}, passport=None)
+stack.missions.complete(mission_id)  # also revokes the Mission's passports
+stack.missions.revoke(mission_id, reason="operator_initiated_clean")
+
 # Passports
-stack.passports.issue(agent_id, intent=None, services=None, ...)
+stack.passports.issue(agent_id, mission_ids=[mission_id], intent=None, services=None, ...)
+stack.passports.mission(agent_id, intent, services, ...)  # context manager: Mission + passport, closed on exit
 stack.passports.verify(token)
 stack.passports.revoke(jti, reason=None)
 stack.passports.checkpoint(jti, services_used, actions_count, ...)
@@ -121,9 +128,9 @@ stack.reviews.list(status="flagged")
 stack.reviews.decide(checkout_id, decision, notes=None, block_future=False)
 
 # Drop-offs
-stack.dropoffs.create(from_agent_id, to_agent_id, schema, ...)
-stack.dropoffs.deposit(dropoff_id, data, agent_id)
-stack.dropoffs.collect(dropoff_id, agent_id)
+stack.dropoffs.create(from_agent_id, to_agent_id, schema, ..., passport_token=None)
+stack.dropoffs.deposit(dropoff_id, data, agent_id, passport_token=None)
+stack.dropoffs.collect(dropoff_id, agent_id, passport_token=None)
 
 # Notifications
 stack.notifications.list()

{getstack-2.0.0 → getstack-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "getstack"
-version = "2.0.0"
+version = "3.0.0"
 description = "Python SDK for STACK — trust infrastructure for AI agents"
 readme = "README.md"
 license = "MIT"

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/__init__.py

@@ -52,7 +52,7 @@ from .auth import ApiKeyAuth, SessionAuth, OAuthAuth, CredentialsFileAuth
 from .agent_auth import AgentKeypairAuth
 from .client import HttpClient, AsyncHttpClient, DEFAULT_BASE_URL
 from .agents import AgentService
-from .passports import PassportService, Mission
+from .passports import PassportService, Mission, _require_one_mission
 from .credentials import CredentialService
 from .services import ServiceService
 from .dropoffs import DropoffService
@@ -119,6 +119,7 @@ from .errors import (
     ForbiddenError,
     ValidationError,
     PassportBlockedError,
+    MissionEndedError,
 )
 
 try:
@@ -222,6 +223,7 @@ __all__ = [
     "ForbiddenError",
     "ValidationError",
     "PassportBlockedError",
+    "MissionEndedError",
 ]
 
 
@@ -301,18 +303,25 @@ class Stack:
         ttl_seconds: int | None = None,
         accountability_mode: str | None = None,
         authority_binding_ids: list[str] | None = None,
+        mission_ids: list[str] | None = None,
         **kwargs: Any,
     ) -> PassportSession:
         """Phase 5.2.6 — issue a passport and return a PassportSession
         that holds the token + auto-refreshes ~60s before expiry. Pass
         the returned session to LLM calls instead of threading a raw
-        token per call::
+        token per call. ``mission_ids`` must hold exactly one Mission id;
+        once that Mission ends, refresh raises ``MissionEndedError``::
 
-            session = stack.issue_passport(agent_id="agt_x", services=[...])
+            mission = stack.missions.open("Answer support tickets", agent_id="agt_x")
+            session = stack.issue_passport(agent_id="agt_x", mission_ids=[mission["mission_id"]])
             for i in range(1000):
                 stack.llm.anthropic.messages.create(body, passport=session)
         """
-        issue_input: dict[str, Any] = {"agent_id": agent_id, **kwargs}
+        issue_input: dict[str, Any] = {
+            "agent_id": agent_id,
+            **kwargs,
+            "mission_ids": _require_one_mission(mission_ids),
+        }
         if services is not None: issue_input["services"] = services
         if intents is not None: issue_input["intents"] = intents
         if ttl_seconds is not None: issue_input["ttl_seconds"] = ttl_seconds
@@ -483,10 +492,16 @@ class AsyncStack:
         ttl_seconds: int | None = None,
         accountability_mode: str | None = None,
         authority_binding_ids: list[str] | None = None,
+        mission_ids: list[str] | None = None,
         **kwargs: Any,
     ):
-        """Phase 5.2.6 — async passport issue + session wrapper."""
-        issue_input: dict[str, Any] = {"agent_id": agent_id, **kwargs}
+        """Phase 5.2.6 — async passport issue + session wrapper.
+        ``mission_ids`` must hold exactly one Mission id."""
+        issue_input: dict[str, Any] = {
+            "agent_id": agent_id,
+            **kwargs,
+            "mission_ids": _require_one_mission(mission_ids),
+        }
         if services is not None: issue_input["services"] = services
         if intents is not None: issue_input["intents"] = intents
         if ttl_seconds is not None: issue_input["ttl_seconds"] = ttl_seconds

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/_async/dropoffs.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any
 
 from ..client import AsyncHttpClient
+from ..dropoffs import _passport_header
 
 
 class AsyncDropoffService:
@@ -18,7 +19,9 @@ class AsyncDropoffService:
         schema: dict[str, Any],
         ttl_seconds: int | None = None,
         on_expire: str | None = None,
+        passport_token: str | None = None,
     ) -> dict[str, Any]:
+        """Create a drop-off. An agent caller passes the producer's Mission Passport as passport_token."""
         body: dict[str, Any] = {
             "from_agent": from_agent_id,
             "to_agent": to_agent_id,
@@ -28,7 +31,7 @@ class AsyncDropoffService:
             body["ttl_seconds"] = ttl_seconds
         if on_expire:
             body["on_expire"] = on_expire
-        return await self._client.post("/v1/dropoffs", json=body)
+        return await self._client.post("/v1/dropoffs", json=body, extra_headers=_passport_header(passport_token))
 
     async def deposit(
         self,
@@ -37,7 +40,9 @@ class AsyncDropoffService:
         agent_id: str,
         passport_jti: str | None = None,
         mission_id: str | None = None,
+        passport_token: str | None = None,
     ) -> dict[str, Any]:
+        """Deposit as the producer. An agent caller passes its Mission Passport as passport_token (or passport_jti)."""
         body: dict[str, Any] = {"agent_id": agent_id, "payload": data}
         if passport_jti is not None:
             body["passport_jti"] = passport_jti
@@ -46,12 +51,15 @@ class AsyncDropoffService:
         return await self._client.post(
             f"/v1/dropoffs/{dropoff_id}/deposit",
             json=body,
+            extra_headers=_passport_header(passport_token),
         )
 
-    async def collect(self, dropoff_id: str, agent_id: str) -> dict[str, Any]:
+    async def collect(self, dropoff_id: str, agent_id: str, passport_token: str | None = None) -> dict[str, Any]:
+        """Collect as the consumer. An agent caller passes its Mission Passport as passport_token."""
         return await self._client.post(
             f"/v1/dropoffs/{dropoff_id}/collect",
             json={"agent_id": agent_id},
+            extra_headers=_passport_header(passport_token),
         )
 
     async def expire(self, dropoff_id: str) -> dict[str, Any]:

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/_async/missions.py

@@ -1,4 +1,8 @@
-"""Async mirror of MissionsService. Same surface, async/await."""
+"""Async mirror of MissionsService. Same surface, async/await.
+
+Completing or revoking a Mission (any reason) revokes every passport
+bound to it.
+"""
 
 from __future__ import annotations
 
@@ -6,14 +10,26 @@ from typing import Any
 from urllib.parse import quote
 
 from ..client import AsyncHttpClient
+from ..missions import _start_body
 
 
 class AsyncMissionsService:
     def __init__(self, client: AsyncHttpClient):
         self._client = client
 
-    async def start(self, request: dict[str, Any]) -> dict[str, Any]:
-        return await self._client.request("POST", "/v1/missions/start", json=request)
+    async def start(
+        self,
+        request: dict[str, Any] | None = None,
+        *,
+        agent_id: str | None = None,
+        mission: dict[str, Any] | None = None,
+        passport: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Open a Mission and issue its passport in one call. Operator form:
+        ``await stack.missions.start(agent_id=..., mission={...}, passport={...})``.
+        Fleet form (unchanged): ``await stack.missions.start({"fleet_policy_id": ...})``."""
+        body = _start_body(request, agent_id, mission, passport)
+        return await self._client.request("POST", "/v1/missions/start", json=body)
 
     async def renew(self, mission_id: str) -> dict[str, Any]:
         return await self._client.request("POST", f"/v1/missions/{quote(mission_id, safe='')}/renew", json={})
@@ -41,8 +57,12 @@ class AsyncMissionsService:
         requested_operations: list[dict[str, Any]] | None = None,
         limits: dict[str, Any] | None = None,
         authority_binding_ids: list[str] | None = None,
+        agent_id: str | None = None,
     ) -> dict[str, Any]:
+        """Open a new mission. ``agent_id`` assigns it to that agent."""
         body: dict[str, Any] = {"intent_summary": intent_summary}
+        if agent_id is not None:
+            body["agent_id"] = agent_id
         if intent_services is not None:
             body["intent_services"] = intent_services
         if expected_counterparties is not None:

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/_async/partner_tenants.py

@@ -6,6 +6,7 @@ from typing import Any, Literal, Optional
 from urllib.parse import quote
 
 from ..client import AsyncHttpClient
+from ..passports import _require_one_mission
 
 
 
@@ -87,8 +88,12 @@ class AsyncPartnerTenantsService:
         services: Optional[list[dict[str, Any]]] = None,
         named_intents: Optional[list[str]] = None,
         accountability_mode: Optional[Literal["enforced", "logged", "standard"]] = None,
+        mission_ids: Optional[list[str]] = None,
     ) -> dict[str, Any]:
-        body: dict[str, Any] = {"agent_id": agent_id}
+        """Issue a passport under the tenant. ``mission_ids`` must hold exactly
+        one Mission id the tenant's agent may use; anything else raises
+        ``ValueError`` before any request."""
+        body: dict[str, Any] = {"agent_id": agent_id, "mission_ids": _require_one_mission(mission_ids)}
         if ttl_seconds is not None:
             body["ttl_seconds"] = ttl_seconds
         if services is not None:
@@ -110,6 +115,8 @@ class AsyncPartnerTenantsService:
         ttl_seconds: int = 900,
         accountability_mode: Literal["enforced", "logged", "standard"] = "enforced",
         named_intents: Optional[list[str]] = None,
+        *,
+        mission_id: str,
     ) -> dict[str, Any]:
         """Phase 5.7 — convenience helper for the MIME-stamping pattern.
 
@@ -123,6 +130,7 @@ class AsyncPartnerTenantsService:
             accountability_mode=accountability_mode,
             services=services,
             named_intents=named_intents,
+            mission_ids=[mission_id],
         )
         token = issued.get("token") or issued.get("passport")
         passport_id = issued.get("passport_id") or issued.get("jti")

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/_async/passport_session.py

@@ -6,6 +6,7 @@ import time
 from typing import Any
 
 from ..client import AsyncHttpClient
+from ..errors import StackError, mission_ended_error
 from ..passport_session import _decode_jwt_exp
 
 
@@ -25,13 +26,19 @@ class AsyncPassportSession:
         now_sec = int(time.time())
         if self._exp_seconds - now_sec > grace_seconds:
             return self._current_token
-        refreshed = await self._client.post(
-            "/v1/passports/refresh",
-            json={
-                "token": self._current_token,
-                "ttl_seconds": self._issue_input.get("ttl_seconds"),
-            },
-        )
+        try:
+            refreshed = await self._client.post(
+                "/v1/passports/refresh",
+                json={
+                    "token": self._current_token,
+                    "ttl_seconds": self._issue_input.get("ttl_seconds"),
+                },
+            )
+        except StackError as exc:
+            ended = mission_ended_error(exc)
+            if ended is not None:
+                raise ended from exc
+            raise
         self._current_token = refreshed["token"]
         self._exp_seconds = _decode_jwt_exp(self._current_token)
         return self._current_token

{getstack-2.0.0 → getstack-3.0.0}/src/getstack/_async/passports.py

@@ -13,8 +13,20 @@ import asyncio
 from contextlib import asynccontextmanager
 from typing import Any, AsyncGenerator, Awaitable, Callable
 
+from urllib.parse import quote
+
 from ..client import AsyncHttpClient
-from ..passports import _parse_duration, _to_passport, _delegation_scopes
+from ..errors import StackError, mission_ended_error
+from ..passports import (
+    _delegation_scopes,
+    _intent_body,
+    _parse_duration,
+    _require_one_mission,
+    _revoke_notes,
+    _signed_accountability,
+    _start_mission_body,
+    _to_passport,
+)
 from ..proxy import ProxyResponse
 from .proxy import AsyncProxyService
 from ..types import Passport, CheckpointResult, CheckoutResult, PassportReport, ToolCall
@@ -35,6 +47,8 @@ class AsyncMission:
         will_delegate: bool = False,
         estimated_duration: str | None = None,
         checkpoint_interval: str | None = None,
+        mission_id: str | None = None,
+        expires_in: str | None = None,
     ):
         self._service = service
         self._agent_id = agent_id
@@ -43,6 +57,10 @@ class AsyncMission:
         self._will_delegate = will_delegate
         self._estimated_duration = estimated_duration
         self._checkpoint_interval = checkpoint_interval
+        self._expires_in = expires_in
+
+        self.mission_id: str | None = mission_id
+        self._owns_mission: bool = False
 
         self.passport: Passport | None = None
         self.review_status: str | None = None
@@ -112,14 +130,30 @@ class AsyncMission:
         return resp
 
     async def _enter(self) -> None:
-        self.passport = await self._service.issue(
-            agent_id=self._agent_id,
-            intent=self._intent,
-            services=self._declared_services,
-            will_delegate=self._will_delegate,
-            estimated_duration=self._estimated_duration,
-            checkpoint_interval=self._checkpoint_interval,
-        )
+        if self.mission_id is None:
+            # One call opens the Mission and issues its passport; the API
+            # revokes the Mission if issuance fails.
+            started = await self._service._start_mission(_start_mission_body(
+                self._agent_id, self._intent, self._declared_services,
+                self._will_delegate, self._estimated_duration,
+                self._checkpoint_interval, self._expires_in,
+            ))
+            self.mission_id = started["mission_id"]
+            self._owns_mission = True
+            passport = _to_passport(started["passport"])
+            if passport.accountability is None:
+                passport.accountability = _signed_accountability(passport.token)
+            self.passport = passport
+        else:
+            self.passport = await self._service.issue(
+                agent_id=self._agent_id,
+                intent=self._intent,
+                services=self._declared_services,
+                will_delegate=self._will_delegate,
+                estimated_duration=self._estimated_duration,
+                checkpoint_interval=self._checkpoint_interval,
+                mission_ids=[self.mission_id],
+            )
         self._rotation_start = asyncio.get_event_loop().time()
 
         if self._checkpoint_interval:
@@ -162,7 +196,9 @@ class AsyncMission:
         )
         self._last_checkpoint_index = len(self._tool_calls)
 
-    async def _exit(self, error: Exception | None = None) -> None:
+    async def _exit(self, error: BaseException | None = None) -> None:
+        """Checkout first (closing the Mission revokes its passports), then
+        close the Mission this object opened."""
         if self._task and not self._task.done():
             self._task.cancel()
             try:
@@ -171,32 +207,33 @@ class AsyncMission:
                 pass
             self._task = None
 
-        if not self.passport:
-            return
-
-        summary = None
-        if error:
-            summary = f"Mission failed: {type(error).__name__}: {error}"
+        if self.passport:
+            summary = None
+            if error:
+                summary = f"Mission failed: {type(error).__name__}: {error}"
 
-        try:
-            self.result = await self._service.checkout(
-                self.passport.jti,
-                services_used=list(self._services_used),
-                actions_count=len(self._tool_calls),
-                tool_calls=[tc.to_dict() for tc in self._tool_calls] if self._tool_calls else None,
-                summary=summary,
-                delegated_to=self._delegated_to if self._delegated_to else None,
-            )
-            self.review_status = self.result.review_status
-        except Exception:
-            pass  # Best-effort checkout
+            try:
+                self.result = await self._service.checkout(
+                    self.passport.jti,
+                    services_used=list(self._services_used),
+                    actions_count=len(self._tool_calls),
+                    tool_calls=[tc.to_dict() for tc in self._tool_calls] if self._tool_calls else None,
+                    summary=summary,
+                    delegated_to=self._delegated_to if self._delegated_to else None,
+                )
+                self.review_status = self.result.review_status
+            except Exception:
+                pass  # Best-effort checkout
+
+        if self._owns_mission and self.mission_id:
+            await self._service._finish_mission(self.mission_id, error)
 
     async def __aenter__(self) -> AsyncMission:
         await self._enter()
         return self
 
     async def __aexit__(
-        self, exc_type: type | None, exc_val: Exception | None, exc_tb: Any
+        self, exc_type: type | None, exc_val: BaseException | None, exc_tb: Any
     ) -> bool:
         await self._exit(error=exc_val if exc_type else None)
         return False
@@ -221,6 +258,17 @@ class AsyncPassportService:
     ) -> Passport:
         """Issue a signed passport for an agent (async mirror of ``Stack``).
 
+        ``mission_ids`` must hold exactly one live Mission id (``ms_*``);
+        anything else raises ``ValueError`` before any request::
+
+            mission = await stack.missions.open("Send the weekly report", agent_id="agt_x")
+            passport = await stack.passports.issue(
+                agent_id="agt_x",
+                mission_ids=[mission["mission_id"]],
+                intent="Send the weekly report",
+                services=["resend"],
+            )
+
         ``scopes`` is a list of per-connection override dicts. Each recognises:
 
         - ``service_connection_id`` (str) — the connection to scope.
@@ -235,6 +283,7 @@ class AsyncPassportService:
 
               await stack.passports.issue(
                   agent_id="agt_x",
+                  mission_ids=[mission_id],
                   scopes=[{
                       "service_connection_id": "scon_resend",
                       "scopes": ["email:send"],
@@ -242,26 +291,44 @@ class AsyncPassportService:
                   }],
               )
         """
-        body: dict[str, Any] = {"agent_id": agent_id}
+        body: dict[str, Any] = {"agent_id": agent_id, "mission_ids": _require_one_mission(mission_ids)}
         if scopes:
             body["scopes"] = scopes
         if authority_binding_ids is not None:
             body["authority_binding_ids"] = authority_binding_ids
-        if mission_ids is not None:
-            body["mission_ids"] = mission_ids
         if ttl_seconds:
             body["ttl_seconds"] = ttl_seconds
-        if intent or services:
-            body["intent"] = {
-                "summary": intent or "",
-                "services": services or [],
-                "will_delegate": will_delegate,
-            }
-            if estimated_duration:
-                body["intent"]["estimated_duration_seconds"] = _parse_duration(estimated_duration)
+        intent_body = _intent_body(intent, services, will_delegate, estimated_duration)
+        if intent_body is not None:
+            body["intent"] = intent_body
         if checkpoint_interval:
             body["checkpoint_interval_seconds"] = _parse_duration(checkpoint_interval)
-        return _to_passport(await self._client.post("/v1/passports/issue", json=body))
+        try:
+            data = await self._client.post("/v1/passports/issue", json=body)
+        except StackError as exc:
+            ended = mission_ended_error(exc)
+            if ended is not None:
+                raise ended from exc
+            raise
+        return _to_passport(data)
+
+    async def _start_mission(self, body: dict[str, Any]) -> dict[str, Any]:
+        return await self._client.post("/v1/missions/start", json=body)
+
+    async def _finish_mission(self, mission_id: str, error: BaseException | None) -> None:
+        """Complete the Mission, or revoke it when the block raised. Mirror of
+        the sync PassportService._finish_mission."""
+        path_id = quote(mission_id, safe="")
+        if error is None:
+            await self._client.post(f"/v1/missions/{path_id}/complete", json={})
+            return
+        try:
+            await self._client.post(
+                f"/v1/missions/{path_id}/revoke",
+                json={"reason": "operator_initiated_clean", "notes": _revoke_notes(error)},
+            )
+        except Exception:
+            pass
 
     async def checkpoint(
         self,
@@ -362,10 +429,18 @@ class AsyncPassportService:
         return await self._client.get("/v1/passports/active", params=params or None)
 
     async def refresh(self, token: str, ttl_seconds: int | None = None) -> Passport:
+        """Refresh within the Mission; raises MissionEndedError once it ends."""
         body: dict[str, Any] = {"token": token}
         if ttl_seconds:
             body["ttl_seconds"] = ttl_seconds
-        return _to_passport(await self._client.post("/v1/passports/refresh", json=body))
+        try:
+            data = await self._client.post("/v1/passports/refresh", json=body)
+        except StackError as exc:
+            ended = mission_ended_error(exc)
+            if ended is not None:
+                raise ended from exc
+            raise
+        return _to_passport(data)
 
     async def list_active(
         self, agent_id: str | None = None, session_id: str | None = None
@@ -386,18 +461,26 @@ class AsyncPassportService:
         will_delegate: bool = False,
         estimated_duration: str | None = None,
         checkpoint_interval: str | None = None,
+        mission_id: str | None = None,
+        expires_in: str | None = None,
     ) -> AsyncGenerator[AsyncMission, None]:
-        """Async-context-manager mission. Mirror of sync mission()."""
+        """Async-context-manager mission. Mirror of sync mission(): opens the
+        Mission and its passport in one call (POST /v1/missions/start),
+        checks out, then completes the Mission on exit (revokes it if the
+        block raised). ``mission_id`` binds an existing Mission, which is
+        then left open on exit."""
         m = AsyncMission(
             self, agent_id, intent, services,
             will_delegate=will_delegate,
             estimated_duration=estimated_duration,
             checkpoint_interval=checkpoint_interval,
+            mission_id=mission_id,
+            expires_in=expires_in,
         )
         await m._enter()
         try:
             yield m
-        except Exception as e:
+        except BaseException as e:
             await m._exit(error=e)
             raise
         else:
@@ -411,21 +494,48 @@ class AsyncPassportService:
         rotation_interval: str = "4h",
         will_delegate: bool = False,
         checkpoint_interval: str | None = None,
+        mission_id: str | None = None,
+        expires_in: str | None = None,
     ) -> AsyncGenerator[AsyncMission, None]:
-        """Async generator yielding successive AsyncMission objects."""
+        """Async generator yielding successive AsyncMission objects. Mirror of
+        sync continuous_mission(): every rotation shares one Mission, and
+        closing the generator (``aclose()``) completes the Mission it opened."""
         rotation_secs = float(_parse_duration(rotation_interval))
         rotation_count = 0
-        while True:
-            m = AsyncMission(
-                self, agent_id, intent, services,
-                will_delegate=will_delegate,
-                checkpoint_interval=checkpoint_interval,
-            )
-            m.rotation_count = rotation_count
-            m._rotation_interval = rotation_secs
-            await m._enter()
-            try:
-                yield m
-            finally:
-                await m._exit()
-            rotation_count += 1
+        bound_mission_id = mission_id
+        owned_mission_id: str | None = None
+        error: BaseException | None = None
+        try:
+            while True:
+                m = AsyncMission(
+                    self, agent_id, intent, services,
+                    will_delegate=will_delegate,
+                    checkpoint_interval=checkpoint_interval,
+                    mission_id=bound_mission_id,
+                    expires_in=expires_in,
+                )
+                m.rotation_count = rotation_count
+                m._rotation_interval = rotation_secs
+                await m._enter()
+                if m._owns_mission:
+                    owned_mission_id = bound_mission_id = m.mission_id
+                    m._owns_mission = False
+                try:
+                    yield m
+                except GeneratorExit:
+                    await m._exit()
+                    raise
+                except BaseException as e:
+                    await m._exit(error=e)
+                    raise
+                else:
+                    await m._exit()
+                rotation_count += 1
+        except GeneratorExit:
+            raise
+        except BaseException as e:
+            error = e
+            raise
+        finally:
+            if owned_mission_id is not None:
+                await self._finish_mission(owned_mission_id, error)