@langchain/langgraph-api 1.1.16 → 1.2.0

package/dist/protocol/session/state-normalizers.mjs

@@ -0,0 +1,430 @@
+import { isRecord } from "./internal-types.mjs";
+import { getTupleToolCallArgs, getTupleToolCallIdentity, normalizeFinalToolCallArgs, } from "./tool-calls.mjs";
+const PROTOCOL_STATE_MESSAGE_TYPES = new Set([
+    "human",
+    "user",
+    "ai",
+    "assistant",
+    "system",
+    "tool",
+    "function",
+    "remove",
+]);
+const MIME_TYPE_BY_AUDIO_FORMAT = {
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    pcm16: "audio/wav",
+    pcm: "audio/wav",
+    opus: "audio/opus",
+    aac: "audio/aac",
+    flac: "audio/flac",
+};
+const PROTOCOL_CONTENT_BLOCK_TYPES = new Set([
+    "text",
+    "reasoning",
+    "tool_call",
+    "tool_call_chunk",
+    "invalid_tool_call",
+    "server_tool_call",
+    "server_tool_call_chunk",
+    "server_tool_call_result",
+    "image",
+    "audio",
+    "video",
+    "file",
+    "non_standard",
+]);
+const normalizeAudioBlockFromAdditionalKwargs = (additionalKwargs) => {
+    const audio = isRecord(additionalKwargs?.audio)
+        ? additionalKwargs.audio
+        : undefined;
+    if (audio == null)
+        return undefined;
+    const data = typeof audio.data === "string" ? audio.data : undefined;
+    const url = typeof audio.url === "string" ? audio.url : undefined;
+    if (data == null && url == null)
+        return undefined;
+    const explicitMimeType = typeof audio.mime_type === "string"
+        ? audio.mime_type
+        : typeof audio.mimeType === "string"
+            ? audio.mimeType
+            : undefined;
+    const format = typeof audio.format === "string"
+        ? audio.format.toLowerCase()
+        : explicitMimeType != null
+            ? undefined
+            : "wav";
+    return {
+        type: "audio",
+        ...(typeof audio.id === "string" ? { id: audio.id } : {}),
+        ...(url != null ? { url } : {}),
+        ...(data != null ? { data } : {}),
+        ...(explicitMimeType != null
+            ? { mime_type: explicitMimeType }
+            : format != null && MIME_TYPE_BY_AUDIO_FORMAT[format] != null
+                ? { mime_type: MIME_TYPE_BY_AUDIO_FORMAT[format] }
+                : {}),
+        ...(typeof audio.transcript === "string"
+            ? { transcript: audio.transcript }
+            : {}),
+    };
+};
+const MEDIA_BLOCK_TYPES = new Set([
+    "image",
+    "audio",
+    "video",
+    "file",
+]);
+const MIME_TYPE_BY_IMAGE_FORMAT = {
+    png: "image/png",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+};
+/**
+ * Extracts OpenAI Responses API `image_generation_call` outputs from
+ * `additional_kwargs.tool_outputs` as protocol-shaped image blocks. These
+ * outputs carry base64 image payloads that do not appear in
+ * `message.content`, so we lift them into standard blocks for downstream
+ * consumers (including synthetic subagent emission on the public namespace).
+ *
+ * @param additionalKwargs - The message's `additional_kwargs` record.
+ * @returns An array of image blocks in the order they appear, or `[]`.
+ */
+const normalizeImageBlocksFromAdditionalKwargs = (additionalKwargs) => {
+    const toolOutputs = additionalKwargs?.tool_outputs;
+    if (!Array.isArray(toolOutputs))
+        return [];
+    const blocks = [];
+    for (const entry of toolOutputs) {
+        if (!isRecord(entry) || entry.type !== "image_generation_call")
+            continue;
+        const data = typeof entry.result === "string" ? entry.result : undefined;
+        const url = typeof entry.url === "string" ? entry.url : undefined;
+        if (data == null && url == null)
+            continue;
+        const outputFormat = typeof entry.output_format === "string"
+            ? entry.output_format.toLowerCase()
+            : undefined;
+        const mimeType = (outputFormat != null
+            ? MIME_TYPE_BY_IMAGE_FORMAT[outputFormat]
+            : undefined) ?? "image/png";
+        blocks.push({
+            type: "image",
+            ...(typeof entry.id === "string" ? { id: entry.id } : {}),
+            ...(url != null ? { url } : {}),
+            ...(data != null ? { data } : {}),
+            mime_type: mimeType,
+        });
+    }
+    return blocks;
+};
+/**
+ * Converts common camelCase field names produced by LangChain content blocks
+ * (e.g. `mimeType`) into the snake_case shape mandated by the protocol
+ * (`mime_type`). This keeps media blocks emitted by providers such as
+ * `ChatOpenAI` (Responses API `image_generation` tool) readable by downstream
+ * clients without requiring each provider to opt into protocol casing.
+ */
+const normalizeMediaBlockCasing = (block) => {
+    if (!MEDIA_BLOCK_TYPES.has(block.type))
+        return block;
+    const { mimeType, ...rest } = block;
+    if (typeof mimeType !== "string")
+        return block;
+    if (typeof rest.mime_type === "string")
+        return rest;
+    return { ...rest, mime_type: mimeType };
+};
+export const normalizeProtocolContentBlock = (value) => {
+    if (!isRecord(value) || typeof value.type !== "string")
+        return undefined;
+    if (PROTOCOL_CONTENT_BLOCK_TYPES.has(value.type)) {
+        return normalizeMediaBlockCasing(value);
+    }
+    if (value.type === "image_url") {
+        const rawImage = value.image_url;
+        if (typeof rawImage === "string") {
+            return { type: "image", url: rawImage };
+        }
+        if (isRecord(rawImage) && typeof rawImage.url === "string") {
+            return {
+                type: "image",
+                url: rawImage.url,
+            };
+        }
+        return undefined;
+    }
+    if (value.type === "input_audio") {
+        const rawAudio = isRecord(value.input_audio)
+            ? value.input_audio
+            : undefined;
+        if (rawAudio == null)
+            return undefined;
+        return {
+            type: "audio",
+            ...(typeof rawAudio.data === "string" ? { data: rawAudio.data } : {}),
+            ...(typeof rawAudio.mimeType === "string"
+                ? { mimeType: rawAudio.mimeType }
+                : {}),
+        };
+    }
+    return {
+        type: "non_standard",
+        value: { ...value },
+    };
+};
+export const normalizeProtocolMessageContent = (content, options) => {
+    const additionalKwargs = options?.additionalKwargs;
+    const extractExtras = () => {
+        const audioBlock = normalizeAudioBlockFromAdditionalKwargs(additionalKwargs);
+        const imageBlocks = normalizeImageBlocksFromAdditionalKwargs(additionalKwargs);
+        return { audioBlock, imageBlocks };
+    };
+    if (typeof content === "string") {
+        const { audioBlock, imageBlocks } = extractExtras();
+        if (audioBlock == null && imageBlocks.length === 0)
+            return content;
+        const blocks = [];
+        if (content.length > 0) {
+            blocks.push({ type: "text", text: content });
+        }
+        blocks.push(...imageBlocks);
+        if (audioBlock != null)
+            blocks.push(audioBlock);
+        return blocks;
+    }
+    if (!Array.isArray(content)) {
+        const { audioBlock, imageBlocks } = extractExtras();
+        if (audioBlock == null && imageBlocks.length === 0)
+            return content;
+        const blocks = [...imageBlocks];
+        if (audioBlock != null)
+            blocks.push(audioBlock);
+        return blocks;
+    }
+    const blocks = [];
+    for (const entry of content) {
+        if (typeof entry === "string") {
+            blocks.push({ type: "text", text: entry });
+            continue;
+        }
+        const normalized = normalizeProtocolContentBlock(entry);
+        if (normalized != null) {
+            blocks.push(normalized);
+        }
+    }
+    const { audioBlock, imageBlocks } = extractExtras();
+    for (const imageBlock of imageBlocks) {
+        const imageId = imageBlock.id;
+        const hasMatchingImage = blocks.some((block) => block.type === "image" &&
+            block.id === imageId &&
+            imageId != null);
+        if (!hasMatchingImage)
+            blocks.push(imageBlock);
+    }
+    if (audioBlock != null && !blocks.some((block) => block.type === "audio")) {
+        blocks.push(audioBlock);
+    }
+    return blocks.length > 0 ? blocks : content;
+};
+/**
+ * Normalizes protocol message type aliases into LangChain core message types.
+ *
+ * @param value - Raw message type.
+ * @returns The normalized message type, if recognized.
+ */
+export const normalizeProtocolStateMessageType = (value) => {
+    switch (value) {
+        case "assistant":
+            return "ai";
+        case "user":
+            return "human";
+        default:
+            return typeof value === "string" ? value : undefined;
+    }
+};
+/**
+ * Checks whether a value matches the message shape used in state payloads.
+ *
+ * @param value - Raw state value.
+ * @returns Whether the value is a protocol-state message object.
+ */
+export const isProtocolStateMessage = (value) => isRecord(value) &&
+    PROTOCOL_STATE_MESSAGE_TYPES.has(normalizeProtocolStateMessageType(value.type) ?? "");
+/**
+ * Normalizes invalid tool calls embedded in serialized AI messages.
+ *
+ * @param value - Raw invalid tool call list.
+ * @returns Normalized invalid tool calls.
+ */
+export const normalizeProtocolStateInvalidToolCalls = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    const invalidToolCalls = [];
+    for (const rawInvalidToolCall of value) {
+        if (!isRecord(rawInvalidToolCall))
+            continue;
+        const identity = getTupleToolCallIdentity(rawInvalidToolCall);
+        invalidToolCalls.push({
+            ...(identity.id != null ? { id: identity.id } : {}),
+            ...(identity.name != null ? { name: identity.name } : {}),
+            ...(typeof rawInvalidToolCall.args === "string"
+                ? { args: rawInvalidToolCall.args }
+                : {}),
+            error: typeof rawInvalidToolCall.error === "string"
+                ? rawInvalidToolCall.error
+                : "Malformed args.",
+            type: "invalid_tool_call",
+        });
+    }
+    return invalidToolCalls;
+};
+/**
+ * Normalizes tool calls embedded in serialized AI messages.
+ *
+ * @param value - Raw tool call list.
+ * @returns Normalized valid and invalid tool call arrays.
+ */
+export const normalizeProtocolStateToolCalls = (value) => {
+    if (!Array.isArray(value)) {
+        return {
+            toolCalls: [],
+            invalidToolCalls: [],
+        };
+    }
+    const toolCalls = [];
+    const invalidToolCalls = [];
+    for (const rawToolCall of value) {
+        if (!isRecord(rawToolCall))
+            continue;
+        const identity = getTupleToolCallIdentity(rawToolCall);
+        const rawArgs = getTupleToolCallArgs(rawToolCall);
+        const normalizedArgs = normalizeFinalToolCallArgs(rawArgs);
+        if (identity.name == null) {
+            invalidToolCalls.push({
+                ...(identity.id != null ? { id: identity.id } : {}),
+                ...(typeof rawArgs === "string" ? { args: rawArgs } : {}),
+                error: "Incomplete tool call.",
+                type: "invalid_tool_call",
+            });
+            continue;
+        }
+        if (!normalizedArgs.valid) {
+            invalidToolCalls.push({
+                ...(identity.id != null ? { id: identity.id } : {}),
+                name: identity.name,
+                ...(typeof normalizedArgs.args === "string"
+                    ? { args: normalizedArgs.args }
+                    : {}),
+                error: "Malformed args.",
+                type: "invalid_tool_call",
+            });
+            continue;
+        }
+        toolCalls.push({
+            ...(identity.id != null ? { id: identity.id } : {}),
+            name: identity.name,
+            args: normalizedArgs.args,
+            type: "tool_call",
+        });
+    }
+    return { toolCalls, invalidToolCalls };
+};
+/**
+ * Normalizes a single message embedded in protocol state payloads.
+ *
+ * @param value - Raw message object.
+ * @returns The normalized message shape.
+ */
+export const normalizeProtocolStateMessage = (value) => {
+    const type = normalizeProtocolStateMessageType(value.type);
+    if (type == null)
+        return value;
+    const additionalKwargs = isRecord(value.additional_kwargs)
+        ? value.additional_kwargs
+        : undefined;
+    const message = {
+        type,
+        content: normalizeProtocolMessageContent("content" in value ? value.content : "", {
+            additionalKwargs: type === "ai" ? additionalKwargs : undefined,
+        }),
+    };
+    if (typeof value.id === "string") {
+        message.id = value.id;
+    }
+    if (typeof value.name === "string") {
+        message.name = value.name;
+    }
+    if ((type === "ai" || type === "human") &&
+        typeof value.example === "boolean") {
+        message.example = value.example;
+    }
+    if (type === "tool") {
+        if (typeof value.tool_call_id === "string") {
+            message.tool_call_id = value.tool_call_id;
+        }
+        if (value.status === "success" || value.status === "error") {
+            message.status = value.status;
+        }
+        if ("artifact" in value) {
+            message.artifact = value.artifact;
+        }
+    }
+    if (type === "ai") {
+        const rawToolCalls = Array.isArray(value.tool_calls) && value.tool_calls.length > 0
+            ? value.tool_calls
+            : Array.isArray(additionalKwargs?.tool_calls)
+                ? additionalKwargs.tool_calls
+                : undefined;
+        const normalizedToolCalls = normalizeProtocolStateToolCalls(rawToolCalls);
+        const normalizedInvalidToolCalls = Array.isArray(value.invalid_tool_calls) &&
+            value.invalid_tool_calls.length > 0
+            ? normalizeProtocolStateInvalidToolCalls(value.invalid_tool_calls)
+            : normalizedToolCalls.invalidToolCalls;
+        if (normalizedToolCalls.toolCalls.length > 0) {
+            message.tool_calls = normalizedToolCalls.toolCalls;
+        }
+        if (normalizedInvalidToolCalls.length > 0) {
+            message.invalid_tool_calls = normalizedInvalidToolCalls;
+        }
+    }
+    return message;
+};
+/**
+ * Recursively normalizes protocol state payloads before they are emitted.
+ *
+ * @param value - Raw state payload.
+ * @returns The normalized state payload.
+ */
+export const normalizeProtocolStatePayload = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => isProtocolStateMessage(item)
+            ? normalizeProtocolStateMessage(item)
+            : normalizeProtocolStatePayload(item));
+    }
+    if (!isRecord(value))
+        return value;
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key === "__interrupt__") {
+            continue;
+        }
+        if (key === "messages" && Array.isArray(entry)) {
+            normalized[key] = entry.map((item) => isProtocolStateMessage(item)
+                ? normalizeProtocolStateMessage(item)
+                : item);
+            continue;
+        }
+        normalized[key] = normalizeProtocolStatePayload(entry);
+    }
+    return normalized;
+};
+/**
+ * Coerces arbitrary update payloads into the protocol values shape.
+ *
+ * @param value - Raw update payload.
+ * @returns A valid updates values payload.
+ */
+export const asUpdateValues = (value) => isRecord(value) ? value : { value };

