@agent-marshal/marshal-prime-agent 0.48.4

package/README.md

@@ -0,0 +1,73 @@
+# Marshal for Prime Agent
+
+`@agent-marshal/marshal-prime-agent` is the native Prime Agent bridge for
+[marshal](https://github.com/ignition-is-go/marshal). It is separate from the
+`marshal-pi` package and targets Prime Agent's conversation lifecycle and canonical
+session identities.
+
+The extension runs inside each Prime Agent conversation. It:
+
+- registers the conversation on the Marshal roster using Prime Agent's session ID;
+- exposes native `marshal_*` tools to the model;
+- subscribes to Marshal's live notification stream; and
+- injects incoming direct messages with
+  `pi.sendMessage(..., { deliverAs: "steer", triggerTurn: true })`.
+
+A direct message therefore appears in the transcript immediately and starts a turn
+when the recipient is idle. While the agent is working, it steers the active run at
+the next tool boundary. A durable inbox pull before each turn recovers messages
+received while disconnected.
+
+## Install
+
+Start a reachable daemon, then install the Prime Agent package:
+
+```bash
+cargo install marshal-daemon
+marshal-daemon &
+prime-agent package install npm:@agent-marshal/marshal-prime-agent
+```
+
+Restart Prime Agent after installation. No MCP server or wrapper is required.
+For a remote daemon:
+
+```bash
+export MARSHAL_DAEMON_ADDRESS=ws://marshal.example.net:6155
+prime-agent
+```
+
+The default is `ws://localhost:6155`. `MARSHAL_OPERATOR` optionally overrides the
+operator name shown on the roster.
+
+For development:
+
+```bash
+cargo run -p marshal-entities --no-default-features --features codegen \
+  --bin typegen -- plugins/marshal-prime-agent/src/generated
+prime-agent --extension ./plugins/marshal-prime-agent/src/index.ts
+```
+
+## Verify
+
+Run `/marshal-status` inside Prime Agent or use `marshal_whoami`. Send a direct
+message from another Marshal session to its nickname or session ID. It appears as:
+
+```text
+new message from <nickname>: <body>
+```
+
+Peer content is untrusted input. The extension adds that warning to the system
+prompt and directs replies through `marshal_send_message`. Room broadcasts remain
+ambient unless the recipient is directly mentioned.
+
+## Tools
+
+- `marshal_whoami`
+- `marshal_roster`
+- `marshal_messages`
+- `marshal_send_message`
+- `marshal_broadcast`
+- `marshal_join_room`
+- `marshal_leave_room`
+- `marshal_set_status`
+- `marshal_ack`

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@agent-marshal/marshal-prime-agent",
+  "version": "0.48.4",
+  "description": "Prime Agent extension that connects live conversations to the marshal coordination daemon with native tools and real-time steering delivery of sibling-agent messages.",
+  "type": "module",
+  "license": "MIT OR Apache-2.0",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "main": "./src/index.ts",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "prime-agent-package",
+    "prime-agent",
+    "marshal",
+    "agent-coordination"
+  ],
+  "dependencies": {
+    "@myko/core": "^4.24.4"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "flux": {
+    "bridges": [
+      "cargo:marshal-entities"
+    ],
+    "tasks": [
+      "gen",
+      "publish"
+    ]
+  },
+  "scripts": {
+    "gen": "cargo run -p marshal-entities --no-default-features --features codegen --bin typegen -- src/generated"
+  }
+}

package/src/daemon.ts

