bazaar-compute-node 0.1.39rc4__tar.gz → 0.2.0rc2__tar.gz

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazaar-compute-node
-Version: 0.1.39rc4
+Version: 0.2.0rc2
 Summary: Runtime-agnostic computer node daemon for agents and channels.
 License-Expression: AGPL-3.0-only
 License-File: LICENSE
@@ -51,11 +51,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/README.md

@@ -32,11 +32,14 @@ bcn --version
 uv tool upgrade bazaar-compute-node
 
 # Add an Agent / 添加 Agent
+# allowed_sender_ids holds the Telegram user ids allowed to open a private chat
+# allowed_sender_ids 是允许与其私聊的 Telegram 用户 id
 bcn agent add \
   --name Tifa \
   --channel telegram \
   --runtime codex \
-  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN
+  --set channel.token_env=BCN_TELEGRAM_TIFA_TOKEN \
+  --set channel.allowed_sender_ids=[123456789]
 
 # Configure the runtime environment / 配置运行时环境
 # Example file content / 示例文件内容:

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.39rc4"
+version = "0.2.0rc2"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bazaar-compute-node"
-version = "0.1.39rc4"
+version = "0.2.0rc2"
 description = "Runtime-agnostic computer node daemon for agents and channels."
 readme = "README.md"
 license = "AGPL-3.0-only"

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/app/agent.py

@@ -12,8 +12,10 @@ from dataclasses import dataclass
 from functools import partial
 from pathlib import Path
 
+from ..core.actor import Actor, Actors, Agent, Thread
+from ..core.audit import AuditRecorder
 from ..core.channel import Channel, ChannelContext, IChannel
-from ..core.concurrency import ISessionConcurrency, SessionLockRegistry
+from ..core.concurrency import IThreadConcurrency, ThreadLockRegistry
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
     InboundAttachment,
@@ -21,12 +23,13 @@ from ..core.models import (
     RuntimeSession,
 )
 from ..core.observability import IAudit
-from ..core.orchestration import SessionOrchestrator
+from ..core.orchestration import AgentOrchestrator
 from ..core.orchestration.reminder_command import ReminderCommandService
 from ..core.paths import resolve_workspace_dir
 from ..core.runtime import IRuntime, RuntimeCommandContext
 from ..core.storage import IStorageScope
 from ..core.timerwheel import TimerWheel
+from ..core.utils.clock import now_ms
 from ..i18n import Translator
 from .attachments import AttachmentMaterializer
 from .command import CommandDispatchError
@@ -57,7 +60,7 @@ _PLATFORM_ENVIRONMENT = {
 @dataclass(frozen=True, slots=True)
 class _SessionCapabilityBinding:
     agent_id: str
-    bcn_session_id: str
+    actor_id: str
     runtime_session_id: str
     capability: str
     token_values: tuple[str, ...]
@@ -74,7 +77,7 @@ class AgentApplication:
         storage: IStorageScope,
         audit: IAudit,
         timer_wheel: TimerWheel,
-        reminder_concurrency: ISessionConcurrency,
+        reminder_concurrency: IThreadConcurrency,
         reminder_poke: Callable[[], None],
         endpoint: Callable[[], str],
         timeout_budget: TimeoutBudget,
@@ -94,7 +97,7 @@ class AgentApplication:
         self._wrapper_path: Path | None = None
         self.command_log: list[CommandRecord] = []
         self._session_capabilities: dict[str, _SessionCapabilityBinding] = {}
-        self._concurrency = SessionLockRegistry()
+        self._concurrency = ThreadLockRegistry()
         self._started = False
         self._stopping = False
         self._runtime_configurations = configuration.runtimes
@@ -103,6 +106,11 @@ class AgentApplication:
             self.workspace_path,
             self._referenced_attachment_paths,
         )
