@ably/ai-transport 0.1.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

@@ -0,0 +1,50 @@
+import { Regenerate, ToolApprovalResponse, ToolResult, ToolResultError, UserMessage } from '../../core/codec/index.js';
+/**
+ * Vercel codec input/output unions.
+ *
+ * The codec splits cleanly along the protocol's `ai-input` / `ai-output`
+ * wire seam:
+ *
+ * - **`VercelOutput`** = `AI.UIMessageChunk` — the AI SDK's streamed-output
+ *   domain model, published by the agent on `ai-output`.
+ * - **`VercelInput`** = a discriminated union of the SDK's well-known
+ *   input shapes — published by the client on `ai-input`. The Vercel
+ *   codec has no codec-local input variants today: every variant comes
+ *   from `@ably/ai-transport`'s well-known set.
+ */
+import type * as AI from 'ai';
+/** Vercel domain payload for a {@link ToolResult}. */
+export interface VercelToolResultPayload {
+    /** The tool call this result corresponds to. */
+    toolCallId: string;
+    /** The tool's output value. Tool-defined shape. */
+    output: unknown;
+}
+/** Vercel domain payload for a {@link ToolResultError}. */
+export interface VercelToolResultErrorPayload {
+    /** The tool call this error corresponds to. */
+    toolCallId: string;
+    /** Human-readable description of the failure. */
+    message: string;
+}
+/** Vercel domain payload for a {@link ToolApprovalResponse}. */
+export interface VercelToolApprovalResponsePayload {
+    /** The tool call this approval responds to. */
+    toolCallId: string;
+    /** Whether the user approved the tool execution. */
+    approved: boolean;
+    /** Optional human-readable reason (typically used on denial). */
+    reason?: string;
+}
+/**
+ * The Vercel codec's `TInput` — every record-shape a client publishes on
+ * the `ai-input` wire. Composed from the SDK's well-known input shapes,
+ * with the tool variants parameterized by the Vercel domain payloads above.
+ */
+export type VercelInput = UserMessage<AI.UIMessage> | Regenerate | ToolResult<VercelToolResultPayload> | ToolResultError<VercelToolResultErrorPayload> | ToolApprovalResponse<VercelToolApprovalResponsePayload>;
+/**
+ * The Vercel codec's `TOutput` — every record-shape the agent publishes
+ * on the `ai-output` wire. The Vercel codec passes the AI SDK's
+ * `UIMessageChunk` through unchanged.
+ */
+export type VercelOutput = AI.UIMessageChunk;

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,22 +1,9 @@
-import { Codec } from '../../core/codec/types.js';
+import { VercelInput, VercelOutput } from './events.js';
 /**
- * Vercel AI SDK codec — maps UIMessageChunk events and UIMessage objects
- * to/from native Ably message primitives (publish, append, update, delete).
- *
- * ```ts
- * import { UIMessageCodec } from '@ably/ai-transport/vercel';
- *
- * const encoder = UIMessageCodec.createEncoder(writer, options);
- * const decoder = UIMessageCodec.createDecoder();
- * const accumulator = UIMessageCodec.createAccumulator();
- * ```
+ * Vercel AI SDK codec implementing
+ * `Codec<VercelInput, VercelOutput, VercelProjection, UIMessage>`. `VercelProjection`
+ * and `UIMessage` are inferred from the reducer.
  */
-import type * as AI from 'ai';
-/**
- * Vercel AI SDK codec implementing `Codec<UIMessageChunk, UIMessage>`.
- *
- * Provides factory methods for creating encoders, decoders, and accumulators
- * that map between Vercel's UIMessageChunk/UIMessage types and Ably's native
- * message primitives.
- */
-export declare const UIMessageCodec: Codec<AI.UIMessageChunk, AI.UIMessage>;
+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

@@ -0,0 +1,62 @@
+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.
+ *
+ * Pure `(init, fold)` over the `VercelInput | VercelOutput` union. Folds
+ * input variants (user-message, tool-result, tool-result-error,
+ * tool-approval-response) and `UIMessageChunk` outputs into a
+ * VercelProjection holding `UIMessage[]` plus internal stream-tracker
+ * state.
+ *
+ * The reducer is stateless: every fold is `(state, event, meta) → state'`,
+ * with no instance state. Mutation in place is allowed — the projection
+ * is single-owner.
+ *
+ * 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
+ * they amend; the reducer applies the resolution onto that assistant's
+ * `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.
+ *
+ * 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.
+ */
+import type * as AI from 'ai';
+/**
+ * Fold one input or output event into the projection. Mutates and returns
+ * `state`.
+ *
+ * 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: 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
+ * assistants in place via `kind: 'tool-result'` etc. — they never
+ * materialise as their own UIMessage in the projection, so no filtering is
+ * needed here.
+ * @param projection - Projection produced by `init` + repeated `fold` calls.
+ * @returns The visible messages with their codec-message-ids, in publication order.
+ */
+export declare const getMessages: (projection: VercelProjection) => CodecMessage<AI.UIMessage>[];
+export { init, type VercelProjection } from './reducer-state.js';

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

@@ -1,20 +1,14 @@
 /**
  * Shared tool part transition logic for the Vercel AI SDK codec.
  *
- * Extracted from the accumulator so the tool output state transition logic
- * lives in one place, reusable by the accumulator and any other callers.
+ * Keeps the tool output state transition logic in one place, reusable by the
+ * Vercel codec reducer and any other callers.
  */
 import type * as AI from 'ai';
 /** The set of UIMessageChunk types that represent tool output transitions. */
 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

@@ -1,6 +1,6 @@
+export type { VercelInput, VercelOutput, VercelProjection } from './codec/index.js';
 export { UIMessageCodec } from './codec/index.js';
-export type { ChatTransport, ChatTransportOptions, SendMessagesRequestContext, VercelClientTransportOptions, VercelServerTransportOptions, } from './transport/index.js';
-export { createChatTransport, createClientTransport, createServerTransport } from './transport/index.js';
-export { applyToolEventsToHistory } from './tool-events.js';
-export type { PrepareApprovalTurnOptions, PrepareApprovalTurnResult, StreamResponseWithApprovalRedirectOptions, ToolApprovalDecision, } from './tool-approvals.js';
-export { applyToolApprovalsToHistory, extractApprovalDecisionsFromHistory, prepareApprovalTurn, streamResponseWithApprovalRedirect, } from './tool-approvals.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';