@ably/ai-transport 0.2.0 → 0.3.0

package/src/utils.ts

@@ -6,7 +6,25 @@
  * the other.
  */
 
-import type * as Ably from 'ably';
+import * as Ably from 'ably';
+
+/**
+ * Extract a human-readable message from an unknown thrown value.
+ * @param error - The thrown value.
+ * @returns The error's `message` when it is an `Error`, otherwise its string form.
+ */
+export const errorMessage = (error: unknown): string => (error instanceof Error ? error.message : String(error));
+
+/**
+ * Narrow an unknown thrown value to an `Ably.ErrorInfo` for use as a wrapping
+ * `cause`, returning `undefined` when it is not one. Pass the result as the
+ * fourth argument to the `Ably.ErrorInfo` constructor to preserve the error
+ * chain without asserting a type the value may not have.
+ * @param error - The thrown value.
+ * @returns The value when it is an `Ably.ErrorInfo`, otherwise `undefined`.
+ */
+export const errorCause = (error: unknown): Ably.ErrorInfo | undefined =>
+  error instanceof Ably.ErrorInfo ? error : undefined;
 
 /**
  * Read one tier of the SDK's `extras.ai` namespace from an Ably message.
@@ -65,20 +83,19 @@ export const parseJson = (value: string | undefined): unknown => {
 };
 
 /**
- * Set a header value if defined, skipping undefined and null. Strings are set directly,
- * booleans and numbers are stringified, objects are JSON-serialized.
- * @param headers - The headers object to mutate.
- * @param key - The header key.
- * @param value - The value to set.
+ * Parse a string as JSON, falling back to the raw string when it isn't valid
+ * JSON. An empty string yields `undefined`. Used for accumulated stream text
+ * whose payload may be JSON or a plain string.
+ * @param value - The string to parse.
+ * @returns The parsed value, the raw string on parse failure, or undefined if empty.
  */