+        self._audit_recorder = AuditRecorder(
+            sink=audit,
+            timeout_budget=timeout_budget,
+            clock=now_ms,
+        )
         provider_channel = factories.channel.build(
             ChannelContext(
                 agent_id=self.agent_id,
@@ -111,6 +119,7 @@ class AgentApplication:
                 workspace=self.workspace_path,
                 translator=self.translator,
                 timer_wheel=self.timer_wheel,
+                audit=self._audit_recorder,
             )
         )
         self.channel: IChannel = Channel(self.agent_id, provider_channel)
@@ -135,6 +144,7 @@ class AgentApplication:
                 agent_name=self.name,
                 bot_name=self._bot_name,
                 runtime_options=runtime_options,
+                mode=configuration.mode,
                 sandbox_mode=runtime_configuration.sandbox_mode,
                 network_access=runtime_configuration.network_access,
                 startup_timeout_seconds=timeout_budget.startup_seconds,
@@ -155,12 +165,13 @@ class AgentApplication:
             raise ValueError("agent idle timeout exceeds the timer horizon")
         self._runtime_contexts = tuple(runtime_contexts)
         self.runtimes: tuple[IRuntime, ...] = tuple(runtimes)
-        self.orchestrator = SessionOrchestrator(
-            agent_id=self.agent_id,
+        self._actors = Actors(agent_id=self.agent_id, mode=configuration.mode)
+        self.orchestrator = AgentOrchestrator(
+            actors=self._actors,
             channel=self.channel,
             runtimes=self.runtimes,
             storage=self.storage,
-            audit=self.audit,
+            audit=self._audit_recorder,
             timeout_budget=self.timeout_budget,
             timer_wheel=self.timer_wheel,
             runtime_idle_timeout_ms=(
@@ -181,9 +192,10 @@ class AgentApplication:
         )
         self.command_dispatcher = CommandDispatcher(
             self.orchestrator.command_service,
+            actors=self._actors,
             reminder_service=self.reminder_service,
             timeout_budget=self.timeout_budget,
-            session_binding_validator=self._validate_session_binding,
+            session_binding_validator=self._validate_actor_binding,
             upgrade_service=upgrade_service,
         )
 
@@ -213,6 +225,7 @@ class AgentApplication:
                 install_bcc_wrapper,
                 workspace / ".bcn" / "bin",
                 agent_id=self.agent_id,
+                mode=self._actors.mode,
             )
             await self._attachment_materializer.reconcile()
             await self.orchestrator.start(
@@ -268,10 +281,10 @@ class AgentApplication:
     ) -> Mapping[str, object]:
         return await self.command_dispatcher(request)
 
-    async def has_session(self, session_id: str) -> bool:
-        if not isinstance(session_id, str) or not session_id:
+    async def has_session(self, thread_id: str) -> bool:
+        if not isinstance(thread_id, str) or not thread_id:
             return False
-        return await self.storage.get_bcn_session(session_id) is not None
+        return await self.storage.get_thread(thread_id) is not None
 
     async def publish_inbox_wake(self, message: Message[InboundAttachment]) -> None:
         if not self._started:
@@ -312,9 +325,9 @@ class AgentApplication:
     async def _referenced_attachment_paths(self) -> set[str]:
         return set(await self.storage.list_ready_attachment_paths())
 
-    async def _validate_session_binding(
+    async def _validate_actor_binding(
         self,
-        session_id: str,
+        actor: Actor,
         request: Mapping[str, object],
     ) -> None:
         request_agent_id = request.get("agent_id")
@@ -325,22 +338,26 @@ class AgentApplication:
             )
         runtime_session_id = request.get("runtime_session_id")
         session_capability = request.get("session_capability")
-        if await self.storage.get_bcn_session(session_id) is None:
-            raise CommandDispatchError(
-                "SESSION_NOT_FOUND",
-                f"unknown bcn session: {session_id}",
-            )
-        runtime_session = self.orchestrator.runtime_session(session_id)
+        match actor:
+            case Thread(thread_id):
+                if await self.storage.get_thread(thread_id) is None:
+                    raise CommandDispatchError(
+                        "SESSION_NOT_FOUND",
+                        f"unknown thread: {thread_id}",
+                    )
+            case Agent():
+                pass
+        runtime_session = self.orchestrator.runtime_session(actor)
         if runtime_session is None or runtime_session_id != runtime_session.id:
             raise CommandDispatchError(
                 "SESSION_BINDING_FAILED",
                 "runtime session binding is invalid",
             )
-        binding = self._session_capabilities.get(session_id)
+        binding = self._session_capabilities.get(actor.id)
         if (
             binding is None
             or binding.agent_id != self.agent_id
-            or binding.bcn_session_id != session_id
+            or binding.actor_id != actor.id
             or binding.runtime_session_id != runtime_session.id
             or not isinstance(session_capability, str)
             or not hmac.compare_digest(
@@ -357,31 +374,29 @@ class AgentApplication:
         runtime_index: int,
         session: RuntimeSession,
     ) -> Mapping[str, str]:
-        runtime_session = self.orchestrator.runtime_session(session.bcn_session_id)
+        runtime_session = self.orchestrator.runtime_session(session.actor)
         if runtime_session is None or runtime_session.id != session.id:
             raise RuntimeError("runtime session is not the current live binding")
         return self._build_command_environment(
-            session.bcn_session_id,
+            session.actor.id,
             session.id,
             runtime_index=runtime_index,
         )
 
     def _build_command_environment(
         self,
-        session_id: str,
+        actor_id: str,
         runtime_session_id: str,
         *,
         runtime_index: int,
     ) -> dict[str, str]:
-        if not session_id:
-            raise ValueError("session_id must be a non-empty string")
         if not runtime_session_id:
             raise ValueError("runtime_session_id must be a non-empty string")
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
         environment_bindings = self._runtime_configurations[runtime_index].env
-        binding = self._session_capabilities.get(session_id)
+        binding = self._session_capabilities.get(actor_id)
         if binding is None or binding.runtime_session_id != runtime_session_id:
             capability = secrets.token_urlsafe(32)
             token_values = [capability]
@@ -393,12 +408,12 @@ class AgentApplication:
                     token_values.append(value)
             binding = _SessionCapabilityBinding(
                 agent_id=self.agent_id,
-                bcn_session_id=session_id,
+                actor_id=actor_id,
                 runtime_session_id=runtime_session_id,
                 capability=capability,
                 token_values=tuple(token_values),
             )
-            self._session_capabilities[session_id] = binding
+            self._session_capabilities[actor_id] = binding
         allowed = set(_PLATFORM_ENVIRONMENT)
         for name in self.runtimes[runtime_index].environment_variable_names():
             if not _ENVIRONMENT_NAME.fullmatch(name):
@@ -433,15 +448,15 @@ class AgentApplication:
             {
                 "BCN_AGENT_ID": self.agent_id,
                 "BCN_ENDPOINT": self._endpoint(),
-                "BCN_SESSION_ID": session_id,
+                "BCN_ACTOR_ID": actor_id,
                 "BCN_RUNTIME_SESSION_ID": runtime_session_id,
                 "BCN_COMMAND_CAPABILITY": binding.capability,
             }
         )
         return environment
 
-    def _redact_session_secrets(self, session_id: str, text: str) -> str:
-        binding = self._session_capabilities.get(session_id)
+    def _redact_session_secrets(self, thread_id: str, text: str) -> str:
+        binding = self._session_capabilities.get(self._actors.for_thread(thread_id).id)
         if binding is None:
             return text
         for token in binding.token_values:
@@ -450,12 +465,12 @@ class AgentApplication:
 
     async def _run_runtime_command(
         self,
-        session_id: str,
+        thread_id: str,
         arguments: Sequence[str],
         body: str | None,
     ) -> None:
-        if not session_id:
-            raise ValueError("session_id must be a non-empty string")
+        if not thread_id:
+            raise ValueError("thread_id must be a non-empty string")
         if not arguments or any(
             not isinstance(argument, str) for argument in arguments
         ):
@@ -463,12 +478,14 @@ class AgentApplication:
         wrapper_path = self._wrapper_path
         if wrapper_path is None:
             raise RuntimeError("bcc wrapper is not installed")
-        self.command_log.append((session_id, tuple(arguments)))
-        runtime_session = self.orchestrator.runtime_session(session_id)
+        self.command_log.append((thread_id, tuple(arguments)))
+        runtime_session = self.orchestrator.runtime_session(
+            self._actors.for_thread(thread_id)
+        )
         if runtime_session is None:
             raise RuntimeError("runtime session is not live")
         environment = self._build_command_environment(
-            session_id,
+            runtime_session.actor.id,
             runtime_session.id,
             runtime_index=runtime_session.runtime_index,
         )

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/app/application.py

@@ -10,7 +10,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from .. import __version__
-from ..core.concurrency import SessionLockRegistry
+from ..core.concurrency import ThreadLockRegistry
 from ..core.lifecycle import ITaskFailureSource, TimeoutBudget
 from ..core.models import InboundAttachment, Message
 from ..core.observability import IAudit
@@ -82,7 +82,7 @@ class NodeApplication:
         self.storage: IStorage = shared_factories.storage()
         self.audit: IAudit = shared_factories.audit()
         self.timer_wheel = TimerWheel()
-        self._reminder_concurrency = SessionLockRegistry()
+        self._reminder_concurrency = ThreadLockRegistry()
         self.reminder_scheduler = ReminderScheduler(
             storage=self.storage,
             timer_wheel=self.timer_wheel,
@@ -369,7 +369,7 @@ class NodeApplication:
             self._log(
                 "reminder.wake.agent_unavailable",
                 agent_id=agent_id,
-                owner_session_id=message.session_id,
+                owner_thread_id=message.thread_id,
             )
             return False
         try:
@@ -380,7 +380,7 @@ class NodeApplication:
             self._log(
                 "reminder.wake.failed",
                 agent_id=agent_id,
-                owner_session_id=message.session_id,
+                owner_thread_id=message.thread_id,
                 error_type=type(error).__name__,
                 error=format_exception(error),
             )

{bazaar_compute_node-0.1.39rc4 → bazaar_compute_node-0.2.0rc2}/src/bazaar_compute_node/app/command.py

@@ -17,12 +17,12 @@ from pydantic import (
     ValidationError,
 )
 
+from ..core.actor import Actor, Actors
 from ..core.command import (
     ICommandService,
-    InboxListResult,
     MessageSendFreshnessHold,
-    SessionNotFoundError,
     TargetProjection,
+    ThreadNotFoundError,
 )
 from ..core.lifecycle import TimeoutBudget
 from ..core.models import (
@@ -83,7 +83,7 @@ def serialize_message(
         "seq": message.seq,
         "message_id": message.message_id,
         "direction": message.direction.value,
-        "session_id": message.session_id,
+        "thread_id": message.thread_id,
         "channel_session_id": message.channel_session_id,
         "channel": message.channel,
         "received_at_ms": message.received_at_ms,
@@ -144,9 +144,8 @@ def serialize_inbox_target(summary: InboxTargetSummary) -> dict[str, object]:
     )
     return {
         "target": summary.target,
-        "session_id": summary.session_id,
+        "thread_id": summary.thread_id,
         "target_kind": summary.target_kind.value,
-        "current": summary.current,
         "pending_count": summary.pending_count,
         "last_activity_at_ms": summary.last_activity_at_ms,
         "latest_message_id": summary.latest_message_id,
@@ -163,16 +162,6 @@ def serialize_inbox_target(summary: InboxTargetSummary) -> dict[str, object]:
     }
 
 
-def serialize_inbox_list(result: InboxListResult) -> dict[str, object]:
-    return {
-        "targets": [serialize_inbox_target(target) for target in result.targets],
-        "total": result.total,
-        "shown": result.shown,
-        "offset": result.offset,
-        "has_more": result.has_more,
-    }
-
-
 class CommandDispatchError(ValueError):
     def __init__(
         self,
@@ -200,7 +189,7 @@ class _CommandRequest(BaseModel):
     kind: Literal["command"]
     resource: StrictStr
     command: StrictStr
-    session_id: NonEmptyText
+    actor_id: NonEmptyText
 
 
 class _MessageCheckRequest(_CommandRequest):
@@ -230,11 +219,9 @@ class _MessageSendRequest(_CommandRequest):
     )
 
 
-class _InboxListRequest(_CommandRequest):
+class _InboxCheckRequest(_CommandRequest):
     resource: Literal["inbox"]
-    command: Literal["list"]
-    limit: PositiveInt = 100
-    offset: NonNegativeInt = 0
+    command: Literal["check"]
 
 
 class _ThreadUnfollowRequest(_CommandRequest):
@@ -249,7 +236,7 @@ _REQUEST_MODELS: dict[tuple[str, str], _RequestModel] = {
     ("message", "check"): _MessageCheckRequest,
     ("message", "read"): _MessageReadRequest,
     ("message", "send"): _MessageSendRequest,
-    ("inbox", "list"): _InboxListRequest,
+    ("inbox", "check"): _InboxCheckRequest,
     ("thread", "unfollow"): _ThreadUnfollowRequest,
 }
 
@@ -275,7 +262,7 @@ _SEND_FAILURES: dict[OutboundDeliveryState, tuple[str, str, str]] = {
 }
 
 _REQUEST_ERRORS: dict[str, tuple[str, str]] = {
-    "session_id": ("SESSION_REQUIRED", "session_id must be a non-empty string"),
+    "actor_id": ("SESSION_REQUIRED", "actor_id must be a non-empty string"),
     "limit": ("INVALID_LIMIT", "limit must be a positive integer"),
     "offset": ("INVALID_OFFSET", "offset must be a non-negative integer"),
     "target": ("TARGET_REQUIRED", "target must be a non-empty string"),
@@ -330,7 +317,7 @@ def _parse_command_request[RequestT: _CommandRequest](
         raise CommandDispatchError(code, message) from error
 
 
-SessionBindingValidator = Callable[[str, Mapping[str, object]], Awaitable[None]]
+SessionBindingValidator = Callable[[Actor, Mapping[str, object]], Awaitable[None]]
 
 
 class CommandDispatcher:
@@ -340,9 +327,11 @@ class CommandDispatcher:
         self,
         service: ICommandService,
         *,
+        actors: Actors,
         timeout_budget: TimeoutBudget,
         session_binding_validator: SessionBindingValidator | None = None,
     ) -> None:
+        self._actors = actors
         self._service = service
         self._timeout_budget = timeout_budget
         self._session_binding_validator = session_binding_validator
@@ -351,6 +340,12 @@ class CommandDispatcher:
         self._drained = asyncio.Event()
         self._drained.set()
 
+    def _resolve_actor(self, actor_id: str) -> Actor:
+        try:
+            return self._actors.resolve(actor_id)
+        except ValueError as error:
+            raise CommandDispatchError("SESSION_NOT_FOUND", str(error)) from error
+
     @property
     def accepting(self) -> bool:
         return self._accepting
@@ -422,7 +417,7 @@ class CommandDispatcher:
             if error.next_action is not None:
                 response["next_action"] = error.next_action
             return response
-        except SessionNotFoundError as error:
+        except ThreadNotFoundError as error:
             return {
                 "ok": False,
                 "code": "SESSION_NOT_FOUND",
@@ -476,51 +471,76 @@ class CommandDispatcher:
             )
 
         request = _parse_command_request(raw_request, _REQUEST_MODELS[route])
-        session_id = request.session_id
+        actor = self._resolve_actor(request.actor_id)
         if self._session_binding_validator is not None:
-            await self._session_binding_validator(session_id, raw_request)
+            await self._session_binding_validator(actor, raw_request)
 
         match route:
             case ("message", "check"):
-                return await self._check_messages(session_id)
+                return await self._check_messages(actor)
             case ("message", "read"):
                 return await self._read_messages(
-                    session_id, cast(_MessageReadRequest, request)
+                    actor, cast(_MessageReadRequest, request)
                 )
             case ("message", "send"):
                 return await self._send_message(
-                    session_id, cast(_MessageSendRequest, request)
-                )
-            case ("inbox", "list"):
-                return await self._list_inbox(
-                    session_id, cast(_InboxListRequest, request)
+                    actor, cast(_MessageSendRequest, request)
                 )
+            case ("inbox", "check"):
+                return await self._check_inbox(actor)
             case ("thread", "unfollow"):
                 return await self._unfollow_thread(
-                    session_id, cast(_ThreadUnfollowRequest, request)
+                    actor, cast(_ThreadUnfollowRequest, request)
                 )
             case _:
                 raise AssertionError("validated command route has no handler")
 
-    async def _check_messages(self, session_id: str) -> Mapping[str, object]:
-        result = await self._service.check(session_id)
+    async def _check_messages(self, actor: Actor) -> Mapping[str, object]:
+        drained = await self._service.check(actor)
+        projections = tuple(
+            projection for result in drained for projection in result.target_projections
+        )
         return {
             "ok": True,
             "result": {
-                "messages": _serialized(result.messages, result.target_projections),
+                "messages": _serialized(
+                    sorted(
+                        (message for result in drained for message in result.messages),
+                        key=lambda message: (
+                            message.received_at_ms
+                            if message.received_at_ms is not None
+                            else message.created_at_ms or 0,
+                            message.thread_id,
+                            message.seq,
+                        ),
+                    ),
+                    projections,
+                ),
                 "referenced_messages": _serialized(
-                    result.referenced_messages, result.target_projections
+                    tuple(
+                        message
+                        for result in drained
+                        for message in result.referenced_messages
+                    ),
+                    projections,
                 ),
-                "snapshot_seq": result.snapshot_seq,
-                "delivered_through_seq": result.delivered_through_seq,
+            },
+        }
+
+    async def _check_inbox(self, actor: Actor) -> Mapping[str, object]:
+        result = await self._service.pending_targets(actor)
+        return {
+            "ok": True,
+            "result": {
+                "targets": [serialize_inbox_target(target) for target in result.targets]
             },
         }
 
     async def _read_messages(
-        self, session_id: str, request: _MessageReadRequest
+        self, actor: Actor, request: _MessageReadRequest
     ) -> Mapping[str, object]:
         result = await self._service.read(
-            session_id,
+            actor,
             raw_target=request.target,
             around_message_id=request.around_message_id,
             limit=request.limit,
@@ -539,10 +559,10 @@ class CommandDispatcher:
         }
 
     async def _send_message(
-        self, session_id: str, request: _MessageSendRequest
+        self, actor: Actor, request: _MessageSendRequest
     ) -> Mapping[str, object]:
         result = await self._service.send(
-            session_id=session_id,
+            actor=actor,
             command_id=request.command_id,
             raw_target=request.target,
             body=request.body,
@@ -581,20 +601,10 @@ class CommandDispatcher:
         )
         return {"ok": True, "result": {"text": text}}
 
-    async def _list_inbox(
-        self, session_id: str, request: _InboxListRequest
-    ) -> Mapping[str, object]:
-        result = await self._service.list_inbox(
-            session_id,
-            limit=request.limit,
-            offset=request.offset,
-        )
-        return {"ok": True, "result": serialize_inbox_list(result)}
-
     async def _unfollow_thread(
-        self, session_id: str, request: _ThreadUnfollowRequest
+        self, actor: Actor, request: _ThreadUnfollowRequest
     ) -> Mapping[str, object]:
-        result = await self._service.unfollow(session_id, raw_target=request.target)
+        result = await self._service.unfollow(actor, raw_target=request.target)
         return {
             "ok": True,
             "result": {"target": result.target, "changed": result.changed},