@ably/ai-transport 0.2.0 → 0.3.0

package/dist/vercel/codec/decode-lifecycle.d.ts

@@ -0,0 +1,9 @@
+import { LifecyclePolicy } from '../../core/codec/index.js';
+import { VercelOutput } from './events.js';
+/**
+ * Build a fresh Vercel decode lifecycle policy (with its own tracker). Passed
+ * to `defineCodec` as the `decodeLifecycle` factory so each decoder instance
+ * gets independent per-run phase state.
+ * @returns A {@link LifecyclePolicy} for the Vercel output union.
+ */
+export declare const createVercelDecodeLifecycle: () => LifecyclePolicy<VercelOutput>;

package/dist/vercel/codec/events.d.ts

@@ -1,4 +1,4 @@
-import { Regenerate, ToolApprovalResponse, ToolResult, ToolResultError, UserMessage } from '../../core/codec/types.js';
+import { Regenerate, ToolApprovalResponse, ToolResult, ToolResultError, UserMessage } from '../../core/codec/index.js';
 /**
  * Vercel codec input/output unions.
  *
@@ -48,4 +48,3 @@ export type VercelInput = UserMessage<AI.UIMessage> | Regenerate | ToolResult<Ve
  * `UIMessageChunk` through unchanged.
  */
 export type VercelOutput = AI.UIMessageChunk;
-export type { VercelProjection } from './reducer.js';

package/dist/vercel/codec/fields.d.ts

@@ -0,0 +1,44 @@
+import { HeaderField } from '../../core/codec/index.js';
+/**
+ * Shared Vercel codec header-field bindings.
+ *
+ * Each field binds a codec header key to its value type once (see
+ * {@link HeaderField}); the output/input descriptors and escape hatches all
+ * read and write through these bindings, so a header key cannot drift between
+ * the encode and decode side. Domain field names live in the Vercel layer, not
+ * core, per the header-discipline rule.
+ */
+import type * as AI from 'ai';
+/** Stream / message id (text & reasoning streams). */
+export declare const fId: HeaderField<string | undefined, "id">;
+/**
+ * Provider metadata envelope, typed to the AI SDK shape. Annotated explicitly:
+ * the inferred type resolves to the AI SDK's internal `SharedV3ProviderMetadata`
+ * alias, which isn't portably nameable across the package boundary.
+ */
+export declare const fMeta: HeaderField<AI.ProviderMetadata | undefined, 'providerMetadata'>;
+/** Tool call id — defaulted to total: an absent header reads as `''`. */
+export declare const fToolCallId: HeaderField<string, "toolCallId">;
+/** Tool name — defaulted to total. */
+export declare const fToolName: HeaderField<string, "toolName">;
+/** Whether the tool is a dynamic tool. */
+export declare const fDynamic: HeaderField<boolean | undefined, "dynamic">;
+/** Optional human-readable title. */
+export declare const fTitle: HeaderField<string | undefined, "title">;
+/** Whether the provider executed the tool. */
+export declare const fProviderExecuted: HeaderField<boolean | undefined, "providerExecuted">;
+/** Media type for file / source-document parts — defaulted to total. */
+export declare const fMediaType: HeaderField<string, "mediaType">;
+/** Source id for source-url / source-document parts — defaulted to total. */
+export declare const fSourceId: HeaderField<string, "sourceId">;
+/** Domain message id (`message.id`) stamped on every user-message part — distinct from the wire codec-message-id transport header. */
+export declare const fMessageId: HeaderField<string | undefined, "messageId">;
+/** Whether the user approved a tool execution — defaulted to total so an absent header reads `false`. */
+export declare const fApproved: HeaderField<boolean, "approved">;
+/** Optional human-readable reason on a tool-approval response. */
+export declare const fReason: HeaderField<string | undefined, "reason">;
+/**
+ * Validated finish reason. Mirrors the AI SDK's `FinishReason` literals and
+ * falls back to `'stop'` for an absent or unrecognized value.
+ */
+export declare const fFinishReason: HeaderField<"error" | "length" | "stop" | "content-filter" | "tool-calls" | "other", "finishReason">;