package/dist/protocol/session/tool-calls.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Extracts the stable identity fields for a tuple tool call.
+ *
+ * @param value - Serialized tool call payload.
+ * @returns The resolved identifier and function name, when present.
+ */
+export declare const getTupleToolCallIdentity: (value: Record<string, unknown>) => {
+    id: string | undefined;
+    name: string | undefined;
+};
+/**
+ * Extracts the raw argument payload for a tuple tool call.
+ *
+ * @param value - Serialized tool call payload.
+ * @returns The raw arguments field, if present.
+ */
+export declare const getTupleToolCallArgs: (value: Record<string, unknown>) => unknown;
+/**
+ * Parses the final argument payload for a completed tool call.
+ *
+ * @param value - Raw tool call arguments.
+ * @returns The parsed arguments plus a validity flag.
+ */
+export declare const normalizeFinalToolCallArgs: (value: unknown) => {
+    valid: boolean;
+    args: unknown;
+};

package/dist/protocol/session/tool-calls.mjs

@@ -0,0 +1,59 @@
+import { isRecord } from "./internal-types.mjs";
+/**
+ * Extracts the stable identity fields for a tuple tool call.
+ *
+ * @param value - Serialized tool call payload.
+ * @returns The resolved identifier and function name, when present.
+ */
+export const getTupleToolCallIdentity = (value) => {
+    const nestedFunction = isRecord(value.function) ? value.function : undefined;
+    return {
+        id: typeof value.id === "string" ? value.id : undefined,
+        name: typeof value.name === "string"
+            ? value.name
+            : typeof nestedFunction?.name === "string"
+                ? nestedFunction.name
+                : undefined,
+    };
+};
+/**
+ * Extracts the raw argument payload for a tuple tool call.
+ *
+ * @param value - Serialized tool call payload.
+ * @returns The raw arguments field, if present.
+ */
+export const getTupleToolCallArgs = (value) => {
+    if ("args" in value)
+        return value.args;
+    const nestedFunction = isRecord(value.function) ? value.function : undefined;
+    return nestedFunction?.arguments;
+};
+/**
+ * Parses the final argument payload for a completed tool call.
+ *
+ * @param value - Raw tool call arguments.
+ * @returns The parsed arguments plus a validity flag.
+ */
+export const normalizeFinalToolCallArgs = (value) => {
+    if (isRecord(value)) {
+        return { valid: true, args: value };
+    }
+    if (typeof value === "string") {
+        if (value.length === 0) {
+            return { valid: true, args: {} };
+        }
+        try {
+            return {
+                valid: true,
+                args: JSON.parse(value),
+            };
+        }
+        catch {
+            return { valid: false, args: value };
+        }
+    }
+    if (value == null) {
+        return { valid: true, args: {} };
+    }
+    return { valid: true, args: value };
+};

