@agent-relay/sdk 10.4.0 → 10.5.0

package/dist/messaging/normalize.js

@@ -1,42 +1,72 @@
+import { AgentPresenceInfoSchema, AgentSchema, AgentStatusSchema, AgentTypeSchema, ChannelMemberInfoSchema, ChannelReadStatusSchema, ChannelSchema, CreateAgentResponseSchema, CreateGroupDmResponseSchema, DeliveryMessageSchema, DeliverySchema, DeliveryStatusSchema, InboxResponseSchema, MessageInjectionModeSchema, MessageSchema, MessageWithMetaSchema, ReactionGroupSchema, ReadReceiptSchema, ReaderInfoSchema, SearchMessageResultSchema, } from '@relaycast/types';
+import { z } from 'zod';
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function readValue(record, ...keys) {
-    if (!record)
-        return undefined;
-    for (const key of keys) {
-        if (Object.hasOwn(record, key))
-            return record[key];
+// ── Wire boundary ────────────────────────────────────────────────────────────
+//
+// `@relaycast/sdk` camelizes wire responses at runtime, while the canonical
+// contract in `@relaycast/types` (and injected raw clients) is snake_case.
+// Instead of probing both spellings field by field, every payload is folded
+// back onto the canonical snake_case wire shape once, then validated with a
+// schema derived from `@relaycast/types` and mapped deliberately.
+/** Keys whose values are caller-defined payloads that must pass through untouched. */
+const PASSTHROUGH_KEYS = new Set([
+    'metadata',
+    'blocks',
+    'data',
+    'value',
+    'input',
+    'output',
+    'parameters',
+    'headers',
+]);
+function toSnakeKey(key) {
+    return key.replace(/[A-Z]/g, (char, index) => (index > 0 ? '_' : '') + char.toLowerCase());
+}
+function toWire(value) {
+    if (Array.isArray(value))
+        return value.map(toWire);
+    if (!isRecord(value))
+        return value;
+    // Null-prototype output: an untrusted `__proto__` key (own on JSON.parse'd
+    // payloads) stays an ordinary data property instead of hijacking the
+    // prototype and feeding inherited fields to downstream reads.
+    const out = Object.create(null);
+    for (const [key, val] of Object.entries(value)) {
+        const snake = toSnakeKey(key);
+        out[snake] = PASSTHROUGH_KEYS.has(snake) ? val : toWire(val);
     }
-    return undefined;
+    return out;
 }
-function readString(record, ...keys) {
-    const value = readValue(record, ...keys);
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number' || typeof value === 'bigint')
-        return String(value);
-    return undefined;
+/** Snake-case a payload's keys and validate it against a canonical-derived schema. */
+function parseWire(schema, input) {
+    const wired = toWire(input);
+    return schema.parse(isRecord(wired) ? wired : {});
 }
-function readNullableString(record, ...keys) {
-    const value = readValue(record, ...keys);
-    return typeof value === 'string' ? value : undefined;
+/** Drop undefined values so optional fields stay absent instead of present-but-undefined. */
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
 }
-function readBoolean(record, ...keys) {
-    const value = readValue(record, ...keys);
-    return typeof value === 'boolean' ? value : undefined;
+/** Collapse empty/null strings to undefined (absent). */
+function opt(value) {
+    return value ? value : undefined;
+}
+function str(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
 }
-function readNumber(record, ...keys) {
-    const value = readValue(record, ...keys);
+function num(record, key) {
+    const value = record[key];
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
-function readArray(record, ...keys) {
-    const value = readValue(record, ...keys);
-    return Array.isArray(value) ? value : [];
+function bool(record, key) {
+    const value = record[key];
+    return typeof value === 'boolean' ? value : undefined;
 }
-function readRecord(record, ...keys) {
-    const value = readValue(record, ...keys);
-    return isRecord(value) ? { ...value } : undefined;
+function rec(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : {};
 }
 function normalizeOptionalChannelName(value) {
     if (!value)
@@ -46,384 +76,369 @@ function normalizeOptionalChannelName(value) {
 export function normalizeChannelName(value) {
     return normalizeOptionalChannelName(value) ?? value;
 }
-function normalizeAgentType(value) {
-    return value === 'human' || value === 'system' ? value : 'agent';
-}
-function normalizeAgentStatus(value) {
-    if (value === 'online' || value === 'offline' || value === 'away')
-        return value;
-    return 'unknown';
-}
-function normalizeOnlineStatus(value) {
-    return value === 'online' ? 'online' : 'offline';
-}
-function normalizeRole(value) {
-    return value === 'owner' ? 'owner' : 'member';
-}
-function normalizeMode(value) {
-    return value === 'wait' || value === 'steer' ? value : undefined;
-}
 function normalizeBlocks(value) {
     return Array.isArray(value) ? value.filter(isRecord).map((block) => ({ ...block })) : [];
 }
-function normalizeStringArray(value) {
-    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
-}
+// ── Boundary schemas ─────────────────────────────────────────────────────────
+//
+// Canonical wire schemas made tolerant of partial rows (older engines and
+// trimmed payloads omit fields); every field that is present is validated
+// against the canonical contract, and enum fields degrade to the relay
+// fallback instead of failing the whole payload.
+const WireAgentChannelSchema = AgentSchema.shape.channels
+    .unwrap()
+    .element.partial()
+    .extend({ role: ChannelMemberInfoSchema.shape.role.optional().catch(undefined) });
+const WireAgentSchema = AgentSchema.omit({ channels: true })
+    .partial()
+    .extend({
+    type: AgentTypeSchema.optional().catch(undefined),
+    status: AgentStatusSchema.optional().catch(undefined),
+    metadata: AgentSchema.shape.metadata.nullable().optional(),
+    channels: z.array(z.unknown()).optional(),
+});
+const WireRegistrationSchema = CreateAgentResponseSchema.partial().extend({
+    status: AgentStatusSchema.optional().catch(undefined),
+});
+const WirePresenceSchema = AgentPresenceInfoSchema.partial().extend({
+    status: AgentPresenceInfoSchema.shape.status.optional().catch(undefined),
+});
+const WireChannelMemberSchema = ChannelMemberInfoSchema.partial().extend({
+    role: ChannelMemberInfoSchema.shape.role.optional().catch(undefined),
+});
+const WireChannelSchema = ChannelSchema.omit({ members: true })
+    .partial()
+    .extend({
+    metadata: ChannelSchema.shape.metadata.unwrap().nullable().optional(),
+    members: z.array(z.unknown()).optional(),
+});
+// Accepts the union of canonical message rows: `MessageWithMeta` (channel
+// listings), `Message` (raw rows, where the text is `body`), the core message
+// payload carried by WebSocket events, and the nullable-sender message
+// embedded in delivery ledger rows.
+const WireMessageSchema = MessageWithMetaSchema.omit({
+    agent_id: true,
+    agent_name: true,
+    attachments: true,
+    blocks: true,
+    has_attachments: true,
+    injection_mode: true,
+    reactions: true,
+})
+    .partial()
+    .extend({
+    agent_id: DeliveryMessageSchema.shape.agent_id.optional(),
+    agent_name: DeliveryMessageSchema.shape.agent_name.optional(),
+    body: MessageSchema.shape.body.optional(),
+    updated_at: MessageSchema.shape.updated_at.optional(),
+    channel_name: z.string().optional(),
+    conversation_id: z.string().optional(),
+    parent_id: z.string().optional(),
+    mode: MessageInjectionModeSchema.optional().catch(undefined),
+    injection_mode: MessageInjectionModeSchema.optional().catch(undefined),
+    metadata: MessageWithMetaSchema.shape.metadata.unwrap().nullable().optional(),
+    // Legacy alias for `metadata` on older message rows.
+    data: z.record(z.string(), z.unknown()).nullable().optional(),
+    attachments: z.array(z.unknown()).optional(),
+    blocks: z.unknown().optional(),
+    reactions: z.array(z.unknown()).optional(),
+});
+const WireInboxChannelSchema = InboxResponseSchema.shape.unread_channels.element.partial();
+const WireInboxReactionSchema = InboxResponseSchema.shape.recent_reactions.element.partial();
+const WireInboxDmSchema = InboxResponseSchema.shape.unread_dms.element
+    .omit({ last_message: true })
+    .partial()
+    .extend({ last_message: z.unknown().optional() });
+const WireInboxLastMessageSchema = InboxResponseSchema.shape.unread_dms.element.shape.last_message
+    .unwrap()
+    .partial();
+const WireInboxSchema = z.object({
+    unread_channels: z.array(WireInboxChannelSchema).optional(),
+    mentions: z.array(z.unknown()).optional(),
+    unread_dms: z.array(z.unknown()).optional(),
+    recent_reactions: z.array(z.unknown()).optional(),
+});
+const WireReadReceiptSchema = ReadReceiptSchema.extend(ReaderInfoSchema.shape).partial();
+const WireChannelReadStatusSchema = ChannelReadStatusSchema.partial();
+const WireSearchResultSchema = SearchMessageResultSchema.partial();
+// Delivery statuses reported by the legacy `api.relaycast.dev` engine
+// (the `@relaycast/types` 3.x lifecycle names not carried into 6.x).
+const LegacyDeliveryStatusSchema = z.enum(['accepted', 'deferred']);
+// A delivery ledger row, optionally carrying its embedded message payload
+// (`DeliveryItem`) — transitions return the bare row.
+const WireDeliverySchema = DeliverySchema.partial().extend({
+    status: z.union([DeliveryStatusSchema, LegacyDeliveryStatusSchema]).optional().catch(undefined),
+    message: DeliveryMessageSchema.partial().nullable().optional(),
+});
+const WireGroupDmSchema = CreateGroupDmResponseSchema.omit({ dm_type: true, participants: true })
+    .partial()
+    .extend({
+    conversation_id: z.string().optional(),
+    participants: z.array(z.unknown()).optional(),
+});
+// ── Normalizers ──────────────────────────────────────────────────────────────
 export function normalizeAgentChannel(input) {
-    const record = isRecord(input) ? input : {};
-    const name = normalizeOptionalChannelName(readString(record, 'name', 'channelName', 'channel_name')) ?? '';
-    return {
-        id: readString(record, 'id', 'channelId', 'channel_id') ?? name,
+    const channel = parseWire(WireAgentChannelSchema, input);
+    const name = normalizeOptionalChannelName(channel.name) ?? '';
+    return compact({
+        id: channel.id ?? name,
         name,
-        role: normalizeRole(readString(record, 'role')),
-        ...(readString(record, 'joinedAt', 'joined_at')
-            ? { joinedAt: readString(record, 'joinedAt', 'joined_at') }
-            : {}),
-    };
+        role: channel.role ?? 'member',
+        joinedAt: opt(channel.joined_at),
+    });
 }
 export function normalizeAgent(input) {
-    const record = isRecord(input) ? input : {};
-    const id = readString(record, 'id', 'agentId', 'agent_id') ??
-        readString(record, 'name', 'agentName', 'agent_name') ??
-        '';
-    const name = readString(record, 'name', 'agentName', 'agent_name') ?? id;
-    const lastSeenAt = readString(record, 'lastSeenAt', 'last_seen', 'lastSeen');
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    const persona = readNullableString(record, 'persona');
-    return {
+    const agent = parseWire(WireAgentSchema, input);
+    const id = agent.id ?? agent.name ?? '';
+    return compact({
         id,
-        name,
-        type: normalizeAgentType(readString(record, 'type')),
-        status: normalizeAgentStatus(readString(record, 'status')),
-        ...(persona ? { persona } : {}),
-        metadata: readRecord(record, 'metadata') ?? {},
-        ...(lastSeenAt ? { lastSeenAt } : {}),
-        ...(createdAt ? { createdAt } : {}),
-        channels: readArray(record, 'channels').map(normalizeAgentChannel),
-    };
+        name: agent.name ?? id,
+        type: agent.type ?? 'agent',
+        status: agent.status ?? 'unknown',
+        persona: opt(agent.persona),
+        metadata: agent.metadata ?? {},
+        lastSeenAt: opt(agent.last_seen),
+        createdAt: opt(agent.created_at),
+        channels: (agent.channels ?? []).map(normalizeAgentChannel),
+    });
 }
 export function normalizeAgentRegistration(input) {
-    const record = isRecord(input) ? input : {};
-    const id = readString(record, 'id', 'agentId', 'agent_id') ?? readString(record, 'name') ?? '';
-    const name = readString(record, 'name', 'agentName', 'agent_name') ?? id;
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    return {
+    const registration = parseWire(WireRegistrationSchema, input);
+    const id = registration.id ?? registration.name ?? '';
+    return compact({
         id,
-        name,
-        token: readString(record, 'token') ?? '',
-        status: normalizeAgentStatus(readString(record, 'status')),
-        ...(createdAt ? { createdAt } : {}),
-    };
+        name: registration.name ?? id,
+        token: registration.token ?? '',
+        status: registration.status ?? 'unknown',
+        createdAt: opt(registration.created_at),
+    });
 }
 export function normalizeAgentPresence(input) {
-    const record = isRecord(input) ? input : {};
-    const agentId = readString(record, 'agentId', 'agent_id', 'id') ?? '';
-    const agentName = readString(record, 'agentName', 'agent_name', 'name') ?? agentId;
+    const presence = parseWire(WirePresenceSchema, input);
+    const agentId = presence.agent_id ?? '';
     return {
         agentId,
-        agentName,
-        status: normalizeOnlineStatus(readString(record, 'status')),
+        agentName: presence.agent_name ?? agentId,
+        status: presence.status === 'online' ? 'online' : 'offline',
     };
 }
 export function normalizeChannelMember(input) {
-    const record = isRecord(input) ? input : {};
-    const agentId = readString(record, 'agentId', 'agent_id', 'id') ?? '';
-    const agentName = readString(record, 'agentName', 'agent_name', 'name') ?? agentId;
-    return {
+    const member = parseWire(WireChannelMemberSchema, input);
+    const agentId = member.agent_id ?? '';
+    return compact({
         agentId,
-        agentName,
-        role: normalizeRole(readString(record, 'role')),
-        ...(readString(record, 'joinedAt', 'joined_at')
-            ? { joinedAt: readString(record, 'joinedAt', 'joined_at') }
-            : {}),
-        muted: readBoolean(record, 'muted', 'isMuted', 'is_muted') ?? false,
-    };
+        agentName: member.agent_name ?? agentId,
+        role: member.role ?? 'member',
+        joinedAt: opt(member.joined_at),
+        muted: member.is_muted ?? false,
+    });
 }
 export function normalizeChannel(input) {
-    const record = isRecord(input) ? input : {};
-    const name = normalizeOptionalChannelName(readString(record, 'name', 'channelName', 'channel_name')) ?? '';
-    const topic = readNullableString(record, 'topic');
-    const createdBy = readString(record, 'createdBy', 'created_by');
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    const memberCount = readNumber(record, 'memberCount', 'member_count');
-    return {
-        id: readString(record, 'id', 'channelId', 'channel_id') ?? name,
+    const channel = parseWire(WireChannelSchema, input);
+    const name = normalizeOptionalChannelName(channel.name) ?? '';
+    return compact({
+        id: channel.id ?? name,
         name,
-        ...(topic ? { topic } : {}),
-        metadata: readRecord(record, 'metadata') ?? {},
-        ...(createdBy ? { createdBy } : {}),
-        ...(createdAt ? { createdAt } : {}),
-        archived: readBoolean(record, 'archived', 'isArchived', 'is_archived') ?? false,
-        ...(memberCount !== undefined ? { memberCount } : {}),
-        members: readArray(record, 'members').map(normalizeChannelMember),
-    };
+        topic: opt(channel.topic),
+        metadata: channel.metadata ?? {},
+        createdBy: opt(channel.created_by),
+        createdAt: opt(channel.created_at),
+        archived: channel.is_archived ?? false,
+        memberCount: channel.member_count,
+        members: (channel.members ?? []).map(normalizeChannelMember),
+    });
 }
 export function normalizeAttachment(input) {
-    const record = isRecord(input) ? input : {};
-    const type = readString(record, 'type');
-    if (type === 'text') {
-        return {
-            type,
-            text: readString(record, 'text', 'content') ?? '',
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'image') {
-        return {
-            type,
-            ...(readString(record, 'url') ? { url: readString(record, 'url') } : {}),
-            ...(readString(record, 'data') ? { data: readString(record, 'data') } : {}),
-            ...(readString(record, 'mimeType', 'mime_type')
-                ? { mimeType: readString(record, 'mimeType', 'mime_type') }
-                : {}),
-            ...(readString(record, 'alt') ? { alt: readString(record, 'alt') } : {}),
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'link') {
-        return {
-            type,
-            url: readString(record, 'url') ?? '',
-            ...(readString(record, 'title') ? { title: readString(record, 'title') } : {}),
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'file') {
-        return {
-            type,
-            path: readString(record, 'path') ?? readString(record, 'filename', 'name') ?? '',
-            ...(readNumber(record, 'line') !== undefined ? { line: readNumber(record, 'line') } : {}),
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'json') {
-        return {
-            type,
-            value: readValue(record, 'value'),
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'diff') {
-        return {
-            type,
-            patch: readString(record, 'patch', 'diff') ?? '',
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
-    }
-    if (type === 'artifact') {
-        return {
-            type,
-            id: readString(record, 'id', 'artifactId', 'artifact_id') ?? '',
-            ...(readString(record, 'url') ? { url: readString(record, 'url') } : {}),
-            ...(readString(record, 'label') ? { label: readString(record, 'label') } : {}),
-        };
+    const wired = toWire(input);
+    const record = isRecord(wired) ? wired : {};
+    const type = str(record, 'type');
+    const label = opt(str(record, 'label'));
+    switch (type) {
+        case 'text':
+            return compact({ type, text: str(record, 'text') ?? str(record, 'content') ?? '', label });
+        case 'image':
+            return compact({
+                type,
+                url: opt(str(record, 'url')),
+                data: opt(str(record, 'data')),
+                mimeType: opt(str(record, 'mime_type')),
+                alt: opt(str(record, 'alt')),
+                label,
+            });
+        case 'link':
+            return compact({ type, url: str(record, 'url') ?? '', title: opt(str(record, 'title')), label });
+        case 'file':
+            return compact({
+                type,
+                path: str(record, 'path') ?? str(record, 'filename') ?? '',
+                line: num(record, 'line'),
+                label,
+            });
+        case 'json':
+            return compact({ type, value: record.value, label });
+        case 'diff':
+            return compact({ type, patch: str(record, 'patch') ?? str(record, 'diff') ?? '', label });
+        case 'artifact':
+            return compact({
+                type,
+                id: str(record, 'id') ?? str(record, 'artifact_id') ?? '',
+                url: opt(str(record, 'url')),
+                label,
+            });
+        default: {
+            // Canonical stored file attachment (`FileAttachment`).
+            const filename = str(record, 'filename');
+            return compact({
+                id: str(record, 'id') ?? str(record, 'file_id') ?? filename ?? '',
+                filename: opt(filename),
+                contentType: opt(str(record, 'content_type')),
+                sizeBytes: num(record, 'size_bytes'),
+            });
+        }
     }
-    const filename = readString(record, 'filename', 'name');
-    const contentType = readString(record, 'contentType', 'content_type');
-    const sizeBytes = readNumber(record, 'sizeBytes', 'size_bytes');
-    return {
-        id: readString(record, 'id', 'fileId', 'file_id') ?? filename ?? '',
-        ...(filename ? { filename } : {}),
-        ...(contentType ? { contentType } : {}),
-        ...(sizeBytes !== undefined ? { sizeBytes } : {}),
-    };
 }
 export function normalizeReaction(input) {
-    const record = isRecord(input) ? input : {};
+    const reaction = parseWire(ReactionGroupSchema.partial(), input);
     return {
-        emoji: readString(record, 'emoji') ?? '',
-        count: readNumber(record, 'count') ?? 0,
-        agents: normalizeStringArray(readValue(record, 'agents', 'agentNames', 'agent_names')),
+        emoji: reaction.emoji ?? '',
+        count: reaction.count ?? 0,
+        agents: reaction.agents ?? [],
     };
 }
 export function normalizeMessage(input, context = {}) {
-    const record = isRecord(input) ? input : {};
-    const fromRecord = isRecord(readValue(record, 'from', 'sender', 'agent'))
-        ? readValue(record, 'from', 'sender', 'agent')
-        : undefined;
-    const channelName = context.channelName ??
-        normalizeOptionalChannelName(readString(record, 'channelName', 'channel_name', 'channel'));
-    const channelId = context.channelId ?? readString(record, 'channelId', 'channel_id');
-    const conversationId = context.conversationId ?? readString(record, 'conversationId', 'conversation_id');
-    const parentId = context.parentId ?? readString(record, 'parentId', 'parent_id');
-    const threadId = context.threadId ?? readNullableString(record, 'threadId', 'thread_id');
-    const createdAt = readString(record, 'createdAt', 'created_at') ?? context.createdAt;
-    const updatedAt = readNullableString(record, 'updatedAt', 'updated_at');
-    const metadata = readRecord(record, 'metadata') ?? readRecord(record, 'data');
-    const replyCount = readNumber(record, 'replyCount', 'reply_count');
-    const readByCount = readNumber(record, 'readByCount', 'read_by_count');
+    const message = parseWire(WireMessageSchema, input);
+    const channelName = context.channelName ?? normalizeOptionalChannelName(message.channel_name);
+    const channelId = context.channelId ?? message.channel_id;
+    const conversationId = context.conversationId ?? message.conversation_id;
+    const parentId = context.parentId ?? message.parent_id;
     const kind = context.kind ??
         (parentId ? 'thread_reply' : conversationId ? 'dm' : channelId || channelName ? 'channel' : 'unknown');
-    const id = readString(record, 'id', 'messageId', 'message_id') ?? '';
-    return {
+    const id = message.id ?? '';
+    return compact({
         id,
         messageId: id,
         kind,
-        text: readString(record, 'text', 'body') ?? '',
-        from: {
-            ...((readString(record, 'agentId', 'agent_id', 'fromId', 'from_id') ??
-                readString(fromRecord, 'id', 'agentId', 'agent_id'))
-                ? {
-                    id: readString(record, 'agentId', 'agent_id', 'fromId', 'from_id') ??
-                        readString(fromRecord, 'id', 'agentId', 'agent_id'),
-                }
-                : {}),
-            ...((readString(record, 'agentName', 'agent_name', 'fromName', 'from_name', 'from') ??
-                readString(fromRecord, 'name', 'agentName', 'agent_name'))
-                ? {
-                    name: readString(record, 'agentName', 'agent_name', 'fromName', 'from_name', 'from') ??
-                        readString(fromRecord, 'name', 'agentName', 'agent_name'),
-                }
-                : {}),
-        },
-        ...(channelId || channelName
-            ? {
-                channel: {
-                    ...(channelId ? { id: channelId } : {}),
-                    ...(channelName ? { name: channelName } : {}),
-                },
-            }
-            : {}),
-        ...(conversationId ? { conversationId } : {}),
-        ...(threadId ? { threadId } : {}),
-        ...(parentId ? { parentId } : {}),
-        ...(normalizeMode(readString(record, 'mode', 'injectionMode', 'injection_mode'))
-            ? {
-                mode: normalizeMode(readString(record, 'mode', 'injectionMode', 'injection_mode')),
-            }
-            : {}),
-        ...(createdAt ? { createdAt } : {}),
-        ...(updatedAt ? { updatedAt } : {}),
-        ...(metadata ? { metadata } : {}),
-        blocks: normalizeBlocks(readValue(record, 'blocks')),
-        attachments: readArray(record, 'attachments').map(normalizeAttachment),
-        ...(replyCount !== undefined ? { replyCount } : {}),
-        reactions: readArray(record, 'reactions').map(normalizeReaction),
-        ...(readByCount !== undefined ? { readByCount } : {}),
-        mentions: normalizeStringArray(readValue(record, 'mentions')),
-    };
+        text: message.text ?? message.body ?? '',
+        from: compact({ id: opt(message.agent_id), name: opt(message.agent_name) }),
+        channel: channelId || channelName
+            ? compact({ id: opt(channelId), name: opt(channelName) })
+            : undefined,
+        conversationId: opt(conversationId),
+        threadId: opt(context.threadId ?? message.thread_id),
+        parentId: opt(parentId),
+        mode: message.mode ?? message.injection_mode,
+        createdAt: opt(message.created_at ?? context.createdAt),
+        updatedAt: opt(message.updated_at),
+        metadata: message.metadata ?? message.data ?? undefined,
+        blocks: normalizeBlocks(message.blocks),
+        attachments: (message.attachments ?? []).map(normalizeAttachment),
+        replyCount: message.reply_count,
+        reactions: (message.reactions ?? []).map(normalizeReaction),
+        readByCount: message.read_by_count,
+        mentions: message.mentions ?? [],
+    });
 }
 export function normalizeThread(input) {
     const record = isRecord(input) ? input : {};
-    const parent = normalizeMessage(readValue(record, 'parent'), { kind: 'channel' });
-    const replies = readArray(record, 'replies').map((reply) => normalizeMessage(reply, {
-        kind: 'thread_reply',
-        channelId: parent.channel?.id,
-        channelName: parent.channel?.name,
-        threadId: parent.threadId ?? parent.id,
-        parentId: parent.id,
-    }));
-    return { parent, replies };
+    const parent = normalizeMessage(record.parent, { kind: 'channel' });
+    const replies = Array.isArray(record.replies) ? record.replies : [];
+    return {
+        parent,
+        replies: replies.map((reply) => normalizeMessage(reply, {
+            kind: 'thread_reply',
+            channelId: parent.channel?.id,
+            channelName: parent.channel?.name,
+            threadId: parent.threadId ?? parent.id,
+            parentId: parent.id,
+        })),
+    };
 }
 function normalizeInboxLastMessage(input) {
-    const record = isRecord(input) ? input : undefined;
-    if (!record)
+    if (!isRecord(input))
         return undefined;
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    return {
-        id: readString(record, 'id', 'messageId', 'message_id') ?? '',
-        text: readString(record, 'text', 'body') ?? '',
-        ...(createdAt ? { createdAt } : {}),
-    };
+    const last = parseWire(WireInboxLastMessageSchema, input);
+    return compact({
+        id: last.id ?? '',
+        text: last.text ?? '',
+        createdAt: opt(last.created_at),
+    });
 }
 function normalizeInboxDirect(input) {
-    const record = isRecord(input) ? input : {};
-    const lastMessage = normalizeInboxLastMessage(readValue(record, 'lastMessage', 'last_message'));
-    return {
-        conversationId: readString(record, 'conversationId', 'conversation_id') ?? '',
-        from: readString(record, 'from', 'agentName', 'agent_name') ?? '',
-        unreadCount: readNumber(record, 'unreadCount', 'unread_count') ?? 0,
-        ...(lastMessage ? { lastMessage } : {}),
-    };
+    const dm = parseWire(WireInboxDmSchema, input);
+    return compact({
+        conversationId: dm.conversation_id ?? '',
+        from: dm.from ?? '',
+        unreadCount: dm.unread_count ?? 0,
+        lastMessage: normalizeInboxLastMessage(dm.last_message),
+    });
 }
 function normalizeInboxReaction(input) {
-    const record = isRecord(input) ? input : {};
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    return {
-        messageId: readString(record, 'messageId', 'message_id') ?? '',
-        channelName: normalizeOptionalChannelName(readString(record, 'channelName', 'channel_name', 'channel')) ?? '',
-        emoji: readString(record, 'emoji') ?? '',
-        agentName: readString(record, 'agentName', 'agent_name') ?? '',
-        ...(createdAt ? { createdAt } : {}),
-    };
+    const reaction = parseWire(WireInboxReactionSchema, input);
+    return compact({
+        messageId: reaction.message_id ?? '',
+        channelName: normalizeOptionalChannelName(reaction.channel_name) ?? '',
+        emoji: reaction.emoji ?? '',
+        agentName: reaction.agent_name ?? '',
+        createdAt: opt(reaction.created_at),
+    });
 }
 export function normalizeInbox(input) {
-    const record = isRecord(input) ? input : {};
+    const inbox = parseWire(WireInboxSchema, input);
     return {
-        unreadChannels: readArray(record, 'unreadChannels', 'unread_channels').map((item) => {
-            const itemRecord = isRecord(item) ? item : {};
-            return {
-                channelName: normalizeOptionalChannelName(readString(itemRecord, 'channelName', 'channel_name', 'channel')) ??
-                    '',
-                unreadCount: readNumber(itemRecord, 'unreadCount', 'unread_count') ?? 0,
-            };
-        }),
-        mentions: readArray(record, 'mentions').map((item) => {
-            const itemRecord = isRecord(item) ? item : {};
-            return normalizeMessage(itemRecord, {
-                kind: 'channel',
-                channelName: normalizeOptionalChannelName(readString(itemRecord, 'channelName', 'channel_name', 'channel')),
-            });
-        }),
-        unreadDms: readArray(record, 'unreadDms', 'unread_dms').map(normalizeInboxDirect),
-        recentReactions: readArray(record, 'recentReactions', 'recent_reactions').map(normalizeInboxReaction),
+        unreadChannels: (inbox.unread_channels ?? []).map((channel) => ({
+            channelName: normalizeOptionalChannelName(channel.channel_name) ?? '',
+            unreadCount: channel.unread_count ?? 0,
+        })),
+        mentions: (inbox.mentions ?? []).map((mention) => normalizeMessage(mention, { kind: 'channel' })),
+        unreadDms: (inbox.unread_dms ?? []).map(normalizeInboxDirect),
+        recentReactions: (inbox.recent_reactions ?? []).map(normalizeInboxReaction),
     };
 }
 export function normalizeReadReceipt(input) {
-    const record = isRecord(input) ? input : {};
-    const readAt = readString(record, 'readAt', 'read_at');
-    return {
-        messageId: readString(record, 'messageId', 'message_id') ?? '',
-        ...(readString(record, 'agentId', 'agent_id')
-            ? { agentId: readString(record, 'agentId', 'agent_id') }
-            : {}),
-        ...(readString(record, 'agentName', 'agent_name')
-            ? { agentName: readString(record, 'agentName', 'agent_name') }
-            : {}),
-        ...(readAt ? { readAt } : {}),
-    };
+    const receipt = parseWire(WireReadReceiptSchema, input);
+    return compact({
+        messageId: receipt.message_id ?? '',
+        agentId: opt(receipt.agent_id),
+        agentName: opt(receipt.agent_name),
+        readAt: opt(receipt.read_at),
+    });
 }
 export function normalizeChannelReadStatus(input) {
-    const record = isRecord(input) ? input : {};
-    const lastReadId = readNullableString(record, 'lastReadId', 'last_read_id');
-    const lastReadAt = readNullableString(record, 'lastReadAt', 'last_read_at');
-    return {
-        agentName: readString(record, 'agentName', 'agent_name') ?? '',
-        ...(lastReadId ? { lastReadId } : {}),
-        ...(lastReadAt ? { lastReadAt } : {}),
-    };
-}
-// Relaycast durable delivery ledger statuses mapped onto relay inbox states.
-// `accepted` means queued for the recipient; the ledger has no `read` state.
+    const status = parseWire(WireChannelReadStatusSchema, input);
+    return compact({
+        agentName: status.agent_name ?? '',
+        lastReadId: opt(status.last_read_id),
+        lastReadAt: opt(status.last_read_at),
+    });
+}
+// Canonical durable delivery statuses mapped onto relay inbox states:
+// the terminal `acked` surfaces as `read` and `dead_lettered` as `failed`;
+// a deferred 6.x row stays `queued` with a future `available_at`. Typed
+// against `DeliveryStatus` so a new canonical status fails to compile here
+// until it is mapped. Legacy `api.relaycast.dev` statuses map alongside.
 const INBOX_STATE_BY_DELIVERY_STATUS = {
-    accepted: 'queued',
+    queued: 'queued',
     delivered: 'delivered',
-    deferred: 'deferred',
+    acked: 'read',
     failed: 'failed',
+    dead_lettered: 'failed',
+    // Legacy 3.x lifecycle names.
+    accepted: 'queued',
+    deferred: 'deferred',
 };
 export function normalizeInboxItemState(value) {
-    return (value !== undefined ? INBOX_STATE_BY_DELIVERY_STATUS[value] : undefined) ?? 'queued';
-}
-function normalizeDeliveryMetadata(record) {
-    const metadata = {};
-    const mode = readString(record, 'mode');
-    const reason = readNullableString(record, 'reason');
-    const priority = readString(record, 'priority');
-    const retryable = readBoolean(record, 'retryable');
-    const error = readNullableString(record, 'error');
-    const deadline = readNullableString(record, 'deadline');
-    if (mode)
-        metadata.mode = mode;
-    if (reason)
-        metadata.reason = reason;
-    if (priority)
-        metadata.priority = priority;
-    if (retryable !== undefined)
-        metadata.retryable = retryable;
-    if (error)
-        metadata.error = error;
-    if (deadline)
-        metadata.deadline = deadline;
+    const status = z.union([DeliveryStatusSchema, LegacyDeliveryStatusSchema]).safeParse(value);
+    return status.success ? INBOX_STATE_BY_DELIVERY_STATUS[status.data] : 'queued';
+}
+function normalizeDeliveryMetadata(delivery) {
+    const metadata = compact({
+        mode: opt(delivery.mode),
+        reason: opt(delivery.reason),
+        priority: opt(delivery.priority),
+        retryable: delivery.retryable ?? undefined,
+        error: opt(delivery.error),
+        deadline: opt(delivery.deadline),
+    });
     return Object.keys(metadata).length > 0 ? metadata : undefined;
 }
 /**
@@ -431,107 +446,92 @@ function normalizeDeliveryMetadata(record) {
  * its embedded message payload) into a relay `InboxItem`.
  */
 export function normalizeInboxItem(input, context = {}) {
-    const record = isRecord(input) ? input : {};
-    const messageId = readString(record, 'messageId', 'message_id');
-    const channelId = readString(record, 'channelId', 'channel_id');
-    const agentId = readString(record, 'agentId', 'agent_id');
-    const availableAt = readNullableString(record, 'availableAt', 'available_at');
-    const messageRecord = readRecord(record, 'message');
-    const metadata = normalizeDeliveryMetadata(record);
-    return {
-        id: readString(record, 'id', 'deliveryId', 'delivery_id') ?? '',
-        recipient: {
-            name: context.recipientName ?? agentId ?? '',
-            ...(agentId ? { id: agentId } : {}),
-        },
-        state: normalizeInboxItemState(readString(record, 'status')),
+    const delivery = parseWire(WireDeliverySchema, input);
+    return compact({
+        id: delivery.id ?? '',
+        recipient: compact({
+            name: context.recipientName ?? delivery.agent_id ?? '',
+            id: opt(delivery.agent_id),
+        }),
+        state: delivery.status ? INBOX_STATE_BY_DELIVERY_STATUS[delivery.status] : 'queued',
         // The relaycast ledger does not expose attempt counts.
         attempts: 0,
-        ...(availableAt ? { availableAt } : {}),
-        message: normalizeMessage(messageRecord ?? {
-            ...(messageId ? { id: messageId } : {}),
-            ...(channelId ? { channel_id: channelId } : {}),
-        }),
-        ...(metadata ? { metadata } : {}),
-    };
+        availableAt: opt(delivery.available_at),
+        message: normalizeMessage(delivery.message ??
+            compact({ id: opt(delivery.message_id), channel_id: opt(delivery.channel_id) })),
+        metadata: normalizeDeliveryMetadata(delivery),
+    });
 }
 /**
  * Normalize the delivery row returned by a relaycast ack/fail/defer transition
  * into the relay delivery result contract.
  */
 export function normalizeDeliveryTransition(action, input) {
-    const record = isRecord(input) ? input : {};
-    const availableAt = readNullableString(record, 'availableAt', 'available_at');
-    return {
+    const delivery = parseWire(WireDeliverySchema, input);
+    return compact({
         supported: true,
         action,
-        deliveryId: readString(record, 'id', 'deliveryId', 'delivery_id') ?? '',
-        messageId: readString(record, 'messageId', 'message_id') ?? '',
-        state: normalizeInboxItemState(readString(record, 'status')),
-        ...(action === 'defer' && availableAt ? { deferUntil: availableAt } : {}),
-    };
+        deliveryId: delivery.id ?? '',
+        messageId: delivery.message_id ?? '',
+        state: delivery.status ? INBOX_STATE_BY_DELIVERY_STATUS[delivery.status] : 'queued',
+        deferUntil: action === 'defer' ? opt(delivery.available_at) : undefined,
+    });
 }
 export function normalizeSearchResult(input) {
-    const record = isRecord(input) ? input : {};
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    return {
-        id: readString(record, 'id', 'messageId', 'message_id') ?? '',
-        channelName: normalizeOptionalChannelName(readString(record, 'channelName', 'channel_name', 'channel')) ?? '',
-        agentName: readString(record, 'agentName', 'agent_name') ?? '',
-        text: readString(record, 'text', 'body') ?? '',
-        ...(createdAt ? { createdAt } : {}),
-        relevanceScore: readNumber(record, 'relevanceScore', 'relevance_score') ?? 0,
-    };
+    const result = parseWire(WireSearchResultSchema, input);
+    return compact({
+        id: result.id ?? '',
+        channelName: normalizeOptionalChannelName(result.channel_name) ?? '',
+        agentName: result.agent_name ?? '',
+        text: result.text ?? '',
+        createdAt: opt(result.created_at),
+        relevanceScore: result.relevance_score ?? 0,
+    });
 }
 export function normalizeGroupDirectConversation(input) {
-    const record = isRecord(input) ? input : {};
-    const name = readNullableString(record, 'name');
-    const createdAt = readString(record, 'createdAt', 'created_at');
-    return {
-        id: readString(record, 'id', 'conversationId', 'conversation_id') ?? '',
-        ...(readString(record, 'channelId', 'channel_id')
-            ? { channelId: readString(record, 'channelId', 'channel_id') }
-            : {}),
-        ...(name ? { name } : {}),
-        participants: readArray(record, 'participants')
-            .map((participant) => {
-            const participantRecord = isRecord(participant) ? participant : undefined;
-            return typeof participant === 'string'
-                ? participant
-                : readString(participantRecord, 'agentName', 'agent_name', 'agentId', 'agent_id');
-        })
+    const conversation = parseWire(WireGroupDmSchema, input);
+    return compact({
+        id: conversation.id ?? conversation.conversation_id ?? '',
+        channelId: opt(conversation.channel_id),
+        name: opt(conversation.name),
+        participants: (conversation.participants ?? [])
+            .map((participant) => typeof participant === 'string'
+            ? participant
+            : isRecord(participant)
+                ? (str(participant, 'agent_name') ?? str(participant, 'agent_id'))
+                : undefined)
             .filter((participant) => typeof participant === 'string'),
-        ...(createdAt ? { createdAt } : {}),
-    };
-}
+        createdAt: opt(conversation.created_at),
+    });
+}
+const MEMBERSHIP_EVENT_TYPES = {
+    'member.joined': 'memberJoined',
+    'member.left': 'memberLeft',
+    'member.channel_muted': 'channelMuted',
+    'member.channel_unmuted': 'channelUnmuted',
+};
 export function normalizeMessagingEvent(input) {
-    const record = isRecord(input) ? input : {};
-    const sourceType = readString(record, 'type');
+    const wired = toWire(input);
+    const record = isRecord(wired) ? wired : {};
+    const sourceType = str(record, 'type');
     switch (sourceType) {
-        case 'message.created': {
-            const channel = normalizeOptionalChannelName(readString(record, 'channel')) ?? '';
-            return {
-                type: 'messageCreated',
-                channel,
-                message: normalizeMessage(readValue(record, 'message'), { kind: 'channel', channelName: channel }),
-            };
-        }
+        case 'message.created':
         case 'message.updated': {
-            const channel = normalizeOptionalChannelName(readString(record, 'channel')) ?? '';
+            const channel = normalizeOptionalChannelName(str(record, 'channel')) ?? '';
             return {
-                type: 'messageUpdated',
+                type: sourceType === 'message.created' ? 'messageCreated' : 'messageUpdated',
                 channel,
-                message: normalizeMessage(readValue(record, 'message'), { kind: 'channel', channelName: channel }),
+                message: normalizeMessage(record.message, { kind: 'channel', channelName: channel }),
             };
         }
         case 'thread.reply': {
-            const channel = normalizeOptionalChannelName(readString(record, 'channel')) ?? '';
-            const parentId = readString(record, 'parentId', 'parent_id') ?? '';
+            const channel = normalizeOptionalChannelName(str(record, 'channel')) ?? '';
+            const parentId = str(record, 'parent_id') ?? '';
             return {
                 type: 'threadReply',
                 channel,
                 parentId,
-                message: normalizeMessage(readValue(record, 'message'), {
+                message: normalizeMessage(record.message, {
                     kind: 'thread_reply',
                     channelName: channel,
                     parentId,
@@ -539,130 +539,100 @@ export function normalizeMessagingEvent(input) {
                 }),
             };
         }
-        case 'dm.received': {
-            const conversationId = readString(record, 'conversationId', 'conversation_id') ?? '';
-            return {
-                type: 'dmReceived',
-                conversationId,
-                message: normalizeMessage(readValue(record, 'message'), { kind: 'dm', conversationId }),
-            };
-        }
+        case 'dm.received':
         case 'group_dm.received': {
-            const conversationId = readString(record, 'conversationId', 'conversation_id') ?? '';
+            const conversationId = str(record, 'conversation_id') ?? '';
+            const kind = sourceType === 'dm.received' ? 'dm' : 'group_dm';
             return {
-                type: 'groupDmReceived',
+                type: kind === 'dm' ? 'dmReceived' : 'groupDmReceived',
                 conversationId,
-                message: normalizeMessage(readValue(record, 'message'), { kind: 'group_dm', conversationId }),
+                message: normalizeMessage(record.message, { kind, conversationId }),
             };
         }
+        // Legacy presence events emitted by older engines; current engines emit
+        // `agent.status.*` (surfaced as `unknown` events).
         case 'agent.online':
-            return {
-                type: 'agentOnline',
-                agent: {
-                    name: readString(isRecord(readValue(record, 'agent'))
-                        ? readValue(record, 'agent')
-                        : undefined, 'name') ?? '',
-                },
-            };
         case 'agent.offline':
             return {
-                type: 'agentOffline',
-                agent: {
-                    name: readString(isRecord(readValue(record, 'agent'))
-                        ? readValue(record, 'agent')
-                        : undefined, 'name') ?? '',
-                },
+                type: sourceType === 'agent.online' ? 'agentOnline' : 'agentOffline',
+                agent: { name: str(rec(record, 'agent'), 'name') ?? '' },
             };
         case 'agent.spawn_requested': {
-            const agent = isRecord(readValue(record, 'agent')) ? readValue(record, 'agent') : {};
+            const agent = rec(record, 'agent');
             return {
                 type: 'agentSpawnRequested',
-                agent: {
-                    name: readString(agent, 'name') ?? '',
-                    ...(readString(agent, 'cli') ? { cli: readString(agent, 'cli') } : {}),
-                    ...(readString(agent, 'task') ? { task: readString(agent, 'task') } : {}),
-                    ...(normalizeOptionalChannelName(readNullableString(agent, 'channel') ?? undefined)
-                        ? { channel: normalizeOptionalChannelName(readNullableString(agent, 'channel') ?? undefined) }
-                        : {}),
-                    ...(readString(agent, 'model') ? { model: readString(agent, 'model') } : {}),
-                    alreadyExisted: readBoolean(agent, 'alreadyExisted', 'already_existed') ?? false,
-                },
+                agent: compact({
+                    name: str(agent, 'name') ?? '',
+                    cli: opt(str(agent, 'cli')),
+                    task: opt(str(agent, 'task')),
+                    channel: normalizeOptionalChannelName(str(agent, 'channel')),
+                    model: opt(str(agent, 'model')),
+                    alreadyExisted: bool(agent, 'already_existed') ?? false,
+                }),
             };
         }
-        case 'agent.release_requested': {
-            const agent = isRecord(readValue(record, 'agent')) ? readValue(record, 'agent') : {};
-            const reason = readNullableString(record, 'reason');
-            return {
+        case 'agent.release_requested':
+            return compact({
                 type: 'agentReleaseRequested',
-                agent: { name: readString(agent, 'name') ?? '' },
-                ...(reason ? { reason } : {}),
-                deleted: readBoolean(record, 'deleted') ?? false,
-            };
-        }
+                agent: { name: str(rec(record, 'agent'), 'name') ?? '' },
+                reason: opt(str(record, 'reason')),
+                deleted: bool(record, 'deleted') ?? false,
+            });
         case 'channel.created':
         case 'channel.updated': {
-            const channel = isRecord(readValue(record, 'channel'))
-                ? readValue(record, 'channel')
-                : {};
-            const topic = readNullableString(channel, 'topic');
+            const channel = rec(record, 'channel');
             return {
                 type: sourceType === 'channel.created' ? 'channelCreated' : 'channelUpdated',
-                channel: {
-                    name: normalizeOptionalChannelName(readString(channel, 'name')) ?? '',
-                    ...(topic ? { topic } : {}),
-                },
+                channel: compact({
+                    name: normalizeOptionalChannelName(str(channel, 'name')) ?? '',
+                    topic: opt(str(channel, 'topic')),
+                }),
             };
         }
-        case 'channel.archived': {
-            const channel = isRecord(readValue(record, 'channel'))
-                ? readValue(record, 'channel')
-                : {};
+        case 'channel.archived':
             return {
                 type: 'channelArchived',
-                channel: { name: normalizeOptionalChannelName(readString(channel, 'name')) ?? '' },
+                channel: { name: normalizeOptionalChannelName(str(rec(record, 'channel'), 'name')) ?? '' },
             };
-        }
         case 'member.joined':
         case 'member.left':
         case 'member.channel_muted':
-        case 'member.channel_unmuted': {
-            const type = sourceType === 'member.joined'
-                ? 'memberJoined'
-                : sourceType === 'member.left'
-                    ? 'memberLeft'
-                    : sourceType === 'member.channel_muted'
-                        ? 'channelMuted'
-                        : 'channelUnmuted';
+        case 'member.channel_unmuted':
             return {
-                type,
-                channel: normalizeOptionalChannelName(readString(record, 'channel')) ?? '',
-                agentName: readString(record, 'agentName', 'agent_name') ?? '',
+                type: MEMBERSHIP_EVENT_TYPES[sourceType],
+                channel: normalizeOptionalChannelName(str(record, 'channel')) ?? '',
+                agentName: str(record, 'agent_name') ?? '',
             };
-        }
         case 'message.read':
-            return {
+            return compact({
                 type: 'messageRead',
-                messageId: readString(record, 'messageId', 'message_id') ?? '',
-                agentName: readString(record, 'agentName', 'agent_name') ?? '',
-                ...(readString(record, 'readAt', 'read_at')
-                    ? { readAt: readString(record, 'readAt', 'read_at') }
-                    : {}),
-            };
+                messageId: str(record, 'message_id') ?? '',
+                agentName: str(record, 'agent_name') ?? '',
+                readAt: opt(str(record, 'read_at')),
+            });
+        // Canonical reaction event plus the legacy split pair. The engine's raw
+        // workspace-stream frames and the durable event log (observer mode) carry
+        // reactions as a single `message.reacted` type with an `action` field;
+        // higher-level clients split it into `reaction.added`/`reaction.removed`
+        // before we see it. All three land here.
+        case 'message.reacted':
         case 'reaction.added':
         case 'reaction.removed':
             return {
-                type: sourceType === 'reaction.added' ? 'reactionAdded' : 'reactionRemoved',
-                messageId: readString(record, 'messageId', 'message_id') ?? '',
-                emoji: readString(record, 'emoji') ?? '',
-                agentName: readString(record, 'agentName', 'agent_name') ?? '',
+                type: sourceType === 'reaction.removed' || str(record, 'action') === 'removed'
+                    ? 'reactionRemoved'
+                    : 'reactionAdded',
+                messageId: str(record, 'message_id') ?? '',
+                emoji: str(record, 'emoji') ?? '',
+                agentName: str(record, 'agent_name') ?? '',
             };
         case 'action.invoked':
             return {
                 type: 'actionInvoked',
-                invocationId: readString(record, 'invocationId', 'invocation_id') ?? '',
-                actionName: readString(record, 'actionName', 'action_name') ?? '',
-                callerName: readString(record, 'callerName', 'caller_name') ?? '',
-                handlerAgentId: readString(record, 'handlerAgentId', 'handler_agent_id') ?? '',
+                invocationId: str(record, 'invocation_id') ?? '',
+                actionName: str(record, 'action_name') ?? '',
+                callerName: str(record, 'caller_name') ?? '',
+                handlerAgentId: str(record, 'handler_agent_id') ?? '',
             };
         case 'open':
             return { type: 'connected' };
@@ -671,9 +641,9 @@ export function normalizeMessagingEvent(input) {
         case 'error':
             return { type: 'error' };
         case 'reconnecting':
-            return { type: 'reconnecting', attempt: readNumber(record, 'attempt') ?? 0 };
+            return { type: 'reconnecting', attempt: num(record, 'attempt') ?? 0 };
         case 'permanently_disconnected':
-            return { type: 'permanentlyDisconnected', attempt: readNumber(record, 'attempt') ?? 0 };
+            return { type: 'permanentlyDisconnected', attempt: num(record, 'attempt') ?? 0 };
         default:
             return { type: 'unknown', ...(sourceType ? { sourceType } : {}), raw: input };
     }