package/dist/vercel/codec/fold-content.d.ts

@@ -0,0 +1,16 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * File and source content-part folds: file / source-url / source-document.
+ * These are independent attachments — each appends a part, never dedups.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a file or source content chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The file, source-url, or source-document chunk.
+ * @param messageId - The target codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldContentPart: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: "file" | "source-url" | "source-document";
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/fold-data.d.ts

@@ -0,0 +1,16 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * data-* part folds. Transient data parts are dropped; persistent ones are
+ * appended, or replaced in place when a matching `id` is already present.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a `data-*` chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The data-* chunk.
+ * @param messageId - The target codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldDataPart: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: `data-${string}`;
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/fold-input.d.ts

@@ -0,0 +1,67 @@
+import { ReducerMeta, ToolApprovalResponse, ToolResult, ToolResultError } from '../../core/codec/index.js';
+import { VercelToolApprovalResponsePayload, VercelToolResultErrorPayload, VercelToolResultPayload } from './events.js';
+import { VercelProjection } from './reducer-state.js';
+/**
+ * Client-published input folds and the pending-resolution buffering.
+ *
+ * Tool resolutions (`ToolResult`, `ToolResultError`, `ToolApprovalResponse`)
+ * carry a `codecMessageId` targeting the assistant they amend. When that
+ * assistant (or its tool part) has not yet arrived, the resolution is buffered
+ * in `pendingToolResolutions` and {@link retryPendingResolutions} re-evaluates
+ * it after every subsequent fold.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a user message into the projection, correlating on the wire
+ * codec-message-id (the caller's `message.id` is preserved verbatim). A
+ * multi-part user message fans out into one wire event per part, all sharing
+ * the codec-message-id — folding appends the incoming parts to the existing
+ * entry, reassembling the message part by part. The transport delivers each
+ * wire exactly once (its per-message version high-water-mark drops replays),
+ * so the merge sees every part once and stays consistent.
+ *
+ * Optimistic (serial-less) seeds need no special handling here: the transport
+ * refolds the node from its log when the echo's serial arrives, rebuilding the
+ * projection from a fresh `init` so the seed never coexists with its echo.
+ * @param state - Projection to fold into.
+ * @param message - The user message (or one decoded part of it) to add or merge.
+ * @param meta - Transport-derived metadata carrying the codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldUserMessage: (state: VercelProjection, message: AI.UIMessage, meta: ReducerMeta) => VercelProjection;
+/**
+ * Fold a client-published `ToolResult`. The input carries
+ * `codecMessageId` pointing at the assistant whose `dynamic-tool` part
+ * holds the matching `toolCallId`. If the assistant and its matching
+ * `dynamic-tool` part are both present, fold directly; otherwise pend
+ * until that tool part arrives.
+ * @param state - Projection to fold into.
+ * @param event - The tool-result input (codecMessageId + domain payload).
+ * @returns The same projection reference.
+ */
+export declare const foldClientToolResult: (state: VercelProjection, event: ToolResult<VercelToolResultPayload>) => VercelProjection;
+/**
+ * Fold a client-published `ToolResultError`. Mirrors
+ * {@link foldClientToolResult} but with the error transition.
+ * @param state - Projection to fold into.
+ * @param event - The tool-result-error input (codecMessageId + domain payload).
+ * @returns The same projection reference.
+ */
+export declare const foldClientToolResultError: (state: VercelProjection, event: ToolResultError<VercelToolResultErrorPayload>) => VercelProjection;
+/**
+ * Fold a client-published `ToolApprovalResponse`. The input carries
+ * `codecMessageId` pointing at the assistant whose `dynamic-tool` part
+ * holds the matching `toolCallId`. Approval → `approval-responded`;
+ * denial → `output-denied` via {@link transitionToolPart}.
+ * @param state - Projection to fold into.
+ * @param event - The approval-response input.
+ * @returns The same projection reference.
+ */
+export declare const foldToolApprovalResponse: (state: VercelProjection, event: ToolApprovalResponse<VercelToolApprovalResponsePayload>) => VercelProjection;
+/**
+ * Re-attempt every pending tool resolution against the current projection.
+ * Successfully promoted entries are removed from the pending list. Cheap:
+ * bounded by the number of pending entries.
+ * @param state - Projection to walk and mutate.
+ */
+export declare const retryPendingResolutions: (state: VercelProjection) => void;