@@ -0,0 +1,358 @@
+// MarshalDaemon — the pi-side equivalent of the Rust marshal-shim's daemon
+// wiring, built on the @myko/core TypeScript client (official myko protocol).
+//
+// Responsibilities (1:1 with the shim's main.rs, minus the Claude-specific
+// session-id archaeology and the MCP stdio transport):
+//   - hold one autoreconnecting WS to the marshal daemon,
+//   - SET a `Session` roster row per live pi session and keep its liveness
+//     fresh (5s cadence, like the shim's roster-publish loop),
+//   - re-SET every tracked session on reconnect (the daemon's roster is
+//     in-memory and lost on restart),
+//   - run the write commands (send/broadcast/join/leave/status/ack) and the
+//     per-turn inbox pull, all carrying `asSession` for caller identity,
+//   - surface inbound `NotifyChannel` pushes to a callback (→ turn injection).
+
+import { randomUUID } from "node:crypto";
+import { ConnectionStatus, MykoClient } from "@myko/core";
+import type { MEvent } from "@myko/core";
+
+import {
+  ackMessages,
+  broadcastMessage,
+  getAllSessions,
+  getAllSessionNicknames,
+  joinRoom,
+  leaveRoom,
+  NOTIFY_CHANNEL_COMMAND_ID,
+  readMessages,
+  sendMessage,
+  setLastActivityAt,
+  setSessionStatus,
+  type BroadcastMessageResult,
+  type JoinRoomResult,
+  type LeaveRoomResult,
+  type MarshalCommand,
+  type MarshalQuery,
+  type MessageView,
+  type NotifyChannelMeta,
+  type ReadMessagesResult,
+  type SendMessageResult,
+  type SessionItem,
+  type SessionNicknameItem,
+} from "./entities.ts";
+import type { Identity } from "./identity.ts";
+
+const LIVENESS_INTERVAL_MS = 5_000;
+const INBOX_PULL_LIMIT = 20;
+const SOURCE_ID = "marshal-prime-agent";
+
+/** myko's CellServer serves its WebSocket at the `/myko` path. */
+export function withMykoPath(addr: string): string {
+  try {
+    const u = new URL(addr);
+    if (u.pathname === "" || u.pathname === "/") u.pathname = "/myko";
+    return u.toString().replace(/\/$/, "");
+  } catch {
+    return /\/myko\/?$/.test(addr) ? addr : `${addr.replace(/\/+$/, "")}/myko`;
+  }
+}
+
+export interface DaemonConfig {
+  address: string;
+  cwd: string;
+  identity: Identity;
+  log?: (msg: string) => void;
+}
+
+type NotifyHandler = (meta: NotifyChannelMeta) => void;
+
+export class MarshalDaemon {
+  private readonly client = new MykoClient();
+  private readonly cfg: DaemonConfig;
+  private readonly log: (msg: string) => void;
+
+  private readonly sessions = new Map<string, SessionItem>();
+  private readonly communicated = new Map<string, Set<string>>();
+  private lastSessionId: string | undefined;
+
+  private roster: SessionItem[] = [];
+  private nicknames: SessionNicknameItem[] = [];
+
+  private readonly draining = new Map<string, Promise<string | null>>();
+  private notifyHandler: NotifyHandler | null = null;
+  private livenessTimer: ReturnType<typeof setInterval> | null = null;
+  private started = false;
+  private connected = false;
+  private rosterChangedHandler: (() => void) | null = null;
+  private connectionChangedHandler: ((connected: boolean) => void) | null = null;
+
+  constructor(cfg: DaemonConfig) {
+    this.cfg = cfg;
+    this.log = cfg.log ?? (() => {});
+  }
+
+  // ── Public API ─────────────────────────────────────────────────────────
+
+  start(): void {
+    if (this.started) return;
+    this.started = true;
+
+    this.client.connectionStatus$.subscribe((status) => {
+      if (status === ConnectionStatus.Connected) {
+        this.connected = true;
+        for (const item of this.sessions.values()) this.emitSet(item);
+        this.connectionChangedHandler?.(true);
+      } else if (status === ConnectionStatus.Disconnected) {
+        this.connected = false;
+        this.connectionChangedHandler?.(false);
+      }
+    });
+
+    this.client.commandIncoming$.subscribe((msg) => {
+      const data = (msg as { data?: { commandId?: string; command?: unknown } }).data;
+      if (!data || data.commandId !== NOTIFY_CHANNEL_COMMAND_ID) return;
+      const command = (data.command ?? {}) as { meta?: NotifyChannelMeta };
+      this.notifyHandler?.(command.meta ?? {});
+    });
+
+    this.watch(getAllSessions()).subscribe((items) => {
+      this.roster = items;
+      this.rosterChangedHandler?.();
+    });
+
+    this.watch(getAllSessionNicknames()).subscribe((items) => {
+      this.nicknames = items;
+    });
+
+    this.client.setAddress(withMykoPath(this.cfg.address));
+  }
+
+  stop(): void {
+    for (const item of this.sessions.values()) this.emitDel(item);
+    this.sessions.clear();
+    if (this.livenessTimer) { clearInterval(this.livenessTimer); this.livenessTimer = null; }
+    this.client.disconnect();
+    this.started = false;
+  }
+
+  onNotify(handler: NotifyHandler): void { this.notifyHandler = handler; }
+  onRosterChanged(handler: () => void): void { this.rosterChangedHandler = handler; }
+  onConnectionChanged(handler: (connected: boolean) => void): void { this.connectionChangedHandler = handler; }
+  isConnected(): boolean { return this.connected; }
+
+  // ── Session management ─────────────────────────────────────────────────
+
+  registerSession(sessionId: string): void {
+    this.lastSessionId = sessionId;
+    const existing = this.sessions.get(sessionId);
+    const now = Date.now() as unknown as bigint;
+    const item: SessionItem = existing ?? {
+      id: sessionId,
+      pid: process.pid,
+      cwd: this.cfg.cwd,
+      connectedAt: now,
+      operator: this.cfg.identity.operator ?? null,
+      host: this.cfg.identity.host ?? null,
+      gitBranch: this.cfg.identity.gitBranch ?? null,
+      project: this.cfg.identity.project ?? null,
+      // Prime Agent can render custom messages and trigger/steer turns through
+      // its extension API, so advertise live-channel capability explicitly.
+      channelsEnabled: true,
+      kind: "prime-agent",
+    } as SessionItem;
+    (item as any).lastActivityAt = now;
+    this.sessions.set(sessionId, item);
+    if (this.connected) this.emitSet(item);
+    this.ensureLivenessTimer();
+  }
+
+  deregisterSession(sessionId: string): void {
+    const item = this.sessions.get(sessionId);
+    if (!item) return;
+    this.sessions.delete(sessionId);
+    this.emitDel(item);
+    if (this.sessions.size === 0 && this.livenessTimer) {
+      clearInterval(this.livenessTimer);
+      this.livenessTimer = null;
+    }
+  }
+
+  // ── Write tools ────────────────────────────────────────────────────────
+
+  sendMessage(asSession: string, to: string, body: string): Promise<SendMessageResult> {
+    this.recordCommunication(asSession, to);
+    return this.send(sendMessage(asSession, to, body));
+  }
+
+  recordCommunication(sessionId: string, peerSessionId: string | undefined): void {
+    if (!peerSessionId || peerSessionId === sessionId) return;
+    const peers = this.communicated.get(sessionId) ?? new Set<string>();
+    peers.add(peerSessionId);
+    this.communicated.set(sessionId, peers);
+  }
+
+  broadcast(asSession: string, room: string, body: string): Promise<BroadcastMessageResult> {
+    return this.send(broadcastMessage(asSession, room, body));
+  }
+
+  joinRoom(asSession: string, name: string, description?: string): Promise<JoinRoomResult> {
+    return this.send(joinRoom(asSession, name, description));
+  }
+
+  leaveRoom(asSession: string, room: string): Promise<LeaveRoomResult> {
+    return this.send(leaveRoom(asSession, room));
+  }
+
+  async setStatus(sessionId: string, text: string): Promise<void> {
+    const item = this.sessions.get(sessionId);
+    if (item) (item as any).currentTask = text;
+    await this.send(setSessionStatus(sessionId, text));
+  }
+
+  // ── Reads ──────────────────────────────────────────────────────────────
+
+  async roster_snapshot(): Promise<SessionItem[]> {
+    if (this.roster.length > 0) return this.roster;
+    return new Promise<SessionItem[]>((resolve) => {
+      let done = false;
+      const sub = this.watch(getAllSessions()).subscribe((items) => {
+        if (done) return;
+        done = true;
+        resolve(items);
+        queueMicrotask(() => sub.unsubscribe());
+      });
+    });
+  }
+
+  rosterSync(): SessionItem[] { return this.roster; }
+
+  async readHistory(asSession: string, opts: { room?: string; since?: number; limit?: number }): Promise<MessageView[]> {
+    const result = await this.send(readMessages({
+      asSession,
+      room: opts.room,
+      inbox: opts.room ? false : true,
+      sent: false,
+      unread: false,
+      since: opts.since,
+      limit: opts.limit ?? 50,
+    }));
+    const messages = result.messages ?? [];
+    for (const m of messages) this.recordCommunication(asSession, m.fromSessionId);
+    return messages;
+  }
+
+  async ackMessages(asSession: string, messageIds: string[]): Promise<number> {
+    await this.send(ackMessages(asSession, messageIds));
+    return messageIds.length;
+  }
+
+  formatMessageLine(m: MessageView): string {
+    return `- [${m.messageId}] ${this.senderLabel(m.fromSessionId)}: ${m.body}`;
+  }
+
+  drainInbox(sessionId: string): Promise<string | null> {
+    const prev = this.draining.get(sessionId) ?? Promise.resolve<string | null>(null);
+    const next = prev.catch(() => null).then(() => this.drainInboxInner(sessionId));
+    this.draining.set(sessionId, next);
+    void next.finally(() => { if (this.draining.get(sessionId) === next) this.draining.delete(sessionId); });
+    return next;
+  }
+
+  nicknameFor(sessionId: string): string {
+    return this.nicknames.find((n) => (n as any).id === sessionId)?.nickname ?? sessionId;
+  }
+
+  currentNickname(): string | undefined {
+    const sid = this.lastSessionId ?? (this.sessions.keys().next().value as string | undefined);
+    if (!sid) return undefined;
+    return this.nicknameFor(sid);
+  }
+
+  // ── Internals ──────────────────────────────────────────────────────────
+
+  private async drainInboxInner(sessionId: string): Promise<string | null> {
+    let result: ReadMessagesResult | undefined;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        result = await this.send(readMessages({
+          asSession: sessionId,
+          toSession: sessionId,
+          inbox: false,
+          sent: false,
+          unread: true,
+          limit: INBOX_PULL_LIMIT,
+        }));
+      } catch {
+        return null;
+      }
+      if (result.messages && result.messages.length > 0) break;
+      if (attempt < 2) await new Promise((r) => setTimeout(r, 100 * (attempt + 1)));
+    }
+    if (!result?.messages?.length) return null;
+
+    const block = this.renderInbox(result.messages);
+    try {
+      await this.send(ackMessages(sessionId, result.messages.map((m) => m.messageId)));
+    } catch { this.log("inbox ack failed"); }
+    return block;
+  }
+
+  private renderInbox(messages: MessageView[]): string {
+    if (messages.length === 1) {
+      const m = messages[0];
+      return `new message from ${this.senderLabel(m.fromSessionId)}: ${m.body}`;
+    }
+    const lines = [`${messages.length} new messages from sibling agents:`];
+    for (const m of messages) lines.push(`- ${this.senderLabel(m.fromSessionId)}: ${m.body}`);
+    return lines.join("\n");
+  }
+
+  private senderLabel(sessionId: string): string {
+    const nick = this.nicknameFor(sessionId);
+    const s = this.roster.find((r) => (r as any).id === sessionId);
+    if (!s) return nick;
+    const ctx = [s.operator, s.host?.name].filter(Boolean).join("@");
+    return ctx ? `${nick} (${ctx})` : nick;
+  }
+
+  private ensureLivenessTimer(): void {
+    if (this.livenessTimer) return;
+    this.livenessTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, item] of this.sessions) {
+        (item as any).lastActivityAt = now;
+        void this.send(setLastActivityAt(id, now)).catch(() => {});
+      }
+    }, LIVENESS_INTERVAL_MS);
+    if (typeof (this.livenessTimer as any).unref === "function") {
+      (this.livenessTimer as any).unref();
+    }
+  }
+
+  private emitSet(item: SessionItem): void {
+    this.client.sendEvent(this.event(item, "SET"));
+  }
+
+  private emitDel(item: SessionItem): void {
+    this.client.sendEvent(this.event(item, "DEL"));
+  }
+
+  private event(item: SessionItem, changeType: "SET" | "DEL"): MEvent {
+    return {
+      item: item as unknown as Record<string, unknown>,
+      changeType,
+      itemType: "Session",
+      createdAt: new Date().toISOString(),
+      tx: randomUUID(),
+      sourceId: SOURCE_ID,
+    } as unknown as MEvent;
+  }
+
+  private send<R>(command: MarshalCommand<R>): Promise<R> {
+    return this.client.sendCommand(command as never) as Promise<R>;
+  }
+
+  private watch<I>(query: MarshalQuery<I>) {
+    return this.client.watchQuery(query as never) as unknown as import("rxjs").Observable<I[]>;
+  }
+}

