@llblab/pi-actors 0.42.2 → 0.43.0

package/docs/actor-messages.md

@@ -1,225 +0,0 @@
-# Actor Messages
-
-Protocol target for organic communication across pi-actors.
-
-## Contract
-
-Compress communication to three durable verbs:
-
-- `spawn`: create an addressable actor from a recipe, template, or tool.
-- `message`: send one typed message to one address.
-- `inspect`: intentionally observe state, logs, actor messages, or artifacts.
-
-Everything else is an adapter until proven otherwise.
-
-## Nouns
-
-- **Actor**: any addressable execution or coordination endpoint.
-- **Address**: stable route string for an actor or sub-actor.
-- **Message**: typed envelope flowing between addresses.
-- **Artifact**: durable result path declared by recipe or produced by actor.
-- **Inspection**: explicit diagnostic/read operation, not a coordination loop.
-
-## Addresses
-
-Initial address forms:
-
-```text
-run:<id>
-branch:<run>/<branch>
-coordinator
-session:<id>
-tool:<name>
-```
-
-Cross-branch communication adds one organic endpoint kind:
-
-```text
-room:<run>
-```
-
-A room is the task's single shared discussion channel: an addressable mailbox with an append-only message log and a compact member roster stored under the owning run state. It is not a broker or coordinator: it accepts normal actor-message envelopes, records shared timeline entries, tracks join/leave presence, and lets actors discover peers for direct messages. `room:<run>` is the public address; named subrooms are intentionally not exposed in 0.17.
-
-An alternate implementation shape is a dedicated non-LLM communication actor: a small script-backed service recipe, possibly singleton-scoped, that owns room timelines, rosters, subscriptions, and fanout. This is attractive when communication needs outgrow simple file-backed room state, but it should remain an implementation adapter behind the same `room:<run>` address and message envelope. The public model should not fork into a separate chat API.
-
-That actor-backed shape can also reduce direct file storage. Instead of every protocol feature owning JSON files as primary state, a helper actor can keep live room/roster structures in memory or another local structure and write files only as snapshots, audit logs, artifacts, or recovery checkpoints. The decision boundary is practical: keep files when durability and inspectability are the main value; prefer actor-owned structures when live coordination, subscriptions, fanout, unread state, or mutation consistency becomes the main value.
-
-Current backend decision: keep the file-backed adapter for now. The covered workload is append-heavy room coordination plus direct branch inbox queueing/claiming, where durable local files are still the useful source of truth for recovery and `inspect`. Live notification is a separate advisory wake layer: actors may subscribe to `wake.jsonl` changes through a cross-platform file notifier and still reconcile canonical mailbox files if a wake is missed. A communication helper should be introduced only when a real workflow needs long-lived subscriptions, live fanout policy, or shared mutable room state beyond the current lock/debounce/compaction safeguards.
-
-Package-specific endpoints may still exist, but the envelope stays the same.
-
-## Message Envelope
-
-One shape covers upward, downward, lateral, parent-to-branch, and branch-to-parent traffic:
-
-```json
-{
-  "to": "run:review",
-  "from": "coordinator",
-  "type": "control.approve",
-  "summary": "Approve checkpoint",
-  "body": "approve",
-  "reply_to": "msg_123",
-  "correlation_id": "task_456",
-  "metadata": {}
-}
-```
-
-Field rules:
-
-- `to`: required address.
-- `from`: optional address; runtime fills when known.
-- `type`: required semantic message type. Prefer compact dotted names such as `control.stop`, `task.claim`, or `player.next`, where the prefix is the interaction channel/domain and the suffix is the action. Many script-backed actors should be able to dispatch from `type` alone without requiring a structured body.
-- `summary`: short human-facing line for notifications/follow-ups.
-- `body`: optional string or JSON payload. Use it when extra context is needed: scripts may ignore it for action-only messages, while LLM-backed agents can accept free-form natural-language prompts without a rigid schema.
-- Routing/delivery is inferred from `to`, actor ownership, and coordinator runtime policy; recipes should not expose delivery knobs. When a coordinator session is known, addressed run/branch/control messages fail closed before controlling or emitting from runs owned by another session.
-- `reply_to`: optional message id for conversational checkpoints.
-- `correlation_id`: optional task/run/workflow id.
-- `metadata`: optional structured routing or domain hints.
-
-## Symmetry
-
-The same `message` primitive must represent:
-
-```text
-coordinator -> run
-run -> coordinator
-run -> run
-parent -> branch
-branch -> parent
-branch -> room
-room -> branch notification
-coordinator -> tool
-```
-
-Transports differ, but the public contract does not:
-
-- `to: run:<id>` routes through the run-local control channel selected by that recipe or runtime adapter.
-- `to: coordinator` routes to the runtime attention path when `from` names a run actor. `to: session:<id>` uses the same actor-message path only when the sender run is owned by that session, making explicit session-directed checkpoints possible without exposing runtime delivery knobs. Generic async-runner `command.done` messages and explicit coordinator/session-bound messages include the actor envelope fields alongside runtime metadata.
-- `to: branch:<run>/<branch>` currently routes through the parent run mailbox with the full envelope preserved so the run or recipe-specific worker protocol can dispatch branch-local control. It also persists a queued branch-local copy under `branches/<branch>/inbox.jsonl`, inspectable with `inspect branch:<run>/<branch> view=mailbox`; compact inspection includes the inbox message `id`, status, route, type, and timestamps so worker protocols can correlate claims/retries. Branch-local inbox append and status rewrites are guarded by a small lock so direct delivery and coordinator claims do not overwrite each other during bursts. Status transitions preserve active queued/claimed records and compact older handled/failed terminal records with bounded retention, so persistent runners do not accumulate unbounded completed inbox history. Coordinator claim handling also assigns an ID to older/manual queued records that do not have one so they can still transition to `handled` or `failed` instead of repeating forever. It is not a broadcast room and it does not make an arbitrary prompt process consume the message automatically. Target direction: direct branch messages should become initiating inbox work for long-lived branch runners, delivered into the recipient's next prompt/context as soon as the runner can accept work.
-- `to: room:<run>` appends the full envelope to the room timeline, updates room state for room-control types such as `actor.join` and `actor.leave`, and can route selected-recipient multicast when `metadata.recipients` contains same-run `branch:<run>/<branch>` addresses.
-- `to: tool:<name>` invokes an executable pi tool by name. Object bodies become tool parameters; primitive bodies are passed as `{ "input": body }`.
-
-Transport is not public API unless a recipe explicitly documents a custom endpoint.
-
-## Rooms and Rosters
-
-The task room is the discovery and shared-context layer for actors whose spawn-tree positions do not give them each other's addresses. The spawn tree remains the lifecycle/provenance structure; the task room describes the group communication graph. Direct messages and room messages can share the same semantic `type` such as `chat.message`; the route (`to: branch:*` versus `to: room:*`) determines whether delivery is private or group-wide.
-
-Use direct branch messages only when the receiving branch is backed by a worker or recipe that reads the parent run mailbox or branch inbox and dispatches branch-targeted envelopes. Room roster contacts are discovery hints, not a guarantee that an independent prompt process is subscribed to its branch address. The current branch inbox records queued mailbox work; runner-side claiming/handling turns direct messages into prompt work for the recipient branch, while room messages remain shared transcript entries. A direct message may ask the recipient to inspect room history when broader shared context is needed. For ad hoc or transcript-driven swarms without such a runner, prefer room-visible replies and mentions so every participant can inspect the shared timeline.
-
-Direct branch delivery is prompt steering for worker-backed branches, not a coordinator follow-up. Packaged coordinator flows claim queued branch inbox records immediately before launching the branch's next prompt, append a bounded "direct messages for you" section to that prompt, and then mark the claimed records `handled` or `failed` based on the prompt result. Generic one-shot `pi -p` children do not receive this injection automatically; a recipe must own the runner loop or use the packaged coordinator path for direct messages to become next-prompt work.
-
-Selected-recipient multicast stays route-based: send one `to: room:<run>` envelope with `metadata.recipients` set to same-run branch addresses. The room timeline keeps the original room-visible envelope, and the runtime also forwards branch-targeted copies to each listed recipient. This is not a subroom; it is a shared transcript plus explicit direct delivery for actors whose worker protocol consumes branch envelopes.
-
-A minimal join message:
-
-```json
-{
-  "to": "room:review",
-  "from": "branch:review/security",
-  "type": "actor.join",
-  "summary": "Security reviewer joined",
-  "body": {
-    "role": "reviewer",
-    "caps": ["security-review", "risk-analysis"],
-    "claim": "Review auth boundary risks"
-  }
-}
-```
-
-A leave message removes that actor from the roster while preserving the timeline entry:
-
-```json
-{
-  "to": "room:review",
-  "from": "branch:review/security",
-  "type": "actor.leave"
-}
-```
-
-Room messages require `from` so roster presence and provenance stay explicit. The sender must belong to the room's run (`run:<run>` or `branch:<run>/<branch>`), which prevents accidental cross-run roster pollution. Other room posts also refresh sender presence, defaulting the role hint to `actor` when no richer role is known.
-
-Roster entries should keep identity axes separate:
-
-- `address`: Stable route for direct messages.
-- `parent`: Spawn-tree parent for provenance and ownership checks.
-- `role`: Current task function; dynamic and prompt-dependent.
-- `caps`: Capabilities the actor can offer.
-- `claim`: Current work claim or focus.
-- `status` / `last_seen`: Presence and staleness hints.
-
-Compact roster inspection includes these hints when present so agents can discover direct-message targets without verbose JSON.
-
-Actors should receive a compact visible communication snapshot rather than a full global tree: self, parent/root, joined rooms, relevant sibling/member addresses, and role/capability hints. Current run actors get `communication.json` in their state dir, and async templates receive `{communication_file}`, `{actor_address}`, and `{default_room}` values. The snapshot includes `self`, `root`, optional `parent`, the default room, current default-room members, direct-message `contacts` derived from the room roster, and `updated_at`. Branch-local snapshots are refreshed when a branch joins or posts in the default room, so actors can discover peers without reading full timelines. Full timelines and rosters remain intentional inspection surfaces. For TUI and compact operator display, `view=previews` returns bounded message preview records with `timestamp`, `from`, `to`, `type`, optional `summary`, and optional `body_preview`.
-
-## Mailbox Declaration
-
-Recipes can declare their conversational surface:
-
-```json
-{
-  "mailbox": {
-    "accepts": [
-      "control.continue",
-      "control.revise",
-      "control.approve",
-      "control.kill"
-    ],
-    "emits": ["checkpoint.needs_scope", "branch.done", "run.done"]
-  }
-}
-```
-
-`mailbox.accepts` is a contract for coordinator-to-actor messages. `mailbox.emits` is a contract for actor-to-coordinator or actor-to-actor messages. Packaged interactive and message-producing recipes declare mailbox metadata so coordinators can discover semantic message types without reading transport details. Message-producing recipes produce actor-message-envelope-shaped records with `to`, `from`, `type`, `summary`, `body`, optional `correlation_id`/`reply_to`, and optional `metadata` fields. Coordinator follow-ups preserve bounded body previews and metadata so checkpoints do not lose their actionable payload. Deterministic pipelines should prefer `utility-actor-message` for this wrapping so message shape is validated and guaranteed instead of delegated to a prompt; its recipe args intentionally mirror the envelope field names.
-
-## Spawn
-
-`spawn` creates an actor and returns its address:
-
-```json
-{
-  "recipe": "subagents-prompts.json",
-  "as": "run:review",
-  "values": {},
-  "artifacts": { "report": "{state_dir}/report.md" }
-}
-```
-
-`spawn` creates detached `run:<id>` actors from a recipe file/name or inline command template. Public spawn state directories are runtime-owned so every actor remains addressable and retention cannot target a caller-selected directory; spawn metadata may include named `artifacts` for terminal follow-ups and inspection. Room rosters are durable but burst-safe: repeated messages that only update `last_seen` may be coalesced briefly, while semantic roster changes such as role/status/display still write immediately.
-
-## Inspect
-
-`inspect` reads state intentionally:
-
-```json
-{
-  "target": "run:review",
-  "view": "status"
-}
-```
-
-The implementation supports `status`, `tail`, `messages`, `artifacts`, `files`, `mailbox`, and `communication` for `run:<id>` actors, `status`, `messages`, `previews`, `roster`, and `contacts` for `room:<run>` actors, `status`/`runs` for `coordinator`, `session:<id>`, and `session:all` actors with optional status filtering, and `status`/`schema` for registered `tool:<name>` actors. Run mailbox inspection shows recipe-declared mailbox metadata plus recent durable run inbox entries; branch mailbox inspection shows branch-local queued/claimed/handled records. Room `status` returns compact message/roster counts plus `last_message_at`, `last_message_from`, `last_message_type`, and `last_message_summary` when available, without parsing the full timeline into actor envelopes. Use `messages` for actor-envelope inspection. `inspect target=coordinator` requires a current coordinator session; use `session:<id>` or `session:all` when the session is intentionally explicit. Direct `run:<id>` and `room:<run>` inspection respects coordinator-session ownership when the current session is known. Ownership denials use `reason=session_mismatch owner_session=<id> current_session=<id> hint=inspect_session:<id>`; recover by inspecting the hinted `session:<id>` instead of forcing cross-session control. `inspect` is for decision points and diagnosis only; examples must not teach sleep-then-inspect polling.
-
-## Runtime Direction
-
-Runtime operations use the actor/message vocabulary:
-
-```text
-create detached work -> spawn
-run-local control    -> message to run:<id>
-run force-kill       -> message type control.kill
-platform control     -> internal adapter selected from run state
-coordinator signal   -> message to coordinator/session
-tool execution       -> message to tool:<name>
-intentional observe  -> inspect
-```
-
-## Non-goals
-
-- No generic expression language in templates.
-- No public transport-path vocabulary in recipe args.
-- No polling-first examples.
-- No separate upward and downward message schemas.
-- No heavyweight chat/broker subsystem when an addressable room mailbox is enough.
-- No broad facade that hides artifacts, logs, or ownership checks.