package/dist/vercel/codec/fold-lifecycle.d.ts

@@ -0,0 +1,16 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * Lifecycle chunk folds: start, start-step, finish-step, finish, abort,
+ * error, message-metadata.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a message-lifecycle chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The lifecycle chunk.
+ * @param messageId - The target codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldLifecycle: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: "start" | "start-step" | "finish-step" | "finish" | "abort" | "error" | "message-metadata";
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/fold-text.d.ts

@@ -0,0 +1,16 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * Text and reasoning streaming folds: the {start, delta, end} lifecycle for
+ * both `text-*` and `reasoning-*` chunks, which share the same shape.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a text or reasoning streaming chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The text/reasoning start, delta, or end chunk.
+ * @param messageId - The target codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldTextOrReasoning: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: "text-start" | "text-delta" | "text-end" | "reasoning-start" | "reasoning-delta" | "reasoning-end";
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/fold-tool-input.d.ts

@@ -0,0 +1,17 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * Tool-input streaming folds: tool-input-start / -delta / -available / -error.
+ * Tool deltas arrive as raw JSON fragments accumulated in the tracker's
+ * `inputText` buffer and parsed on each delta.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold a tool-input streaming chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The tool-input start, delta, available, or error chunk.
+ * @param messageId - The target codec-message-id.
+ * @returns The same projection reference.
+ */
+export declare const foldToolInput: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: "tool-input-start" | "tool-input-delta" | "tool-input-available" | "tool-input-error";
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/fold-tool-output.d.ts

@@ -0,0 +1,16 @@
+import { VercelProjection } from './reducer-state.js';
+/**
+ * Agent-published tool-output transitions: tool-output-available /
+ * tool-output-error / tool-output-denied / tool-approval-request.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold an agent-published tool-output chunk into the projection.
+ * @param state - Projection to fold into.
+ * @param chunk - The tool-output-available/-error/-denied or tool-approval-request chunk.
+ * @param messageId - The target codec-message-id (used for the approval-request / denied paths).
+ * @returns The same projection reference.
+ */
+export declare const foldToolOutput: (state: VercelProjection, chunk: Extract<AI.UIMessageChunk, {
+    type: "tool-output-available" | "tool-output-error" | "tool-output-denied" | "tool-approval-request";
+}>, messageId: string) => VercelProjection;

package/dist/vercel/codec/index.d.ts

@@ -1,34 +1,9 @@
-import { VercelInput, VercelOutput, VercelToolApprovalResponsePayload, VercelToolResultErrorPayload, VercelToolResultPayload } from './events.js';
-import { VercelProjection } from './reducer.js';
+import { VercelInput, VercelOutput } from './events.js';
 /**
- * Vercel AI SDK codec — implements
- * `Codec<VercelInput, VercelOutput, VercelProjection, UIMessage>`.
- *
- * The codec is the reducer (extends `Reducer<VercelInput | VercelOutput,
- * VercelProjection>`) plus encoder/decoder factories and `getMessages`
- * for Tree population.
- *
- * ```ts
- * import { UIMessageCodec } from '@ably/ai-transport/vercel';
- *
- * const encoder = UIMessageCodec.createEncoder(writer, options);
- * const decoder = UIMessageCodec.createDecoder();
- * const projection = UIMessageCodec.init();
- * ```
+ * Vercel AI SDK codec implementing
+ * `Codec<VercelInput, VercelOutput, VercelProjection, UIMessage>`. `VercelProjection`
+ * and `UIMessage` are inferred from the reducer.
  */