package/dist/protocol/types.d.mts

@@ -0,0 +1,121 @@
+import type { AgentResult, AgentStatus, AgentTreeNode, Channel, Checkpoint, CheckpointSource, Command, CommandResponse, ContentBlockDeltaData, ContentBlockFinishData, ContentBlockStartData, CustomData, ErrorCode, ErrorResponse, Event, LifecycleCause, MessageErrorData, MessageFinishData, MessageMetadata, MessageStartData, MessagesData, Namespace, ResponseMeta, RunStartParams, RunResult, StateGetResult, SubscribeParams, SubscribeResult, ToolErrorData, ToolFinishedData, ToolOutputDeltaData, ToolStartedData, ToolsData, UnsubscribeParams, UpdatesEvent } from "@langchain/protocol";
+export type { LifecycleCause };
+import type { AuthContext } from "../auth/index.mjs";
+import type { RunProtocolSession } from "./session/index.mjs";
+/**
+ * Raw events emitted by the existing LangGraph run stream implementation
+ * before they are normalized into protocol-framed events.
+ *
+ * The session emits two independent events per persisted checkpoint:
+ * - `event: "values"` carries the full state snapshot on the `values`
+ *   protocol channel.
+ * - `event: "checkpoints"` carries the lightweight {@link Checkpoint}
+ *   envelope on the dedicated `checkpoints` channel, paired with the
+ *   adjacent `values` event by `(namespace, step)` so fork/time-travel
+ *   UIs can subscribe without also paying for full-state payloads.
+ *
+ * When {@link normalized} is `true` the payload has already been converted
+ * to its protocol shape by the in-process streaming layer
+ * (`streamEvents(..., { version: "v3" })`) and should be passed through
+ * without re-normalization.
+ */
+export type SourceStreamEvent = {
+    id?: string;
+    event: string;
+    data: unknown;
+    normalized?: boolean;
+};
+/**
+ * Transport profiles currently exposed by the LangGraph API implementation.
+ */
+export type ProtocolTransportName = "websocket" | "sse-http";
+export type SupportedChannel = Extract<Channel, "values" | "updates" | "checkpoints" | "messages" | "tools" | "custom" | "lifecycle" | "input" | "tasks">;
+export type EventMethodByChannel = {
+    values: "values";
+    updates: "updates";
+    checkpoints: "checkpoints";
+    messages: "messages";
+    tools: "tools";
+    custom: "custom";
+    lifecycle: "lifecycle";
+    input: "input.requested";
+    tasks: "tasks";
+};
+export type ProtocolResponseMeta = ResponseMeta;
+export type ProtocolSuccess = CommandResponse;
+export type ProtocolError = ErrorResponse;
+export type ProtocolEvent = Event;
+export type ProtocolCommand = Command;
+export type ProtocolCommandByMethod<Method extends ProtocolCommand["method"]> = Extract<ProtocolCommand, {
+    method: Method;
+}>;
+export type ProtocolEventByMethod<Method extends SupportedChannel> = Extract<ProtocolEvent, {
+    method: EventMethodByChannel[Method];
+}>;
+export type ProtocolEventDataByMethod<Method extends SupportedChannel> = ProtocolEventByMethod<Method>["params"]["data"];
+export type { AgentResult, AgentStatus, AgentTreeNode, Checkpoint, CheckpointSource, ContentBlockDeltaData, ContentBlockFinishData, ContentBlockStartData, CustomData, ErrorCode, MessageErrorData, MessageFinishData, MessageMetadata, MessagesData, MessageStartData, Namespace, RunStartParams, RunResult, StateGetResult, SubscribeParams, SubscribeResult, ToolErrorData, ToolFinishedData, ToolOutputDeltaData, ToolStartedData, ToolsData, UnsubscribeParams, UpdatesEvent, };
+/**
+ * Per-connection filter for SSE event sinks.
+ *
+ * Each SSE `POST .../events` connection carries its own filter so the server
+ * can deliver only matching events without persisting subscription state.
+ */
+export type EventSinkFilter = {
+    channels: Set<string>;
+    namespaces?: string[][];
+    depth?: number;
+    since?: number;
+};
+/**
+ * A single SSE event sink attached to a thread.
+ *
+ * `pendingReplay` is true while {@link ProtocolService.attachFilteredEventSink}
+ * is draining buffered events into this sink. While true, the live `send`
+ * callback must skip this sink so that the replay loop — not the live path —
+ * owns strict in-order delivery.
+ */
+export type EventSinkEntry = {
+    id: string;
+    filter: EventSinkFilter;
+    send: (message: ProtocolEvent) => Promise<void> | void;
+    pendingReplay?: boolean;
+};
+/**
+ * Runtime state tracked for an active thread connection.
+ *
+ * In the thread-centric protocol, threads are durable but ephemeral
+ * connection state lives here: the active run session, attached SSE
+ * sinks, and a queue of events waiting for a sink.
+ */
+export type ThreadRecord = {
+    threadId: string;
+    transport: ProtocolTransportName;
+    auth?: AuthContext;
+    assistantId?: string;
+    seq: number;
+    session?: RunProtocolSession;
+    currentRunId?: string;
+    /** WebSocket-only: single event delivery callback. */
+    sendEvent?: ((message: ProtocolEvent) => Promise<void> | void) | undefined;
+    /** SSE: per-connection filtered event sinks. */
+    eventSinks: Map<string, EventSinkEntry>;
+    /** Events buffered when no sink is attached yet. */
+    queuedEvents: ProtocolEvent[];
+    /** WebSocket-only: subscription commands replayed on new run sessions. */
+    activeSubscriptions: ProtocolCommand[];
+    /**
+     * WebSocket-only: subscribes that arrived before a run session was bound.
+     *
+     * The SDK opens its root-pump subscription (and legacy lifecycle/values
+     * subs) eagerly on thread creation so that no events are missed on fast
+     * runs. On WebSocket those subscribes can race ahead of the concurrent
+     * `run.start` and hit the service before `ensureRunSession` has bound a
+     * session. Rather than rejecting them with `no_such_run`, we park each
+     * command's response promise here and resolve it once the first session
+     * is bound — mirroring the cross-run `activeSubscriptions` replay path.
+     */
+    pendingSubscribes: Array<{
+        command: ProtocolCommand;
+        resolve: (response: ProtocolSuccess | ProtocolError | null) => void;
+    }>;
+};

package/dist/protocol/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/queue.mjs

@@ -54,8 +54,14 @@ const worker = async (ops, run, attempt, signal) => {
                 signal,
                 ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
             });
-            for await (const { event, data } of stream) {
-                await ops.runs.stream.publish({ runId, resumable, event, data });
+            for await (const { event, data, normalized } of stream) {
+                await ops.runs.stream.publish({
+                    runId,
+                    resumable,
+                    event,
+                    data,
+                    ...(normalized != null ? { normalized } : {}),
+                });
             }
         }
         catch (error) {