package/fixtures/protocol/actor-message-branch.json

@@ -1,13 +0,0 @@
-{
-  "to": "branch:demo/reviewer",
-  "from": "run:demo",
-  "type": "task.assign",
-  "summary": "Review the current slice",
-  "body": {
-    "task": "Check mailbox loop semantics"
-  },
-  "correlation_id": "task-001",
-  "metadata": {
-    "requires_response": true
-  }
-}

package/fixtures/protocol/mailbox-contract.json

@@ -1,15 +0,0 @@
-{
-  "accepts": [
-    "task.assign",
-    {
-      "type": "control.stop",
-      "description": "Request graceful worker shutdown"
-    }
-  ],
-  "emits": [
-    "task.claim",
-    "task.result",
-    "awaiting_assignment",
-    "actor.leave"
-  ]
-}

package/fixtures/protocol/room-message.json

@@ -1,11 +0,0 @@
-{
-  "to": "room:demo",
-  "from": "branch:demo/worker",
-  "type": "task.result",
-  "summary": "Worker completed task",
-  "body": {
-    "id": "inbox-001",
-    "result": "ok"
-  },
-  "received_at": "2026-05-26T00:00:00.000Z"
-}

package/fixtures/protocol/room-roster.json

@@ -1,11 +0,0 @@
-{
-  "room": "main",
-  "members": {
-    "branch:demo/worker": {
-      "display": "worker",
-      "role": "worker",
-      "status": "present",
-      "last_seen": "2026-05-26T00:00:00.000Z"
-    }
-  }
-}