-import type * as AI from 'ai';
-export declare const UIMessageCodec: {
-    adapterTag: "vercel-ai-sdk-ui-message";
-    init: () => VercelProjection;
-    fold: (state: VercelProjection, event: VercelInput | VercelOutput, meta: import('../../core/codec/types.js').ReducerMeta) => VercelProjection;
-    createEncoder: (writer: import('../../core/codec/types.js').ChannelWriter, options?: import('../../index.js').EncoderCoreOptions) => import('../../core/codec/types.js').Encoder<VercelInput, VercelOutput>;
-    createDecoder: (options?: import('../../index.js').DecoderCoreOptions) => import('../../core/codec/types.js').Decoder<VercelInput, VercelOutput>;
-    getMessages: (projection: VercelProjection) => import('../../core/codec/types.js').CodecMessage<AI.UIMessage>[];
-    createUserMessage: (message: AI.UIMessage) => VercelInput;
-    createRegenerate: (target: string, parent: string) => VercelInput;
-    createToolResult: (codecMessageId: string, payload: VercelToolResultPayload) => VercelInput;
-    createToolResultError: (codecMessageId: string, payload: VercelToolResultErrorPayload) => VercelInput;
-    createToolApprovalResponse: (codecMessageId: string, payload: VercelToolApprovalResponsePayload) => VercelInput;
-};
+export declare const UIMessageCodec: import('../../core/codec/define-codec.js').DefinedCodec<VercelInput, VercelOutput, import('./reducer-state.js').VercelProjection, import('ai').UIMessage<unknown, import('ai').UIDataTypes, import('ai').UITools>>;
 export type { VercelInput, VercelOutput } from './events.js';
 export { type VercelProjection } from './reducer.js';

package/dist/vercel/codec/inputs.d.ts

@@ -0,0 +1,11 @@
+import { InputBuilder, InputDescriptor } from '../../core/codec/index.js';
+import { VercelInput } from './events.js';
+/**
+ * The Vercel codec's `ai-input` descriptors, built from the injected
+ * direction-scoped builder.
+ * @param builder - The `{ event, batch }` builder curried on `VercelInput`.
+ * @param builder.event - Define a single-event input (payload-nested, or `wireOnly`).
+ * @param builder.batch - Define a multi-part (batch) input that fans out into one wire event per part.
+ * @returns The input descriptor table the generic input drivers consume.
+ */
+export declare const inputs: ({ event, batch }: InputBuilder<VercelInput>) => readonly InputDescriptor<VercelInput>[];

package/dist/vercel/codec/outputs.d.ts

@@ -0,0 +1,11 @@
+import { OutputBuilder, OutputDescriptor } from '../../core/codec/index.js';
+import { VercelOutput } from './events.js';
+/**
+ * The Vercel codec's `ai-output` descriptors, built from the injected
+ * direction-scoped builder.
+ * @param builder - The `{ event, stream }` builder curried on `VercelOutput`.
+ * @param builder.event - Define a single discrete output event.
+ * @param builder.stream - Define a streamed output family (start / delta / end).
+ * @returns The output descriptor table the generic output drivers consume.
+ */
+export declare const outputs: ({ event, stream }: OutputBuilder<VercelOutput>) => readonly OutputDescriptor<VercelOutput>[];

package/dist/vercel/codec/reducer-state.d.ts