-export const setIfPresent = (headers: Record<string, string>, key: string, value: unknown): void => {
-  if (value === undefined || value === null) return;
-  if (typeof value === 'string') {
-    headers[key] = value;
-  } else if (typeof value === 'boolean' || typeof value === 'number') {
-    headers[key] = String(value);
-  } else if (typeof value === 'object') {
-    headers[key] = JSON.stringify(value);
+export const parseJsonOrString = (value: string): unknown => {
+  if (!value) return undefined;
+  try {
+    // CAST: JSON.parse returns any; unknown is the safe trust-boundary type.
+    return JSON.parse(value) as unknown;
+  } catch {
+    return value;
   }
 };
 
@@ -130,14 +147,6 @@ export const compareBySerial = (a: HasSerial, b: HasSerial): number => {
   return 0;
 };
 
-/**
- * Read a domain header value from a codec-tier headers record.
- * @param headers - The codec headers record to read from.
- * @param key - The domain key (e.g. `'toolCallId'`).
- * @returns The header value, or undefined if absent.
- */
-export const getDomainHeader = (headers: Record<string, string>, key: string): string | undefined => headers[key];
-
 /**
  * Mapped type that converts properties whose type includes `undefined`
  * into optional properties with `undefined` excluded from the value.
@@ -171,78 +180,3 @@ export const stripUndefined = <T extends Record<string, unknown>>(obj: T): Strip
   // required keys are always present, optional keys are absent when undefined.
   return result as Stripped<T>;
 };
-
-// ---------------------------------------------------------------------------
-// DomainHeaderReader — typed accessors for domain headers
-// ---------------------------------------------------------------------------
-
-/**
- * Typed accessor wrapper around a headers record for reading domain headers.
- * Reduces repetitive `getDomainHeader` + `parseBool` / `parseJson` chains.
- */
-export interface DomainHeaderReader {
-  /** Read a domain header as a string, or undefined if absent. */
-  str(key: string): string | undefined;
-  /** Read a domain header as a string, falling back to a default if absent. */
-  strOr(key: string, fallback: string): string;
-  /** Read a domain header as a boolean: `true` only for the exact string "true", `false` for any other present value, or undefined if absent. */
-  bool(key: string): boolean | undefined;
-  /** Read a domain header as parsed JSON, or undefined if absent or invalid. */
-  json(key: string): unknown;
-}
-
-/**
- * Create a {@link DomainHeaderReader} over a headers record.
- * @param headers - The raw headers record to read domain headers from.
- * @returns A typed accessor for domain header values.
- */
-export const headerReader = (headers: Record<string, string>): DomainHeaderReader => ({
-  str: (key: string) => getDomainHeader(headers, key),
-  strOr: (key: string, fallback: string) => getDomainHeader(headers, key) ?? fallback,
-  bool: (key: string) => parseBool(getDomainHeader(headers, key)),
-  json: (key: string) => parseJson(getDomainHeader(headers, key)),
-});
-
-// ---------------------------------------------------------------------------
-// DomainHeaderWriter — typed builder for domain headers
-// ---------------------------------------------------------------------------
-
-/**
- * Fluent builder for constructing domain header records with typed setters.
- * Mirrors {@link DomainHeaderReader} with the same method names for symmetry.
- * Undefined values are silently skipped on all setters.
- */
-export interface DomainHeaderWriter {
-  /** Set a string domain header. Skips if value is undefined. */
-  str(key: string, value: string | undefined): DomainHeaderWriter;
-  /** Set a boolean domain header (serialized as "true"/"false"). Skips if value is undefined. */
-  bool(key: string, value: boolean | undefined): DomainHeaderWriter;
-  /** Set a JSON-serialized domain header. Skips if value is undefined or null. */
-  json(key: string, value: unknown): DomainHeaderWriter;
-  /** Return the accumulated headers record. */
-  build(): Record<string, string>;
-}
-
-/**
- * Create a {@link DomainHeaderWriter} for building a codec-tier headers record.
- * @returns A fluent builder that accumulates codec headers under their bare keys.
- */
-export const headerWriter = (): DomainHeaderWriter => {
-  const h: Record<string, string> = {};
-  const writer: DomainHeaderWriter = {
-    str: (key: string, value: string | undefined) => {
-      if (value !== undefined) h[key] = value;
-      return writer;
-    },
-    bool: (key: string, value: boolean | undefined) => {
-      if (value !== undefined) h[key] = String(value);
-      return writer;
-    },
-    json: (key: string, value: unknown) => {
-      if (value !== undefined && value !== null) h[key] = JSON.stringify(value);
-      return writer;
-    },
-    build: () => h,
-  };
-  return writer;
-};

package/src/vercel/codec/decode-lifecycle.ts

@@ -0,0 +1,70 @@
+/**
+ * Vercel decode lifecycle policy — mid-stream-join repair.
+ *
+ * When a client joins a stream mid-flight (history compaction, rewind miss,
+ * partial page), the reducer must still see a clean `start` / `start-step`
+ * pre-roll. This policy keys that repair on the discrete codec `kind` and on
+ * stream start; each entry performs its tracker side effect and returns the
+ * lead-in chunks the generic decoder prepends before running the descriptor
+ * driver. A fresh policy (and tracker) is built per decoder instance.
+ */
+
+import type * as AI from 'ai';
+
+import { createLifecycleTracker, type LifecyclePolicy, type LifecycleTracker } from '../../core/codec/index.js';
+import { stripUndefined } from '../../utils.js';
+import type { VercelOutput } from './events.js';
+import { fMessageId } from './fields.js';
+
+const createVercelLifecycleTracker = (): LifecycleTracker<AI.UIMessageChunk> =>
+  createLifecycleTracker<AI.UIMessageChunk>([
+    {
+      key: 'start',
+      build: (ctx) => [stripUndefined({ type: 'start' as const, messageId: ctx.messageId })],
+    },
+    {
+      key: 'start-step',
+      build: () => [{ type: 'start-step' as const }],
+    },
+  ]);
+
+/**
+ * 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 const createVercelDecodeLifecycle = (): LifecyclePolicy<VercelOutput> => {
+  const tracker = createVercelLifecycleTracker();
+  return {
+    onDiscrete: {
+      start: (runId) => {
+        tracker.markEmitted(runId, 'start');
+        return [];
+      },
+      'start-step': (runId) => {
+        tracker.markEmitted(runId, 'start-step');
+        return [];
+      },
+      'finish-step': (runId) => {
+        tracker.resetPhase(runId, 'start-step');
+        return [];
+      },
+      finish: (runId) => {
+        tracker.clearScope(runId);
+        return [];
+      },
+      error: (runId) => {
+        tracker.clearScope(runId);
+        return [];
+      },
+      abort: (runId) => {
+        tracker.clearScope(runId);
+        return [];
+      },
+      'tool-input': (runId, ctx) => tracker.ensurePhases(runId, { messageId: fMessageId.read(ctx.codecHeaders) }),
+    },
+    onStreamStart: (runId, trackerState) =>
+      tracker.ensurePhases(runId, { messageId: fMessageId.read(trackerState.codecHeaders) }),
+  };
+};

package/src/vercel/codec/events.ts

@@ -20,7 +20,7 @@ import type {
   ToolResult,
   ToolResultError,
   UserMessage,
-} from '../../core/codec/types.js';
+} from '../../core/codec/index.js';
 
 // ---------------------------------------------------------------------------
 // Domain payloads
@@ -83,5 +83,3 @@ export type VercelOutput = AI.UIMessageChunk;
 // ---------------------------------------------------------------------------
 // Projection re-export
 // ---------------------------------------------------------------------------
-
-export type { VercelProjection } from './reducer.js';

package/src/vercel/codec/fields.ts

@@ -0,0 +1,58 @@
+/**
+ * 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';
+
+import { boolField, enumField, type HeaderField, jsonField, strField } from '../../core/codec/index.js';
+
+/** Stream / message id (text & reasoning streams). */
+export const fId = strField('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 const fMeta: HeaderField<AI.ProviderMetadata | undefined, 'providerMetadata'> = jsonField<
+  AI.ProviderMetadata,
+  'providerMetadata'
+>('providerMetadata');
+/** Tool call id — defaulted to total: an absent header reads as `''`. */
+export const fToolCallId = strField('toolCallId', '');
+/** Tool name — defaulted to total. */
+export const fToolName = strField('toolName', '');
+/** Whether the tool is a dynamic tool. */
+export const fDynamic = boolField('dynamic');
+/** Optional human-readable title. */
+export const fTitle = strField('title');
+/** Whether the provider executed the tool. */
+export const fProviderExecuted = boolField('providerExecuted');
+/** Media type for file / source-document parts — defaulted to total. */
+export const fMediaType = strField('mediaType', '');
+/** Source id for source-url / source-document parts — defaulted to total. */
+export const fSourceId = strField('sourceId', '');
+
+// --- input-side bindings (shared by the input descriptors' encode/decode) ---
+
+/** Domain message id (`message.id`) stamped on every user-message part — distinct from the wire codec-message-id transport header. */
+export const fMessageId = strField('messageId');
+/** Whether the user approved a tool execution — defaulted to total so an absent header reads `false`. */
+export const fApproved = boolField('approved', false);
+/** Optional human-readable reason on a tool-approval response. */
+export const fReason = strField('reason');
+
+/**
+ * Validated finish reason. Mirrors the AI SDK's `FinishReason` literals and
+ * falls back to `'stop'` for an absent or unrecognized value.
+ */
+export const fFinishReason = enumField(
+  'finishReason',
+  ['stop', 'length', 'content-filter', 'tool-calls', 'error', 'other'] as const,
+  'stop',
+);

package/src/vercel/codec/fold-content.ts

@@ -0,0 +1,54 @@
+/**
+ * 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';
+
+import { stripUndefined } from '../../utils.js';
+import { ensureMessage, type VercelProjection } from './reducer-state.js';
+
+/**
+ * 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 const foldContentPart = (
+  state: VercelProjection,
+  chunk: Extract<AI.UIMessageChunk, { type: 'file' | 'source-url' | 'source-document' }>,
+  messageId: string,
+): VercelProjection => {
+  const message = ensureMessage(state, messageId);
+
+  switch (chunk.type) {
+    case 'file': {
+      message.parts.push({ type: 'file', mediaType: chunk.mediaType, url: chunk.url });
+      return state;
+    }
+    case 'source-url': {
+      message.parts.push(
+        stripUndefined({
+          type: 'source-url' as const,
+          sourceId: chunk.sourceId,
+          url: chunk.url,
+          title: chunk.title,
+        }),
+      );
+      return state;
+    }
+    case 'source-document': {
+      message.parts.push(
+        stripUndefined({
+          type: 'source-document' as const,
+          sourceId: chunk.sourceId,
+          mediaType: chunk.mediaType,
+          title: chunk.title,
+          filename: chunk.filename,
+        }),
+      );
+      return state;
+    }
+  }
+};

package/src/vercel/codec/fold-data.ts

@@ -0,0 +1,46 @@
+/**
+ * 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';
+
+import { stripUndefined } from '../../utils.js';
+import { ensureMessage, type VercelProjection } from './reducer-state.js';
+
+/**
+ * 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 const foldDataPart = (
+  state: VercelProjection,
+  chunk: Extract<AI.UIMessageChunk, { type: `data-${string}` }>,
+  messageId: string,
+): VercelProjection => {
+  if (chunk.transient) return state;
+
+  const message = ensureMessage(state, messageId);
+
+  // CAST: chunk.type is `data-${string}` which satisfies DataUIPart, but
+  // TypeScript cannot verify the template literal matches a specific
+  // UIMessagePart variant at the type level.
+  const dataPart = stripUndefined({
+    type: chunk.type,
+    id: chunk.id,
+    data: chunk.data,
+  }) as AI.UIMessage['parts'][number];
+
+  if (chunk.id !== undefined) {
+    const idx = message.parts.findIndex((p) => p.type === chunk.type && 'id' in p && p.id === chunk.id);
+    if (idx !== -1) {
+      message.parts[idx] = dataPart;
+      return state;
+    }
+  }
+
+  message.parts.push(dataPart);
+  return state;
+};

package/src/vercel/codec/fold-input.ts

@@ -0,0 +1,255 @@
+/**
+ * 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';
+
+import type { ReducerMeta, ToolApprovalResponse, ToolResult, ToolResultError } from '../../core/codec/index.js';
+import type {
+  VercelToolApprovalResponsePayload,
+  VercelToolResultErrorPayload,
+  VercelToolResultPayload,
+} from './events.js';
+import {
+  ensureTrackers,
+  getToolPart,
+  type OwnerLookup,
+  type PendingToolResolution,
+  type VercelProjection,
+} from './reducer-state.js';
+import { toolBase, transitionToolPart } from './tool-transitions.js';
+
+/**
+ * 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 const foldUserMessage = (
+  state: VercelProjection,
+  message: AI.UIMessage,
+  meta: ReducerMeta,
+): VercelProjection => {
+  // Correlate the projection entry on the wire codec-message-id; the
+  // caller-supplied `message.id` is preserved verbatim and surfaced to the
+  // application unchanged. Without a codec-message-id the message has no
+  // identity to key on, so it is appended as a fresh entry.
+  const codecMessageId = meta.messageId;
+  if (codecMessageId === undefined) {
+    state.messages.push({ codecMessageId: message.id, message });
+    return state;
+  }
+  const existing = state.messages.find((e) => e.codecMessageId === codecMessageId);
+  if (existing === undefined) {
+    state.messages.push({ codecMessageId, message });
+  } else {
+    // Merge by codec-message-id: keep the existing envelope (id and role are
+    // stamped identically on every part of one message) and append the
+    // incoming parts in fold order — wire serials preserve publish order.
+    existing.message.parts.push(...message.parts);
+  }
+  return state;
+};
+
+/**
+ * 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 const foldClientToolResult = (
+  state: VercelProjection,
+  event: ToolResult<VercelToolResultPayload>,
+): VercelProjection => {
+  const { toolCallId, output } = event.payload;
+  return resolveOrPend(state, event.codecMessageId, toolCallId, { kind: 'tool-result', output });
+};
+
+/**
+ * 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 const foldClientToolResultError = (
+  state: VercelProjection,
+  event: ToolResultError<VercelToolResultErrorPayload>,
+): VercelProjection => {
+  const { toolCallId, message } = event.payload;
+  return resolveOrPend(state, event.codecMessageId, toolCallId, { kind: 'tool-result-error', message });
+};
+
+/**
+ * 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 const foldToolApprovalResponse = (
+  state: VercelProjection,
+  event: ToolApprovalResponse<VercelToolApprovalResponsePayload>,
+): VercelProjection => {
+  const { toolCallId, approved, reason } = event.payload;
+  return resolveOrPend(state, event.codecMessageId, toolCallId, {
+    kind: 'tool-approval-response',
+    approved,
+    ...(reason === undefined ? {} : { reason }),
+  });
+};
+
+/**
+ * Apply a resolution when its tool part is present, otherwise buffer it in
+ * `pendingToolResolutions` for {@link retryPendingResolutions}.
+ * @param state - Projection to fold into.
+ * @param codecMessageId - The assistant the resolution targets.
+ * @param toolCallId - The tool call being resolved.
+ * @param resolution - The resolution variant to apply or buffer.
+ * @returns The same projection reference.
+ */
+const resolveOrPend = (
+  state: VercelProjection,
+  codecMessageId: string,
+  toolCallId: string,
+  resolution: PendingToolResolution['resolution'],
+): VercelProjection => {
+  const owner = findOwner(state, codecMessageId, toolCallId);
+  if (owner) {
+    applyResolution(owner, toolCallId, resolution);
+  } else {
+    state.pendingToolResolutions.push({ targetCodecMessageId: codecMessageId, toolCallId, resolution });
+  }
+  return state;
+};
+
+/**
+ * Apply one tool resolution onto its located `dynamic-tool` part, replacing
+ * the part with the transitioned shape — the single application point shared
+ * by the direct folds and {@link retryPendingResolutions}.
+ * @param owner - The located owner (message + tracker + part).
+ * @param toolCallId - The tool call being resolved.
+ * @param resolution - The resolution variant to apply.
+ */
+const applyResolution = (
+  owner: OwnerLookup,
+  toolCallId: string,
+  resolution: PendingToolResolution['resolution'],
+): void => {
+  switch (resolution.kind) {
+    case 'tool-result': {
+      owner.message.parts[owner.tracker.partIndex] = transitionToolPart(owner.part, {
+        type: 'tool-output-available',
+        toolCallId,
+        output: resolution.output,
+      });
+      break;
+    }
+    case 'tool-result-error': {
+      owner.message.parts[owner.tracker.partIndex] = transitionToolPart(owner.part, {
+        type: 'tool-output-error',
+        toolCallId,
+        errorText: resolution.message,
+      });
+      break;
+    }
+    case 'tool-approval-response': {
+      owner.message.parts[owner.tracker.partIndex] = approvalTransition(
+        owner.part,
+        resolution.approved,
+        resolution.reason,
+      );
+      break;
+    }
+  }
+};
+
+/**
+ * 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 const retryPendingResolutions = (state: VercelProjection): void => {
+  const next: VercelProjection['pendingToolResolutions'] = [];
+  for (const pending of state.pendingToolResolutions) {
+    const owner = findOwner(state, pending.targetCodecMessageId, pending.toolCallId);
+    if (!owner) {
+      next.push(pending);
+      continue;
+    }
+    applyResolution(owner, pending.toolCallId, pending.resolution);
+  }
+  state.pendingToolResolutions = next;
+};
+
+const findOwner = (state: VercelProjection, codecMessageId: string, toolCallId: string): OwnerLookup | undefined => {
+  const entry = state.messages.find((e) => e.codecMessageId === codecMessageId);
+  if (!entry) return undefined;
+  const trackers = ensureTrackers(state, codecMessageId);
+  const found = getToolPart(entry.message, trackers, toolCallId);
+  if (!found) return undefined;
+  return { message: entry.message, tracker: found.tracker, part: found.part };
+};
+
+/**
+ * Build the next `dynamic-tool` part shape for an approval response.
+ *
+ * For `approved=true`, transition to `approval-responded` so the AI SDK's
+ * multi-step loop will auto-run the tool on the next step.
+ * `transitionToolPart` has no shape for this transition, so we synthesize
+ * the part directly.
+ *
+ * For `approved=false`, delegate to `transitionToolPart` with a synthetic
+ * `tool-output-denied` chunk so denial mirrors the chunk-driven path.
+ * @param part - The existing `dynamic-tool` part being transitioned.
+ * @param approved - Whether the user approved the tool execution.
+ * @param reason - Optional human-readable reason.
+ * @returns The replacement `dynamic-tool` part.
+ */
+const approvalTransition = (
+  part: AI.DynamicToolUIPart,
+  approved: boolean,
+  reason: string | undefined,
+): AI.DynamicToolUIPart => {
+  if (approved) {
+    return {
+      ...toolBase(part),
+      state: 'approval-responded',
+      input: 'input' in part ? part.input : undefined,
+      approval: {
+        id: 'approval' in part && part.approval ? part.approval.id : '',
+        approved: true,
+        ...(reason === undefined ? {} : { reason }),
+      },
+    };
+  }
+  return transitionToolPart(part, {
+    type: 'tool-output-denied',
+    toolCallId: part.toolCallId,
+    ...(reason === undefined ? {} : { reason }),
+  });
+};