package/fixtures/protocol/run-inbox-message.json

@@ -1,9 +0,0 @@
-{
-  "id": "inbox-001",
-  "status": "queued",
-  "queued_at": "2026-05-26T00:00:00.000Z",
-  "to": "run:demo",
-  "from": "coordinator",
-  "type": "control.continue",
-  "body": "continue"
-}

package/fixtures/protocol/run-outbox-event.json

@@ -1,9 +0,0 @@
-{
-  "id": "event-001",
-  "type": "task.result",
-  "summary": "Worker completed task",
-  "body": {
-    "result": "ok"
-  },
-  "created_at": "2026-05-26T00:00:00.000Z"
-}

package/lib/mailbox-loop.ts

@@ -1,144 +0,0 @@
-/**
- * Mailbox worker loop primitives.
- * Zones: mailbox-consuming actors, run/branch inbox claiming, handler status transitions
- * Owns reusable claim/handle/drain behavior across run and branch inboxes; scheduling and task policy stay outside.
- */
-
-import {
-  claimBranchInboxMessage,
-  updateBranchInboxMessageStatus,
-  type BranchInboxRecord,
-} from "./rooms.ts";
-import {
-  claimRunInboxMessage,
-  updateRunInboxMessageStatus,
-  type RunInboxMessage,
-} from "./async-runs.ts";
-
-export type MailboxLoopMessage = RunInboxMessage | BranchInboxRecord;
-
-export type MailboxLoopTarget =
-  | {
-      kind: "run";
-      runOrDir: string;
-    }
-  | {
-      address: string;
-      kind: "branch";
-      run: string;
-      stateDir: string;
-    };
-
-export interface MailboxLoopClaimOptions {
-  owner?: string;
-  statuses?: string[];
-}
-
-export interface MailboxLoopHandleResult {
-  handled: boolean;
-  id?: string;
-  message?: MailboxLoopMessage;
-  target: MailboxLoopTarget;
-}
-
-export interface MailboxLoopDrainOptions extends MailboxLoopClaimOptions {
-  maxMessages?: number;
-  stopOnControl?: boolean;
-}
-
-export interface MailboxLoopDrainResult {
-  handled: number;
-  stopped: boolean;
-  target: MailboxLoopTarget;
-}
-
-export function isMailboxLoopStopMessage(message: unknown): boolean {
-  const type =
-    message && typeof message === "object" && "type" in message
-      ? (message as { type?: unknown }).type
-      : undefined;
-  return type === "control.kill";
-}
-
-function messageId(
-  message: MailboxLoopMessage | undefined,
-): string | undefined {
-  return typeof message?.id === "string" ? message.id : undefined;
-}
-
-export function claimMailboxLoopMessage(
-  target: MailboxLoopTarget,
-  options: MailboxLoopClaimOptions = {},
-): MailboxLoopMessage | undefined {
-  const owner = options.owner ?? "mailbox-loop";
-  const statuses = options.statuses ?? ["queued"];
-  return target.kind === "run"
-    ? claimRunInboxMessage(target.runOrDir, owner, statuses)
-    : claimBranchInboxMessage(
-        target.stateDir,
-        target.run,
-        target.address,
-        owner,
-        statuses,
-      );
-}
-
-export function updateMailboxLoopMessageStatus(
-  target: MailboxLoopTarget,
-  id: string,
-  status: "claimed" | "handled" | "failed",
-  metadata: Record<string, unknown> = {},
-): boolean {
-  return target.kind === "run"
-    ? updateRunInboxMessageStatus(target.runOrDir, id, status, metadata)
-    : updateBranchInboxMessageStatus(
-        target.stateDir,
-        target.run,
-        target.address,
-        id,
-        status,
-        metadata,
-      );
-}
-
-export async function handleMailboxLoopOnce(
-  target: MailboxLoopTarget,
-  handler: (message: MailboxLoopMessage) => Promise<void> | void,
-  options: MailboxLoopClaimOptions = {},
-): Promise<MailboxLoopHandleResult> {
-  const message = claimMailboxLoopMessage(target, options);
-  const id = messageId(message);
-  if (!message || !id) return { handled: false, target };
-  try {
-    await handler(message);
-    updateMailboxLoopMessageStatus(target, id, "handled");
-    return { handled: true, id, message, target };
-  } catch (error) {
-    updateMailboxLoopMessageStatus(target, id, "failed", {
-      error: error instanceof Error ? error.message : String(error),
-    });
-    throw error;
-  }
-}
-
-export async function drainMailboxLoopMessages(
-  target: MailboxLoopTarget,
-  handler: (message: MailboxLoopMessage) => Promise<void> | void,
-  options: MailboxLoopDrainOptions = {},
-): Promise<MailboxLoopDrainResult> {
-  const maxMessages = Math.max(1, Math.floor(options.maxMessages ?? 100));
-  let handled = 0;
-  for (; handled < maxMessages; handled += 1) {
-    const result = await handleMailboxLoopOnce(target, handler, options);
-    if (!result.handled || !result.message) {
-      return { handled, stopped: false, target };
-    }
-    if (
-      options.stopOnControl !== false &&
-      isMailboxLoopStopMessage(result.message)
-    ) {
-      return { handled: handled + 1, stopped: true, target };
-    }
-  }
-  return { handled, stopped: false, target };
-}