@@ -0,0 +1,121 @@
+import { CodecMessage } from '../../core/codec/index.js';
+/**
+ * Shared reducer state: the projection shape, its internal tracker types,
+ * `init`, and the message/tracker lookup helpers the per-concern fold modules
+ * build on. This module is the base of the reducer's import DAG — the fold
+ * modules depend on it; it depends on none of them.
+ */
+import type * as AI from 'ai';
+/**
+ * Tracks an in-progress tool part within a UIMessage. Text and reasoning
+ * parts don't need this — we write to them directly via partIndex. Tool
+ * parts need an extra `inputText` buffer because deltas arrive as raw
+ * JSON fragments that must be accumulated before parsing.
+ */
+export interface ToolPartTracker {
+    /** Index in the message's parts array. */
+    partIndex: number;
+    /** Accumulated streaming input text (for JSON parsing on completion). */
+    inputText: string;
+}
+/** Per-codecMessageId tracking state for in-progress streams within a UIMessage. */
+export interface MessageTrackers {
+    /** Text stream id → partIndex. */
+    text: Map<string, number>;
+    /** Reasoning stream id → partIndex. */
+    reasoning: Map<string, number>;
+    /** Tool call id → tracker. */
+    tools: Map<string, ToolPartTracker>;
+}
+/**
+ * The per-Run state produced by the Vercel codec's reducer.
+ *
+ * The SDK reads only `messages` (via `Codec.getMessages`). The remaining
+ * fields are internal to the reducer; they happen to live on the
+ * projection because the projection is the only thing the reducer can
+ * carry from fold to fold (it has no instance state).
+ */
+export interface VercelProjection {
+    /**
+     * UIMessages produced or modified in this Run, in publication order,
+     * each paired with its codec-message-id. The reducer correlates strictly
+     * on `codecMessageId`; `message.id` is preserved verbatim from the source
+     * (the AI SDK stream's `start.messageId` for assistants, the caller's id
+     * for user messages) and is never used as an identity key.
+     */
+    messages: CodecMessage<AI.UIMessage>[];
+    /** Per-codecMessageId tracker state for streamed parts. Internal — do not access. */
+    trackers: Map<string, MessageTrackers>;
+    /**
+     * Tool-resolution events that arrived before any assistant in this
+     * projection had a matching `toolCallId`. Re-evaluated on every
+     * subsequent fold so that an out-of-order tool output is folded as
+     * soon as the corresponding assistant lands.
+     */
+    pendingToolResolutions: PendingToolResolution[];
+}
+/**
+ * A buffered tool resolution waiting for its assistant message to arrive.
+ * The reducer scans pending entries after every successful fold so an
+ * out-of-order tool output is promoted as soon as the matching assistant
+ * is added to the projection.
+ */
+export interface PendingToolResolution {
+    /** The codec-message-id of the assistant the resolution targets. */
+    targetCodecMessageId: string;
+    /** Tool call this resolution targets. */
+    toolCallId: string;
+    /** Variant of the tool-resolution used to transition the assistant's tool part. */
+    resolution: {
+        kind: 'tool-result';
+        output: unknown;
+    } | {
+        kind: 'tool-result-error';
+        message: string;
+    } | {
+        kind: 'tool-approval-response';
+        approved: boolean;
+        reason?: string;
+    };
+}
+/** A located `dynamic-tool` part with its owning message and tracker. */
+export interface OwnerLookup {
+    /** The message owning the tool part. */
+    message: AI.UIMessage;
+    /** The tracker pointing at the part's index. */
+    tracker: ToolPartTracker;
+    /** The resolved `dynamic-tool` part itself. */
+    part: AI.DynamicToolUIPart;
+}
+/**
+ * Build an empty initial projection.
+ * @returns A fresh VercelProjection with no messages and no tracker state.
+ */
+export declare const init: () => VercelProjection;
+/**
+ * Resolve the assistant message for a codec-message-id, creating an empty
+ * placeholder when none exists yet.
+ * @param state - Projection to read or extend.
+ * @param codecMessageId - The codec-message-id to resolve.
+ * @returns The existing or newly-seeded UIMessage for that id.
+ */
+export declare const ensureMessage: (state: VercelProjection, codecMessageId: string) => AI.UIMessage;
+/**
+ * Resolve the stream trackers for a codec-message-id, creating empty maps
+ * when none exist yet.
+ * @param state - Projection to read or extend.
+ * @param messageId - The codec-message-id whose trackers to resolve.
+ * @returns The existing or newly-created tracker maps for that id.
+ */
+export declare const ensureTrackers: (state: VercelProjection, messageId: string) => MessageTrackers;
+/**
+ * Resolve the `dynamic-tool` part tracked for a toolCallId within a message.
+ * @param message - The message whose parts to read.
+ * @param trackers - The message's tracker maps.
+ * @param toolCallId - The tool call to resolve.
+ * @returns The tracker and part, or `undefined` if untracked or the part is not a dynamic-tool.
+ */
+export declare const getToolPart: (message: AI.UIMessage, trackers: MessageTrackers, toolCallId: string) => {
+    tracker: ToolPartTracker;
+    part: AI.DynamicToolUIPart;
+} | undefined;