package/src/entities.ts

@@ -0,0 +1,197 @@
+// Marshal wire shapes for the pi extension.
+//
+// ALL marshal types come from the generated bindings in `./generated/`, which
+// are produced from the canonical Rust `marshal-entities` definitions by
+// `scripts/generate-pi-types.sh`. Regenerate them whenever the Rust entities
+// change so the wire contract can't drift.
+//
+// What stays here:
+//   - `MarshalCommand` / `MarshalQuery` — generic myko envelopes (not marshal-specific).
+//   - builder functions — thin wrappers that return `{ commandId, command }`.
+//   - `NotifyChannelMeta` — documents the runtime shape of the freeform JSON
+//     `meta` field the daemon pushes (the Rust `serde_json::Value` has no type).
+//   - `NOTIFY_CHANNEL_COMMAND_ID` — the push command id constant.
+
+import type {
+  AckMessagesResult,
+  BroadcastMessageResult,
+  JoinRoomResult,
+  LeaveRoomResult,
+  MessageView,
+  ReadMessagesArgs,
+  ReadMessagesResult,
+  Room,
+  RoomMember,
+  SendMessageResult,
+  Session,
+  SessionNickname,
+} from "./generated/index.ts";
+
+// ── Re-exported generated types ──────────────────────────────────────────
+
+export type {
+  AckMessagesResult,
+  BroadcastMessageResult,
+  HostInfo,
+  JoinRoomResult,
+  LeaveRoomResult,
+  MessageView,
+  ReadMessagesResult,
+  Room,
+  RoomMember,
+  SendMessageResult,
+  Session,
+  SessionNickname,
+  SessionId,
+  RoomId,
+  MessageId,
+} from "./generated/index.ts";
+
+/** The roster-row payload this extension SETs. The generated `Session` type
+ *  brands timestamps as `bigint` (ts-rs maps Rust `i64` that way); at runtime
+ *  marshal serializes them as cbor numbers, so the daemon casts `Date.now()`
+ *  values at construction. */
+export type SessionItem = Session;
+
+/** The daemon-assigned handle, read from the `SessionNickname` store. */
+export type SessionNicknameItem = SessionNickname;
+
+/** A room entry from `GetAllRooms`. */
+export type RoomItem = Room;
+
+/** A room membership from `GetAllRoomMembers`. */
+export type RoomMemberItem = RoomMember;
+
+// ── Server→client push meta ──────────────────────────────────────────────
+
+/** The `NotifyChannel.meta` the daemon dispatches to the connected client
+ *  when a peer sends a message. The Rust source defines it as `serde_json::Value`
+ *  (freeform), so this is a convenience type, not a generated marshal one. */
+export interface NotifyChannelMeta {
+  source?: string;
+  kind?: string;
+  message_id?: string;
+  from_session?: string;
+  from_nickname?: string;
+  to_session?: string;
+  to_operator?: string | null;
+  body?: string;
+  body_truncated?: boolean;
+  sent_at?: number;
+}
+
+export const NOTIFY_CHANNEL_COMMAND_ID = "NotifyChannel";
+
+// ── Envelope types ───────────────────────────────────────────────────────
+
+/** A myko command envelope as `MykoClient.sendCommand` expects it. */
+export interface MarshalCommand<_Result = unknown> {
+  readonly commandId: string;
+  readonly command: Record<string, unknown>;
+}
+
+/** A myko query envelope as `MykoClient.watchQuery` expects it. */
+export interface MarshalQuery<_Item = unknown> {
+  readonly queryId: string;
+  readonly queryItemType: string;
+  readonly query: Record<string, unknown>;
+}
+
+// ── Write command builders ───────────────────────────────────────────────
+
+export function sendMessage(
+  asSession: string,
+  toSessionId: string,
+  body: string,
+): MarshalCommand<SendMessageResult> {
+  return { commandId: "SendMessage", command: { toSessionId, body, asSession } };
+}
+
+export function broadcastMessage(
+  asSession: string,
+  toRoomId: string,
+  body: string,
+): MarshalCommand<BroadcastMessageResult> {
+  return { commandId: "BroadcastMessage", command: { toRoomId, body, asSession } };
+}
+
+export function joinRoom(
+  asSession: string,
+  name: string,
+  description?: string,
+): MarshalCommand<JoinRoomResult> {
+  return { commandId: "JoinRoom", command: stripUndefined({ name, description, asSession }) };
+}
+
+export function leaveRoom(
+  asSession: string,
+  room: string,
+): MarshalCommand<LeaveRoomResult> {
+  return { commandId: "LeaveRoom", command: { room, asSession } };
+}
+
+export function ackMessages(
+  asSession: string,
+  messageIds: string[],
+): MarshalCommand<AckMessagesResult> {
+  return { commandId: "AckMessages", command: { messageIds, asSession } };
+}
+
+/** `set_status` maps to the generated setter for `Session.current_task`
+ *  (`Set{Item}{Field}` — myko/macros/src/item.rs). Payload is `{ id, currentTask }`. */
+export function setSessionStatus(
+  sessionId: string,
+  currentTask: string | null,
+): MarshalCommand<void> {
+  return { commandId: "SetSessionCurrentTask", command: { id: sessionId, currentTask } };
+}
+
+/** Liveness bump — the generated setter for `Session.last_activity_at`. Mirrors
+ *  the Rust shim's 5s roster-publish loop so the daemon sweeper doesn't reap us. */
+export function setLastActivityAt(
+  sessionId: string,
+  lastActivityAt: number,
+): MarshalCommand<void> {
+  return { commandId: "SetSessionLastActivityAt", command: { id: sessionId, lastActivityAt } };
+}
+
+export function readMessages(args: ReadMessagesArgs): MarshalCommand<ReadMessagesResult> {
+  const command = stripUndefined({
+    asSession: args.asSession,
+    inbox: args.inbox ?? false,
+    sent: args.sent ?? false,
+    unread: args.unread ?? false,
+    room: args.room,
+    from: args.from,
+    toSession: args.toSession,
+    since: args.since,
+    limit: args.limit,
+  });
+  return { commandId: "ReadMessages", command };
+}
+
+// ── Read query builders ──────────────────────────────────────────────────
+
+export function getAllSessions(): MarshalQuery<Session> {
+  return { queryId: "GetAllSessions", queryItemType: "Session", query: {} };
+}
+
+export function getAllRooms(): MarshalQuery<Room> {
+  return { queryId: "GetAllRooms", queryItemType: "Room", query: {} };
+}
+
+export function getAllRoomMembers(): MarshalQuery<RoomMember> {
+  return { queryId: "GetAllRoomMembers", queryItemType: "RoomMember", query: {} };
+}
+
+export function getAllSessionNicknames(): MarshalQuery<SessionNickname> {
+  return { queryId: "GetAllSessionNicknames", queryItemType: "SessionNickname", query: {} };
+}
+
+function stripUndefined(o: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return out;
+}

package/src/generated/AckMessages.ts

@@ -0,0 +1,16 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { MessageId } from "./MessageId";
+import type { SessionId } from "./SessionId";
+
+export type AckMessages = { 
+/**
+ * Messages to mark read. Order doesn't matter; missing/unknown
+ * ids are silently skipped (idempotent — re-acking is fine).
+ */
+messageIds: Array<MessageId>, 
+/**
+ * Self-identified caller for connectionless paths (HTTP-MCP agents,
+ * the daemon's `/hook/*` handlers acking on a session's behalf).
+ * WS shim callers omit it. See `resolve_caller`.
+ */
+asSession?: SessionId | null, };