package/lib/messages.ts

@@ -1,151 +0,0 @@
-/**
- * Actor message protocol.
- * Zones: addressed envelopes, address parsing, route normalization
- * Owns pure validation/normalization for semantic actor messages; transport routing stays in adapters.
- */
-
-export type ActorAddressKind =
-  | "branch"
-  | "coordinator"
-  | "room"
-  | "run"
-  | "session"
-  | "tool";
-
-export interface ActorAddress {
-  kind: ActorAddressKind;
-  value?: string;
-  branch?: string;
-  room?: string;
-}
-
-export interface ActorMessage {
-  to: string;
-  type: string;
-  body?: unknown;
-  correlation_id?: string;
-  from?: string;
-  metadata?: Record<string, unknown>;
-  reply_to?: string;
-  summary?: string;
-}
-
-const ADDRESS_PATTERN = /^[A-Za-z0-9_.-]+$/;
-const MESSAGE_TYPE_PATTERN = /^[A-Za-z][A-Za-z0-9_.:-]*$/;
-
-function assertToken(value: string, label: string): string {
-  const normalized = value.trim();
-  if (!normalized) throw new Error(`${label} is required`);
-  if (!ADDRESS_PATTERN.test(normalized)) {
-    throw new Error(`${label} contains unsupported characters: ${value}`);
-  }
-  return normalized;
-}
-
-export function parseActorAddress(address: string): ActorAddress {
-  const value = address.trim();
-  if (value === "coordinator") return { kind: "coordinator" };
-  const separator = value.indexOf(":");
-  if (separator < 0)
-    throw new Error(`Actor address must include kind: ${address}`);
-  const kind = value.slice(0, separator) as ActorAddressKind;
-  const rest = value.slice(separator + 1);
-  switch (kind) {
-    case "branch": {
-      const [run, branch, ...extra] = rest.split("/");
-      if (extra.length > 0)
-        throw new Error(`Branch address has too many parts: ${address}`);
-      return {
-        kind,
-        value: assertToken(run || "", "branch run"),
-        branch: assertToken(branch || "", "branch id"),
-      };
-    }
-    case "room": {
-      const [run, room, ...extra] = rest.split("/");
-      if (extra.length > 0)
-        throw new Error(`Room address has too many parts: ${address}`);
-      if (room && room !== "main") {
-        throw new Error("Task rooms do not support named subrooms; use room:<run>.");
-      }
-      return {
-        kind,
-        value: assertToken(run || "", "room run"),
-        room: "main",
-      };
-    }
-    case "run":
-    case "session":
-    case "tool":
-      return { kind, value: assertToken(rest, `${kind} address`) };
-    default:
-      throw new Error(`Unsupported actor address kind: ${kind}`);
-  }
-}
-
-export function formatActorAddress(address: ActorAddress): string {
-  if (address.kind === "coordinator") return "coordinator";
-  if (address.kind === "branch") {
-    return `branch:${assertToken(address.value || "", "branch run")}/${assertToken(address.branch || "", "branch id")}`;
-  }
-  if (address.kind === "room") {
-    return `room:${assertToken(address.value || "", "room run")}`;
-  }
-  return `${address.kind}:${assertToken(address.value || "", `${address.kind} address`)}`;
-}
-
-function normalizeOptionalString(
-  value: unknown,
-  label: string,
-): string | undefined {
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== "string") throw new Error(`${label} must be a string`);
-  const normalized = value.trim();
-  return normalized || undefined;
-}
-
-function normalizeMetadata(
-  value: unknown,
-): Record<string, unknown> | undefined {
-  if (value === undefined || value === null) return undefined;
-  if (typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("message metadata must be an object");
-  }
-  return value as Record<string, unknown>;
-}
-
-export function normalizeActorMessage(input: unknown): ActorMessage {
-  if (!input || typeof input !== "object" || Array.isArray(input)) {
-    throw new Error("actor message must be an object");
-  }
-  const record = input as Record<string, unknown>;
-  const to = normalizeOptionalString(record.to, "message.to");
-  if (!to) throw new Error("message.to is required");
-  const parsedTo = parseActorAddress(to);
-  const type = normalizeOptionalString(record.type, "message.type");
-  if (!type) throw new Error("message.type is required");
-  if (!MESSAGE_TYPE_PATTERN.test(type)) {
-    throw new Error(`message.type contains unsupported characters: ${type}`);
-  }
-  const from = normalizeOptionalString(record.from, "message.from");
-  if (from) parseActorAddress(from);
-  const normalizedTo = formatActorAddress(parsedTo);
-  return {
-    to: normalizedTo,
-    type,
-    ...(record.body !== undefined ? { body: record.body } : {}),
-    ...(record.correlation_id !== undefined
-      ? { correlation_id: String(record.correlation_id) }
-      : {}),
-    ...(from ? { from: formatActorAddress(parseActorAddress(from)) } : {}),
-    ...(record.metadata !== undefined
-      ? { metadata: normalizeMetadata(record.metadata) }
-      : {}),
-    ...(record.reply_to !== undefined
-      ? { reply_to: String(record.reply_to) }
-      : {}),
-    ...(record.summary !== undefined
-      ? { summary: String(record.summary) }
-      : {}),
-  };
-}