package/dist/vercel/codec/reducer.d.ts

@@ -1,5 +1,6 @@
-import { CodecMessage, ReducerMeta } from '../../core/codec/types.js';
+import { CodecEvent, CodecMessage, ReducerMeta } from '../../core/codec/index.js';
 import { VercelInput, VercelOutput } from './events.js';
+import { VercelProjection } from './reducer-state.js';
 /**
  * Vercel AI SDK reducer.
  *
@@ -13,11 +14,12 @@ import { VercelInput, VercelOutput } from './events.js';
  * with no instance state. Mutation in place is allowed — the projection
  * is single-owner.
  *
- * Idempotency is **per conflict key**, not stream-wide: when two events
- * compete for the same logical state (e.g. two `tool-output-available`
- * for the same `toolCallId`), the higher-serial one wins and the other
- * is dropped. Unrelated events arrive freely in any order. See
- * `_conflictKeyOf` for the per-variant key derivation.
+ * The reducer does not dedup or reorder. The transport sequences events
+ * canonically — ascending by wire serial across messages, in decode order
+ * within a wire — and delivers each exactly once, so the reducer folds
+ * unconditionally. Last-writer-wins for events competing over the same
+ * logical state (e.g. two `tool-output-available` for one `toolCallId`)
+ * falls out of fold order: the highest-serial event folds last.
  *
  * Client-published tool resolutions (`ToolResult`, `ToolResultError`,
  * `ToolApprovalResponse`) carry `codecMessageId` targeting the assistant
@@ -25,112 +27,28 @@ import { VercelInput, VercelOutput } from './events.js';
  * `dynamic-tool` part directly. If the assistant has not yet arrived in
  * the projection (out-of-order delivery), the resolution is buffered in
  * `pendingToolResolutions` and re-evaluated on each subsequent fold.
- */
-import type * as AI from 'ai';
-/**
- * Tracks an in-progress tool part within a UIMessage. Text and reasoning
- * parts don't need this — we write to them directly via partIndex. Tool
- * parts need an extra `inputText` buffer because deltas arrive as raw
- * JSON fragments that must be accumulated before parsing.
- */
-interface ToolPartTracker {
-    /** Index in the message's parts array. */
-    partIndex: number;
-    /** Accumulated streaming input text (for JSON parsing on completion). */
-    inputText: string;
-}
-/** Per-codecMessageId tracking state for in-progress streams within a UIMessage. */
-interface MessageTrackers {
-    /** Text stream id → partIndex. */
-    text: Map<string, number>;
-    /** Reasoning stream id → partIndex. */
-    reasoning: Map<string, number>;
-    /** Tool call id → tracker. */
-    tools: Map<string, ToolPartTracker>;
-}
-/**
- * The per-Run state produced by the Vercel codec's reducer.
  *
- * The SDK reads only `messages` (via `Codec.getMessages`). The remaining
- * fields are internal to the reducer; they happen to live on the
- * projection because the projection is the only thing the reducer can
- * carry from fold to fold (it has no instance state).
+ * This file is the reducer's public facade and dispatch: `init`,
+ * `getMessages`, `fold`, and the output-chunk router. The per-concern fold
+ * logic lives in the sibling `fold-*` modules over a shared `reducer-state`
+ * base; the import graph is an acyclic DAG rooted here.
  */
