@tanstack/ai 0.42.0 → 0.43.0

package/src/interrupt-resume.ts

@@ -0,0 +1,824 @@
+import {
+  INTERRUPT_BINDING_VERSION,
+  canonicalizeInterruptResolutions,
+} from './interrupts'
+import {
+  canonicalInterruptJson,
+  digestInterruptJson,
+} from './interrupt-serialization'
+import {
+  hashSchemaInput,
+  normalizeApprovalSchema,
+} from './activities/chat/tools/approval-schema'
+import {
+  isStandardSchema,
+  validateWithStandardSchema,
+} from './activities/chat/tools/schema-converter'
+import type {
+  InterruptBinding,
+  InterruptSubmissionError,
+  ItemInterruptErrorCode,
+  ToolApprovalResolution,
+  UnopenedInterruptBinding,
+} from './interrupts'
+import type {
+  ChatMiddlewareConfig,
+  ChatResumeToolState,
+} from './activities/chat/middleware/types'
+import type { Interrupt, RunAgentResumeItem } from './types'
+
+/**
+ * The `Interrupt.metadata` key under which this package's resume binding
+ * travels.
+ *
+ * Exported so anything that produces an interrupt this package must later
+ * resume — an application middleware raising a generic pause, a future
+ * workflow-to-AG-UI projection — attaches the binding through
+ * {@link withInterruptBinding} rather than copying the string. Everything
+ * outside this key is the plain AG-UI envelope and is left untouched.
+ */
+export const INTERRUPT_BINDING_METADATA_KEY = 'tanstack:interruptBinding'
+
+const interruptBindingMetadataKey = INTERRUPT_BINDING_METADATA_KEY
+
+/** The persistence-neutral shape required to validate an interrupt resume. */
+export interface PendingInterruptResumeRecord {
+  interruptId: string
+  payload: unknown
+  binding: InterruptBinding
+}
+
+export interface ValidateInterruptResumeBatchInput {
+  threadId: string
+  interruptedRunId: string
+  generation: number
+  pending: ReadonlyArray<PendingInterruptResumeRecord>
+  resume?: ReadonlyArray<RunAgentResumeItem>
+  tools: ChatMiddlewareConfig['tools']
+  now?: number
+}
+
+export interface ValidatedInterruptResumeBatch {
+  errors: ReadonlyArray<InterruptSubmissionError>
+  resolutions?: ReadonlyArray<RunAgentResumeItem>
+  canonicalResolutions?: string
+  fingerprint?: string
+  resumeToolState?: ChatResumeToolState
+}
+
+export class InterruptResumeValidationError extends Error {
+  override readonly name = 'InterruptResumeValidationError'
+
+  constructor(readonly errors: ReadonlyArray<InterruptSubmissionError>) {
+    super(errors.map((error) => error.message).join(' '))
+  }
+}
+
+function objectValue(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object'
+    ? (value as Record<string, unknown>)
+    : null
+}
+
+function stringField(
+  value: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  return typeof value[key] === 'string' ? value[key] : undefined
+}
+
+function normalizeIssuePath(
+  path: ReadonlyArray<unknown> | undefined,
+): ReadonlyArray<string | number> | undefined {
+  if (!path) return undefined
+  return path.map((segment) => {
+    if (typeof segment === 'string' || typeof segment === 'number') {
+      return segment
+    }
+    const record = objectValue(segment)
+    const key = record?.key
+    return typeof key === 'number' ? key : String(key ?? segment)
+  })
+}
+
+export function interruptItemError(
+  input: Pick<
+    ValidateInterruptResumeBatchInput,
+    'threadId' | 'interruptedRunId' | 'generation'
+  >,
+  interruptId: string,
+  code: ItemInterruptErrorCode,
+  message: string,
+  options?: {
+    path?: ReadonlyArray<string | number>
+    source?: 'client' | 'server'
+    retryable?: boolean
+  },
+): InterruptSubmissionError {
+  return {
+    scope: 'item',
+    threadId: input.threadId,
+    interruptedRunId: input.interruptedRunId,
+    generation: input.generation,
+    interruptId,
+    code,
+    message,
+    source: options?.source ?? 'client',
+    retryable: options?.retryable ?? false,
+    ...(options?.path ? { path: options.path } : {}),
+  }
+}
+
+async function validateSchemaValue(input: {
+  schema: unknown
+  value: unknown
+  onIssue: (message: string, path?: ReadonlyArray<string | number>) => void
+}): Promise<void> {
+  if (isStandardSchema(input.schema)) {
+    const result = await validateWithStandardSchema<unknown>(
+      input.schema,
+      input.value,
+    )
+    if (!result.success) {
+      for (const issue of result.issues) {
+        input.onIssue(issue.message, normalizeIssuePath(issue.path))
+      }
+    }
+    return
+  }
+
+  // A non-Standard-Schema value (a raw JSON Schema, e.g. a generic interrupt's
+  // wire responseSchema) is not validated by the library. The application
+  // validates the resume value itself if it needs to; otherwise it flows
+  // through as-is.
+}
+
+type RuntimeTool = ChatMiddlewareConfig['tools'][number] & {
+  approvalSchema?: Parameters<typeof normalizeApprovalSchema>[0]
+}
+
+function runtimeTool(
+  tools: ChatMiddlewareConfig['tools'],
+  name: string,
+): RuntimeTool | undefined {
+  return tools.find((tool) => tool.name === name) as RuntimeTool | undefined
+}
+
+function descriptorResponseSchema(
+  record: PendingInterruptResumeRecord,
+): unknown {
+  return objectValue(record.payload)?.responseSchema
+}
+
+function schemaHash(schema: unknown): string {
+  return digestInterruptJson(canonicalInterruptJson(schema))
+}
+
+async function pushSchemaIssues(input: {
+  request: ValidateInterruptResumeBatchInput
+  errors: Array<InterruptSubmissionError>
+  interruptId: string
+  schema: unknown
+  value: unknown
+  code: ItemInterruptErrorCode
+  label: string
+}): Promise<void> {
+  try {
+    await validateSchemaValue({
+      schema: input.schema,
+      value: input.value,
+      onIssue: (message, path) => {
+        input.errors.push(
+          interruptItemError(
+            input.request,
+            input.interruptId,
+            input.code,
+            `${input.label}: ${message}`,
+            { path },
+          ),
+        )
+      },
+    })
+  } catch (error) {
+    input.errors.push(
+      interruptItemError(
+        input.request,
+        input.interruptId,
+        'invalid-response-schema',
+        `${input.label} could not be validated: ${error instanceof Error ? error.message : String(error)}`,
+        { source: 'server' },
+      ),
+    )
+  }
+}
+
+function validateDescriptorSchema(
+  input: ValidateInterruptResumeBatchInput,
+  record: PendingInterruptResumeRecord,
+  binding: InterruptBinding,
+  errors: Array<InterruptSubmissionError>,
+): unknown {
+  const schema = descriptorResponseSchema(record)
+  if (
+    schema === undefined ||
+    schemaHash(schema) !== binding.responseSchemaHash
+  ) {
+    errors.push(
+      interruptItemError(
+        input,
+        record.interruptId,
+        'invalid-response-schema',
+        `Interrupt ${record.interruptId} response schema no longer matches its binding.`,
+        { source: 'server' },
+      ),
+    )
+  }
+  return schema
+}
+
+/**
+ * Validate and translate a complete interrupt batch before any tool executes.
+ * Used by ephemeral chat resume; a durable layer may share the same validator.
+ */
+export async function validateInterruptResumeBatch(
+  input: ValidateInterruptResumeBatchInput,
+): Promise<ValidatedInterruptResumeBatch> {
+  const grouped = new Map<string, Array<InterruptSubmissionError>>()
+  const batchErrors: Array<InterruptSubmissionError> = []
+  const group = (interruptId: string): Array<InterruptSubmissionError> => {
+    const existing = grouped.get(interruptId)
+    if (existing) return existing
+    const created: Array<InterruptSubmissionError> = []
+    grouped.set(interruptId, created)
+    return created
+  }
+  const pendingById = new Map(
+    input.pending.map((record) => [record.interruptId, record]),
+  )
+  const resumeById = new Map<string, RunAgentResumeItem>()
+  const counts = new Map<string, number>()
+  for (const entry of input.resume ?? []) {
+    counts.set(entry.interruptId, (counts.get(entry.interruptId) ?? 0) + 1)
+    if (!resumeById.has(entry.interruptId))
+      resumeById.set(entry.interruptId, entry)
+  }
+
+  for (const [interruptId, count] of counts) {
+    if (count > 1) {
+      group(interruptId).push(
+        interruptItemError(
+          input,
+          interruptId,
+          'conflict',
+          `Interrupt ${interruptId} has duplicate resume entries.`,
+        ),
+      )
+    }
+  }
+
+  let incomplete = false
+  for (const record of input.pending) {
+    const errors = group(record.interruptId)
+    const entry = resumeById.get(record.interruptId)
+    const binding = record.binding
+    if (!entry) {
+      incomplete = true
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'unknown-interrupt',
+          `Missing resume entry for interrupt ${record.interruptId}.`,
+        ),
+      )
+    }
+    if (
+      binding.interruptedRunId !== input.interruptedRunId ||
+      binding.generation !== input.generation ||
+      binding.interruptId !== record.interruptId
+    ) {
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'stale',
+          `Interrupt ${record.interruptId} has stale correlation metadata.`,
+          { source: 'server' },
+        ),
+      )
+    }
+    if (
+      binding.expiresAt !== undefined &&
+      Date.parse(binding.expiresAt) <= (input.now ?? Date.now())
+    ) {
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'expired',
+          `Interrupt ${record.interruptId} has expired.`,
+          { source: 'server' },
+        ),
+      )
+    }
+
+    const responseSchema = validateDescriptorSchema(
+      input,
+      record,
+      binding,
+      errors,
+    )
+    if (!entry) continue
+    const entryStatus: unknown = entry.status
+    if (entryStatus !== 'resolved' && entryStatus !== 'cancelled') {
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'invalid-payload',
+          `Interrupt ${record.interruptId} has invalid status ${String(entryStatus)}.`,
+        ),
+      )
+      continue
+    }
+    if (binding.kind === 'generic') {
+      if (entry.status === 'cancelled') {
+        if (entry.payload !== undefined) {
+          errors.push(
+            interruptItemError(
+              input,
+              record.interruptId,
+              'invalid-payload',
+              `Cancelled interrupt ${record.interruptId} must not include a payload.`,
+            ),
+          )
+        }
+      } else if (responseSchema !== undefined) {
+        await pushSchemaIssues({
+          request: input,
+          errors,
+          interruptId: record.interruptId,
+          schema: responseSchema,
+          value: entry.payload,
+          code: 'invalid-payload',
+          label: `Interrupt ${record.interruptId} payload is invalid`,
+        })
+      }
+      continue
+    }
+
+    const tool = runtimeTool(input.tools, binding.toolName)
+    if (!tool) {
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'stale',
+          `Tool ${binding.toolName} is unavailable for interrupt ${record.interruptId}.`,
+          { source: 'server' },
+        ),
+      )
+      continue
+    }
+
+    let approval: ReturnType<typeof normalizeApprovalSchema> | undefined
+    let schemaDrifted = false
+    if (binding.kind === 'client-tool-execution') {
+      if (hashSchemaInput(tool.outputSchema) !== binding.outputSchemaHash) {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'stale',
+            `Tool ${binding.toolName} output schema has changed.`,
+            { source: 'server' },
+          ),
+        )
+        schemaDrifted = true
+      }
+    } else {
+      try {
+        approval = normalizeApprovalSchema(
+          tool.approvalSchema,
+          tool.inputSchema,
+        )
+      } catch {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'stale',
+            `Tool ${binding.toolName} approval schema is unavailable.`,
+            { source: 'server' },
+          ),
+        )
+        schemaDrifted = true
+      }
+      if (
+        approval !== undefined &&
+        (hashSchemaInput(tool.inputSchema) !== binding.inputSchemaHash ||
+          approval.approvalSchemaHash !== binding.approvalSchemaHash ||
+          approval.responseSchemaHash !== binding.responseSchemaHash)
+      ) {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'stale',
+            `Tool ${binding.toolName} approval schema has changed.`,
+            { source: 'server' },
+          ),
+        )
+        schemaDrifted = true
+      }
+    }
+
+    if (entry.status === 'cancelled') {
+      if (entry.payload !== undefined) {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'invalid-payload',
+            `Cancelled interrupt ${record.interruptId} must not include a payload.`,
+          ),
+        )
+      }
+      continue
+    }
+    if (schemaDrifted) continue
+
+    if (binding.kind === 'client-tool-execution') {
+      if (responseSchema !== undefined) {
+        await pushSchemaIssues({
+          request: input,
+          errors,
+          interruptId: record.interruptId,
+          schema: responseSchema,
+          value: entry.payload,
+          code: 'invalid-tool-output',
+          label: `Tool ${binding.toolName} output is invalid`,
+        })
+      }
+      if (tool.outputSchema !== undefined) {
+        await pushSchemaIssues({
+          request: input,
+          errors,
+          interruptId: record.interruptId,
+          schema: tool.outputSchema,
+          value: entry.payload,
+          code: 'invalid-tool-output',
+          label: `Tool ${binding.toolName} output is invalid`,
+        })
+      }
+      continue
+    }
+
+    if (approval === undefined) continue
+    const envelope = objectValue(entry.payload)
+    const approved =
+      typeof entry.payload === 'boolean'
+        ? entry.payload
+        : typeof envelope?.approved === 'boolean'
+          ? envelope.approved
+          : undefined
+    if (approved === undefined) {
+      errors.push(
+        interruptItemError(
+          input,
+          record.interruptId,
+          'invalid-payload',
+          `Approval ${record.interruptId} must be a boolean or decision envelope.`,
+        ),
+      )
+      continue
+    }
+    if (envelope) {
+      await pushSchemaIssues({
+        request: input,
+        errors,
+        interruptId: record.interruptId,
+        schema: approval.responseSchema,
+        value: entry.payload,
+        code: 'invalid-payload',
+        label: `Approval ${record.interruptId} envelope is invalid`,
+      })
+    }
+    if (approved && envelope?.editedArgs !== undefined) {
+      if (tool.inputSchema === undefined) {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'invalid-edited-args',
+            `Approval ${record.interruptId} cannot edit arguments without an input schema.`,
+          ),
+        )
+      } else {
+        await pushSchemaIssues({
+          request: input,
+          errors,
+          interruptId: record.interruptId,
+          schema: tool.inputSchema,
+          value: envelope.editedArgs,
+          code: 'invalid-edited-args',
+          label: `Approval ${record.interruptId} edited arguments are invalid`,
+        })
+      }
+    }
+    const branch = approved
+      ? approval.branches.approve
+      : approval.branches.reject
+    if (branch) {
+      if (!envelope) {
+        errors.push(
+          interruptItemError(
+            input,
+            record.interruptId,
+            'invalid-payload',
+            `Approval ${record.interruptId} requires a payload for the ${approved ? 'approve' : 'reject'} decision.`,
+          ),
+        )
+      } else {
+        await pushSchemaIssues({
+          request: input,
+          errors,
+          interruptId: record.interruptId,
+          schema: branch.source,
+          value: envelope.payload,
+          code: 'invalid-payload',
+          label: `Approval ${record.interruptId} payload is invalid`,
+        })
+      }
+    }
+  }
+
+  for (const entry of input.resume ?? []) {
+    if (!pendingById.has(entry.interruptId)) {
+      incomplete = true
+      group(entry.interruptId).push(
+        interruptItemError(
+          input,
+          entry.interruptId,
+          'unknown-interrupt',
+          `Resume entry references unknown interrupt ${entry.interruptId}.`,
+        ),
+      )
+    }
+  }
+
+  if (incomplete) {
+    batchErrors.push({
+      scope: 'batch',
+      threadId: input.threadId,
+      interruptedRunId: input.interruptedRunId,
+      generation: input.generation,
+      code: 'incomplete-batch',
+      message:
+        'Resume entries must resolve or cancel the complete interrupt batch.',
+      source: 'client',
+      retryable: false,
+      interruptIds: input.pending.map((record) => record.interruptId),
+    })
+  }
+
+  const itemErrors = [...grouped.entries()]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .flatMap(([, errors]) => errors)
+  if (itemErrors.length > 0) {
+    batchErrors.push({
+      scope: 'batch',
+      threadId: input.threadId,
+      interruptedRunId: input.interruptedRunId,
+      generation: input.generation,
+      code: 'item-validation-failed',
+      message: 'One or more interrupt resolutions are invalid.',
+      source: 'client',
+      retryable: false,
+      interruptIds: input.pending.map((record) => record.interruptId),
+    })
+    return { errors: [...itemErrors, ...batchErrors] }
+  }
+
+  const canonical = canonicalizeInterruptResolutions(input.resume ?? [])
+  const approvals = new Map<string, ToolApprovalResolution>()
+  const clientToolResults = new Map<string, unknown>()
+  const genericInterrupts = new Map<
+    string,
+    | { interruptId: string; status: 'resolved'; payload: unknown }
+    | { interruptId: string; status: 'cancelled' }
+  >()
+  const deniedToolResults = new Map<string, unknown>()
+  const cancelledToolCallIds = new Set<string>()
+
+  for (const record of input.pending) {
+    const entry = resumeById.get(record.interruptId)
+    if (!entry) continue
+    const binding = record.binding
+    if (binding.kind === 'generic') {
+      genericInterrupts.set(
+        record.interruptId,
+        entry.status === 'resolved'
+          ? {
+              interruptId: record.interruptId,
+              status: 'resolved',
+              payload: entry.payload,
+            }
+          : { interruptId: record.interruptId, status: 'cancelled' },
+      )
+      continue
+    }
+    if (entry.status === 'cancelled') {
+      cancelledToolCallIds.add(binding.toolCallId)
+      continue
+    }
+    if (binding.kind === 'client-tool-execution') {
+      clientToolResults.set(binding.toolCallId, entry.payload)
+      continue
+    }
+    const envelope = objectValue(entry.payload)
+    const resolution: ToolApprovalResolution =
+      typeof entry.payload === 'boolean'
+        ? entry.payload
+        : envelope?.approved === true
+          ? {
+              approved: true,
+              ...(envelope.editedArgs !== undefined
+                ? { editedArgs: envelope.editedArgs }
+                : {}),
+              ...(envelope.payload !== undefined
+                ? { payload: envelope.payload }
+                : {}),
+            }
+          : {
+              approved: false,
+              ...(envelope?.payload !== undefined
+                ? { payload: envelope.payload }
+                : {}),
+            }
+    approvals.set(binding.toolCallId, resolution)
+    if (
+      resolution === false ||
+      (typeof resolution === 'object' && !resolution.approved)
+    ) {
+      deniedToolResults.set(
+        binding.toolCallId,
+        typeof resolution === 'object' ? resolution.payload : undefined,
+      )
+    }
+  }
+
+  return {
+    errors: [],
+    resolutions: canonical.resolutions,
+    canonicalResolutions: canonical.canonicalResolutions,
+    fingerprint: canonical.fingerprint,
+    resumeToolState: {
+      approvals,
+      clientToolResults,
+      genericInterrupts,
+      deniedToolResults,
+      cancelledToolCallIds,
+    },
+  }
+}
+
+/**
+ * Is this a binding written by a version of the protocol we understand?
+ *
+ * A missing `v` is read as {@link INTERRUPT_BINDING_VERSION} so bindings
+ * written before the field existed still resume. A `v` we don't recognise is
+ * rejected outright — a newer or foreign producer's binding must not be
+ * duck-typed into ours.
+ */
+function isSupportedBindingVersion(raw: Record<string, unknown>): boolean {
+  const version = raw['v']
+  if (version === undefined) return true
+  return version === INTERRUPT_BINDING_VERSION
+}
+
+export function readUnopenedInterruptBinding(
+  descriptor: Interrupt,
+): UnopenedInterruptBinding | undefined {
+  const metadata = objectValue(descriptor.metadata)
+  const raw = metadata
+    ? objectValue(metadata[interruptBindingMetadataKey])
+    : null
+  if (!raw || stringField(raw, 'interruptId') !== descriptor.id)
+    return undefined
+  if (!isSupportedBindingVersion(raw)) return undefined
+  const kind = stringField(raw, 'kind')
+  const interruptId = stringField(raw, 'interruptId')
+  const responseSchemaHash = stringField(raw, 'responseSchemaHash')
+  const expiresAt = stringField(raw, 'expiresAt')
+  if (!interruptId || !responseSchemaHash) return undefined
+  const v = INTERRUPT_BINDING_VERSION
+  if (kind === 'generic') {
+    return {
+      v,
+      kind,
+      interruptId,
+      responseSchemaHash,
+      ...(expiresAt ? { expiresAt } : {}),
+    }
+  }
+  const toolName = stringField(raw, 'toolName')
+  const toolCallId = stringField(raw, 'toolCallId')
+  if (!toolName || !toolCallId) return undefined
+  if (kind === 'client-tool-execution') {
+    const outputSchemaHash = stringField(raw, 'outputSchemaHash')
+    if (!outputSchemaHash) return undefined
+    return {
+      v,
+      kind,
+      interruptId,
+      toolName,
+      toolCallId,
+      outputSchemaHash,
+      responseSchemaHash,
+      ...(expiresAt ? { expiresAt } : {}),
+    }
+  }
+  if (kind === 'tool-approval') {
+    const inputSchemaHash = stringField(raw, 'inputSchemaHash')
+    const approvalSchemaHash = stringField(raw, 'approvalSchemaHash')
+    if (!inputSchemaHash || !approvalSchemaHash) return undefined
+    return {
+      v,
+      kind,
+      interruptId,
+      toolName,
+      toolCallId,
+      originalArgs: raw.originalArgs,
+      inputSchemaHash,
+      approvalSchemaHash,
+      responseSchemaHash,
+      ...(expiresAt ? { expiresAt } : {}),
+    }
+  }
+  return undefined
+}
+
+/**
+ * Attach a resume binding to an interrupt descriptor, under
+ * {@link INTERRUPT_BINDING_METADATA_KEY}.
+ *
+ * This is the supported way to make an interrupt resumable by this package.
+ * The descriptor keeps its AG-UI shape; only `metadata` gains the namespaced
+ * key. Pass the unopened form (no `interruptedRunId` / `generation`) when
+ * emitting from inside a run — those fields are stamped as the run finishes.
+ */
+export function withInterruptBinding(
+  descriptor: Interrupt,
+  binding: UnopenedInterruptBinding | InterruptBinding,
+): Interrupt {
+  return {
+    ...descriptor,
+    metadata: {
+      ...descriptor.metadata,
+      [interruptBindingMetadataKey]: {
+        ...binding,
+        v: INTERRUPT_BINDING_VERSION,
+        interruptId: descriptor.id,
+      },
+    },
+  }
+}
+
+/**
+ * Read the opened resume binding off a descriptor, or `undefined` when the
+ * descriptor carries no binding of a version we understand.
+ *
+ * `undefined` means "this interrupt is not ours to resume" — it is not a
+ * failure to recover from by inventing a binding.
+ */
+export function readInterruptBinding(
+  descriptor: Interrupt,
+): InterruptBinding | undefined {
+  const unopened = readUnopenedInterruptBinding(descriptor)
+  if (!unopened) return undefined
+  const metadata = objectValue(descriptor.metadata)
+  const raw = metadata
+    ? objectValue(metadata[interruptBindingMetadataKey])
+    : null
+  if (!raw) return undefined
+  const interruptedRunId = stringField(raw, 'interruptedRunId')
+  const generation = raw['generation']
+  if (
+    !interruptedRunId ||
+    typeof generation !== 'number' ||
+    !Number.isInteger(generation) ||
+    generation < 0
+  ) {
+    return undefined
+  }
+  return { ...unopened, interruptedRunId, generation }
+}
+
+export function withoutInterruptBinding(descriptor: Interrupt): Interrupt {
+  const metadata = objectValue(descriptor.metadata)
+  if (!metadata || !(interruptBindingMetadataKey in metadata)) return descriptor
+  const publicMetadata = { ...metadata }
+  delete publicMetadata[interruptBindingMetadataKey]
+  return { ...descriptor, metadata: publicMetadata }
+}