-export interface VercelProjection {
-    /**
-     * UIMessages produced or modified in this Run, in publication order,
-     * each paired with its codec-message-id. The reducer correlates strictly
-     * on `codecMessageId`; `message.id` is preserved verbatim from the source
-     * (the AI SDK stream's `start.messageId` for assistants, the caller's id
-     * for user messages) and is never used as an identity key.
-     */
-    messages: CodecMessage<AI.UIMessage>[];
-    /**
-     * Per-conflict-key high-water-marks. Maps a codec-derived conflict key
-     * (see `_conflictKeyOf`) to the highest `meta.serial` already folded for
-     * that key. Events whose serial is `<=` the stored value are dropped as
-     * duplicates of an already-incorporated operation. Events that have no
-     * conflict key (additive content, lifecycle markers) are folded
-     * unconditionally.
-     */
-    conflictSerials: Map<string, string>;
-    /** Per-codecMessageId tracker state for streamed parts. Internal — do not access. */
-    trackers: Map<string, MessageTrackers>;
-    /**
-     * Tool-resolution events that arrived before any assistant in this
-     * projection had a matching `toolCallId`. Re-evaluated on every
-     * subsequent fold so that an out-of-order tool output is folded as
-     * soon as the corresponding assistant lands.
-     */
-    pendingToolResolutions: PendingToolResolution[];
-}
-/**
- * A buffered tool resolution waiting for its assistant message to arrive.
- * The reducer scans pending entries after every successful fold so an
- * out-of-order tool output is promoted as soon as the matching assistant
- * is added to the projection.
- */
-interface PendingToolResolution {
-    /** The codec-message-id of the assistant the resolution targets. */
-    targetCodecMessageId: string;
-    /** Tool call this resolution targets. */
-    toolCallId: string;
-    /** Serial of the wire message — used by the conflict-key check on promotion. */
-    serial: string;
-    /** Variant of the tool-resolution used to transition the assistant's tool part. */
-    resolution: {
-        kind: 'tool-result';
-        output: unknown;
-    } | {
-        kind: 'tool-result-error';
-        message: string;
-    } | {
-        kind: 'tool-approval-response';
-        approved: boolean;
-        reason?: string;
-    };
-}
-/**
- * Build an empty initial projection.
- * @returns A fresh VercelProjection with no messages and no tracker state.
- */
-export declare const init: () => VercelProjection;
+import type * as AI from 'ai';
 /**
  * Fold one input or output event into the projection. Mutates and returns
  * `state`.
  *
- * Idempotency is per conflict key (see `_conflictKeyOf`): if the event has
- * a conflict key and the projection has already folded an event for that
- * key at a higher-or-equal serial, this call is a no-op. Events without a
- * conflict key (additive content, lifecycle markers) are folded
- * unconditionally. Orphan events (e.g. tool-output for an unknown
- * toolCallId) are dropped silently inside the per-variant fold helpers.
+ * The transport invokes `fold` exactly once per event, in canonical order,
+ * so the reducer folds unconditionally — no dedup or high-water-mark here.
+ * Competing events resolve by order (the highest-serial event folds last
+ * and wins). Orphan events (e.g. tool-output for an unknown toolCallId) are
+ * dropped silently inside the per-variant fold helpers.
  * @param state - Projection to fold into (may be mutated in place).
  * @param event - Input or output event to fold.
  * @param meta - Transport-derived metadata (serial, optional messageId).
  * @returns The same projection reference, possibly mutated.
  */
-export declare const fold: (state: VercelProjection, event: VercelInput | VercelOutput, meta: ReducerMeta) => VercelProjection;
+export declare const fold: (state: VercelProjection, event: CodecEvent<VercelInput, VercelOutput>, meta: ReducerMeta) => VercelProjection;
 /**
  * Extract the UIMessage list from a projection, each paired with its
  * codec-message-id. Client-published tool resolutions amend existing
@@ -141,4 +59,4 @@ export declare const fold: (state: VercelProjection, event: VercelInput | Vercel
  * @returns The visible messages with their codec-message-ids, in publication order.
  */
 export declare const getMessages: (projection: VercelProjection) => CodecMessage<AI.UIMessage>[];
-export {};
+export { init, type VercelProjection } from './reducer-state.js';

package/dist/vercel/codec/tool-transitions.d.ts

@@ -9,12 +9,6 @@ import type * as AI from 'ai';
 export type ToolOutputChunk = Extract<AI.UIMessageChunk, {
     type: 'tool-output-available' | 'tool-output-error' | 'tool-output-denied' | 'tool-approval-request';
 }>;
-/**
- * Whether a UIMessageChunk is a tool output transition event.
- * @param chunk - The chunk to test.
- * @returns True if the chunk is a tool output transition type.
- */
-export declare const isToolOutputChunk: (chunk: AI.UIMessageChunk) => chunk is ToolOutputChunk;
 /** Fields shared by all DynamicToolUIPart state variants. */
 interface ToolBaseFields {
     type: 'dynamic-tool';

package/dist/vercel/codec/wire-data.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Wire-data shapes and runtime guards for the tool payloads whose `data`
+ * envelope is JSON-parsed from the network (a trust boundary). The guards
+ * validate the typed envelope fields; tool-defined `output`/`input` stay
+ * unconstrained. Shared by the output and input descriptor tables.
+ */
+/** Wire format for the agent-side `tool-input-error` chunk data payload. */
+export interface ToolInputErrorWireData {
+    errorText?: string;
+    input?: unknown;
+}
+/** Wire format for the `tool-output-available` (agent) / `tool-result` (client) data payload. */
+export interface ToolOutputAvailableWireData {
+    output?: unknown;
+}
+/** Wire format for the agent-side `tool-output-error` chunk data payload. */
+export interface AgentToolOutputErrorWireData {
+    errorText?: string;
+}
+/** Wire format for the client-side `tool-result-error` input data payload. */
+export interface ClientToolResultErrorWireData {
+    message?: string;
+}
+/**
+ * Coerce wire `data` to a string, falling back to `''` for any non-string
+ * payload — the defensive read for descriptors whose data is plain text.
+ * @param data - The inbound wire data.
+ * @returns The string payload, or `''` when the data is not a string.
+ */
+export declare const asString: (data: unknown) => string;
+export declare const isToolInputErrorWireData: (data: unknown) => data is ToolInputErrorWireData;
+export declare const isToolOutputAvailableWireData: (data: unknown) => data is ToolOutputAvailableWireData;
+export declare const isAgentToolOutputErrorWireData: (data: unknown) => data is AgentToolOutputErrorWireData;
+export declare const isClientToolResultErrorWireData: (data: unknown) => data is ClientToolResultErrorWireData;

package/dist/vercel/index.d.ts

@@ -2,4 +2,5 @@ export type { VercelInput, VercelOutput, VercelProjection } from './codec/index.
 export { UIMessageCodec } from './codec/index.js';
 export type { ChatTransport, ChatTransportOptions, SendMessagesRequestContext, VercelAgentSessionOptions, VercelClientSessionOptions, } from './transport/index.js';
 export { createAgentSession, createChatTransport, createClientSession } from './transport/index.js';
+export type { VercelRunOutcome } from './run-end-reason.js';
 export { vercelRunOutcome } from './run-end-reason.js';