deepline 0.1.153 → 0.1.154

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -12,41 +12,18 @@ import type { PlayQueueHint } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
 import type { AnyBatchOperationStrategy } from './batching-types';
 import type { ToolResultMetadataInput } from './tool-result';
-import type {
-  AuthoredStaleAfterSeconds,
-  CellStalenessPolicy,
-  PreviousCell,
-} from './cell-staleness';
+import type { PreviousCell } from './cell-staleness';
 import type { MapRowOutcome } from './durability-store';
 
 export interface RowState {
-  waterfalls: Map<string, WaterfallState>;
   results: Map<string, unknown>;
 }
 
-export interface WaterfallState {
-  status: 'pending' | 'complete' | 'failed';
-  providerIndex: number;
-  result?: unknown;
-  error?: string;
-}
-
-export interface WaterfallRequest {
-  rowId: number;
-  fieldName?: string;
-  tableNamespace?: string;
-  rowKey?: string | null;
-  key: string;
-  toolName: string;
-  input: Record<string, unknown>;
-  providerIndex: number;
-  opts?: WaterfallOptions;
-  spec?: InlineWaterfallSpec;
-  description?: string;
-}
-
 export interface ToolCallRequest {
   callId: string;
+  cacheKey: string;
+  receiptKey?: string | null;
+  force?: boolean;
   rowId: number;
   fieldName?: string;
   toolId: string;
@@ -78,6 +55,7 @@ export interface ClaimRuntimeStepReceiptInput {
   key: string;
   runId: string;
   reclaimRunning?: boolean;
+  forceRefresh?: boolean;
 }
 
 export interface CompleteRuntimeStepReceiptInput {
@@ -98,10 +76,31 @@ export interface SkipRuntimeStepReceiptInput {
   output?: unknown | null;
 }
 
-export interface WaterfallOptions {
-  providers?: string[];
-  timeout?: number;
-  description?: string;
+export interface GetRuntimeStepReceiptsInput {
+  keys: string[];
+}
+
+export interface ClaimRuntimeStepReceiptsInput {
+  keys: string[];
+  runId: string;
+  reclaimRunning?: boolean;
+  forceRefresh?: boolean;
+}
+
+export interface CompleteRuntimeStepReceiptsInput {
+  receipts: Array<{
+    key: string;
+    runId: string;
+    output: unknown | null;
+  }>;
+}
+
+export interface FailRuntimeStepReceiptsInput {
+  receipts: Array<{
+    key: string;
+    runId: string;
+    error: string;
+  }>;
 }
 
 export interface CsvOptions {
@@ -203,8 +202,6 @@ export interface PlayCallOptions {
 }
 
 export interface StepOptions {
-  recompute?: boolean;
-  recomputeOnError?: boolean;
   semanticKey?: string;
   staleAfterSeconds?: number;
 }
@@ -213,39 +210,6 @@ export interface FetchOptions {
   staleAfterSeconds?: number;
 }
 
-export interface InlineWaterfallToolStep {
-  id: string;
-  kind?: 'tool';
-  toolId: string;
-  mapInput: (input: Record<string, unknown>) => Record<string, unknown>;
-}
-
-export interface InlineWaterfallCodeStepContext {
-  tools: {
-    execute(request: ToolExecutionRequest): Promise<unknown>;
-  };
-}
-
-export interface InlineWaterfallCodeStep {
-  id: string;
-  kind: 'code';
-  run: (
-    input: Record<string, unknown>,
-    ctx: InlineWaterfallCodeStepContext,
-  ) => unknown | Promise<unknown>;
-}
-
-export type InlineWaterfallStep =
-  | InlineWaterfallToolStep
-  | InlineWaterfallCodeStep;
-
-export interface InlineWaterfallSpec {
-  id: string;
-  output: string;
-  minResults: number;
-  steps: InlineWaterfallStep[];
-}
-
 export interface ResolvedPlayExecution {
   playId: string;
   code?: string | null;
@@ -298,10 +262,8 @@ export interface BatchRequest {
 }
 
 export interface MapStartResult {
-  /** Rows that need processing (not yet completed in a prior run). */
+  /** Rows that need processing for this run. Previous values may be included for context. */
   pendingRows: Record<string, unknown>[];
-  /** Rows already completed in a prior run (cached results). */
-  completedRows: Record<string, unknown>[];
   /** Resolved table namespace. */
   tableNamespace: string;
 }
@@ -465,7 +427,6 @@ export interface ContextOptions {
       playId?: string;
       runId?: string;
       staticPipeline?: PlayStaticPipeline | null;
-      cellPolicies?: Record<string, CellStalenessPolicy>;
     },
   ) => Promise<MapStartResult>;
   /**
@@ -490,6 +451,9 @@ export interface ContextOptions {
   getToolRetryPolicy?: (toolId: string) => Promise<{
     retrySafeTransientHttp?: boolean;
   } | null>;
+  getToolActionCacheVersion?: (
+    toolId: string,
+  ) => Promise<string> | string;
   getToolTargetGetters?: (
     toolId: string,
     output: string,
@@ -524,15 +488,27 @@ export interface ContextOptions {
   getRuntimeStepReceipt?: (
     input: GetRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
+  getRuntimeStepReceipts?: (
+    input: GetRuntimeStepReceiptsInput,
+  ) => Promise<RuntimeStepReceipt[]> | RuntimeStepReceipt[];
   claimRuntimeStepReceipt?: (
     input: ClaimRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
+  claimRuntimeStepReceipts?: (
+    input: ClaimRuntimeStepReceiptsInput,
+  ) => Promise<RuntimeStepReceipt[]> | RuntimeStepReceipt[];
   completeRuntimeStepReceipt?: (
     input: CompleteRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
+  completeRuntimeStepReceipts?: (
+    input: CompleteRuntimeStepReceiptsInput,
+  ) => Promise<RuntimeStepReceipt[]> | RuntimeStepReceipt[];
   failRuntimeStepReceipt?: (
     input: FailRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
+  failRuntimeStepReceipts?: (
+    input: FailRuntimeStepReceiptsInput,
+  ) => Promise<RuntimeStepReceipt[]> | RuntimeStepReceipt[];
   skipRuntimeStepReceipt?: (
     input: SkipRuntimeStepReceiptInput,
   ) => Promise<RuntimeStepReceipt | null> | RuntimeStepReceipt | null;
@@ -616,7 +592,7 @@ export interface BatchResult {
 export interface ToolDefinition {
   toolId: string;
   provider: string;
-  providers?: string[]; // For waterfalls
+  providers?: string[];
   supportsBatch?: boolean;
 }
 
@@ -678,9 +654,6 @@ export type RuntimeConditionalStepResolver<
 
 export type RuntimeStepProgramStep = {
   name: string;
-  recompute?: boolean;
-  recomputeOnError?: boolean;
-  staleAfterSeconds?: AuthoredStaleAfterSeconds;
   resolver:
     | RuntimeStepResolver
     | RuntimeConditionalStepResolver

package/dist/bundling-sources/shared_libs/play-runtime/default-batch-strategies.ts

@@ -40,6 +40,38 @@ type TestRateLimitBatchResult = {
   }>;
 };
 
+function testRateLimitBatchItems(
+  value: unknown,
+): Array<{ itemKey?: string; result?: unknown }> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return [];
+  }
+  const record = value as Record<string, unknown>;
+  if (Array.isArray(record.items)) {
+    return record.items as Array<{ itemKey?: string; result?: unknown }>;
+  }
+  const candidates = [
+    record.data,
+    record.result,
+    record.output,
+    record.toolResponse &&
+    typeof record.toolResponse === 'object' &&
+    !Array.isArray(record.toolResponse)
+      ? (record.toolResponse as Record<string, unknown>).raw
+      : undefined,
+    record.toolOutput &&
+    typeof record.toolOutput === 'object' &&
+    !Array.isArray(record.toolOutput)
+      ? (record.toolOutput as Record<string, unknown>).raw
+      : undefined,
+  ];
+  for (const candidate of candidates) {
+    const items = testRateLimitBatchItems(candidate);
+    if (items.length > 0) return items;
+  }
+  return [];
+}
+
 const testRateLimitBatchStrategy: BatchOperationStrategy<
   TestRateLimitPayload,
   TestRateLimitBatchPayload,
@@ -65,7 +97,9 @@ const testRateLimitBatchStrategy: BatchOperationStrategy<
         ? payloads[0].simulated_delay_ms
         : undefined;
     const items = payloads.map((payload, index) => ({
-      itemKey: String(payload.lead_id || payload.row_number || `row_${index}`),
+      itemKey: String(
+        payload.lead_id || payload.row_number || payload.key || `row_${index}`,
+      ),
       payload,
     }));
     return {
@@ -82,19 +116,7 @@ const testRateLimitBatchStrategy: BatchOperationStrategy<
     };
   },
   splitResult(fullResult, compiled) {
-    const container =
-      fullResult && typeof fullResult === 'object'
-        ? (fullResult as { data?: { items?: unknown[] }; items?: unknown[] })
-        : {};
-    const nestedItems =
-      container.data && typeof container.data === 'object'
-        ? container.data.items
-        : undefined;
-    const resultItems = Array.isArray(container.items)
-      ? (container.items as Array<{ itemKey?: string; result?: unknown }>)
-      : Array.isArray(nestedItems)
-        ? (nestedItems as Array<{ itemKey?: string; result?: unknown }>)
-        : [];
+    const resultItems = testRateLimitBatchItems(fullResult);
     return compiled.items.map((item, index) => ({
       itemKey: item.itemKey,
       result:

package/dist/bundling-sources/shared_libs/play-runtime/durable-call-cache.ts

@@ -0,0 +1,145 @@
+import {
+  normalizeTableNamespace,
+  sha256Hex,
+  stableStringify,
+  // Relative (not '@shared_libs/...') because this file ships inside the
+  // packed SDK's dist/bundling-sources graph, where only relative imports
+  // resolve.
+} from '../plays/row-identity';
+
+export const DURABLE_CALL_CACHE_POLICY_VERSION = 'call-cache-v1';
+
+export type DurableCallKind = 'tool' | 'step' | 'fetch' | 'runPlay';
+
+function validateStaleAfterSeconds(staleAfterSeconds?: number | null): void {
+  if (staleAfterSeconds === undefined || staleAfterSeconds === null) {
+    return;
+  }
+  if (
+    !Number.isFinite(staleAfterSeconds) ||
+    !Number.isInteger(staleAfterSeconds) ||
+    staleAfterSeconds <= 0
+  ) {
+    throw new Error(
+      'staleAfterSeconds must be a positive whole number of seconds.',
+    );
+  }
+}
+
+export function durableCacheStaleBucket(input: {
+  staleAfterSeconds?: number | null;
+  nowMs?: number;
+}): string | null {
+  validateStaleAfterSeconds(input.staleAfterSeconds);
+  if (
+    input.staleAfterSeconds === undefined ||
+    input.staleAfterSeconds === null
+  ) {
+    return null;
+  }
+  const nowMs = input.nowMs ?? Date.now();
+  return `${input.staleAfterSeconds}:${Math.floor(
+    nowMs / (input.staleAfterSeconds * 1000),
+  )}`;
+}
+
+export const durableCallStaleBucket = durableCacheStaleBucket;
+
+export function buildDurableToolCallCacheKey(input: {
+  orgId?: string | null;
+  playId: string;
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  authScopeDigest?: string | null;
+  providerActionVersion?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+}): string {
+  const orgId = input.orgId?.trim() || 'org';
+  const playId = input.playId.trim();
+  if (!playId) {
+    throw new Error(
+      'Durable tool call cache key requires a non-empty play id.',
+    );
+  }
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error(
+      'Durable tool call cache key requires a non-empty tool id.',
+    );
+  }
+  const providerActionVersion = input.providerActionVersion?.trim();
+  if (!providerActionVersion) {
+    throw new Error(
+      'Durable tool call cache key requires a provider action version.',
+    );
+  }
+  const digest = sha256Hex(
+    stableStringify({
+      kind: 'tool' satisfies DurableCallKind,
+      orgId,
+      playId,
+      toolId,
+      normalizedToolId: normalizeTableNamespace(toolId),
+      requestInput: input.requestInput,
+      authScopeDigest: input.authScopeDigest ?? null,
+      providerActionVersion,
+      cachePolicyVersion:
+        input.cachePolicyVersion ?? DURABLE_CALL_CACHE_POLICY_VERSION,
+      staleBucket: durableCacheStaleBucket({
+        staleAfterSeconds: input.staleAfterSeconds,
+      }),
+    }),
+  );
+  return `ctx:${orgId}:call:tool:${normalizeTableNamespace(toolId)}:${digest}`;
+}
+
+export function buildDurableCtxCallCacheKey(input: {
+  orgId?: string | null;
+  playId?: string | null;
+  kind: Exclude<DurableCallKind, 'tool'>;
+  id: string;
+  semanticKey?: string | null;
+  cachePolicyVersion?: string | null;
+  staleAfterSeconds?: number | null;
+}): string {
+  const orgId = input.orgId?.trim() || 'org';
+  const playId = input.playId?.trim() || 'play';
+  const id = input.id.trim();
+  if (!id) {
+    throw new Error(
+      `Durable ${input.kind} call cache key requires a non-empty id.`,
+    );
+  }
+  const normalizedId = normalizeTableNamespace(id);
+  const digest = sha256Hex(
+    stableStringify({
+      kind: input.kind,
+      orgId,
+      playId,
+      id,
+      normalizedId,
+      semanticKey: input.semanticKey ?? null,
+      cachePolicyVersion:
+        input.cachePolicyVersion ?? DURABLE_CALL_CACHE_POLICY_VERSION,
+      staleBucket: durableCacheStaleBucket({
+        staleAfterSeconds: input.staleAfterSeconds,
+      }),
+    }),
+  );
+  return `ctx:${orgId}:call:${input.kind}:${normalizedId}:${digest}`;
+}
+
+export function buildDurableToolCallAuthScopeDigest(input: {
+  orgId?: string | null;
+  userEmail?: string | null;
+  toolId: string;
+}): string {
+  return sha256Hex(
+    stableStringify({
+      orgId: input.orgId?.trim() || 'org',
+      actor: input.userEmail?.trim().toLowerCase() || 'workspace',
+      toolId: input.toolId.trim(),
+    }),
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/durable-receipt-execution.ts

@@ -0,0 +1,284 @@
+import {
+  deserializeToolExecuteResult,
+  isSerializedToolExecuteResult,
+  isToolExecuteResult,
+  serializeToolExecuteResult,
+} from './tool-result';
+import { assertNoSecretTaint } from './secret-capability';
+import type { RuntimeStepReceipt } from './ctx-types';
+import type { DurableReceiptRecoverySource } from './tool-execution-outcome';
+
+const DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS = 240;
+const DURABLE_RECEIPT_WAIT_DELAY_MS = 250;
+
+export class RuntimeReceiptWaitTimeoutError extends Error {
+  constructor(key: string) {
+    super(`Timed out waiting for durable receipt ${key}.`);
+    this.name = 'RuntimeReceiptWaitTimeoutError';
+  }
+}
+
+export type DurableReceiptOperation = 'step' | 'tool' | 'fetch' | 'runPlay';
+
+export type DurableReceiptExecutionStore = {
+  enabled: boolean;
+  get(receiptKey: string): Promise<RuntimeStepReceipt | null>;
+  getMany(receiptKeys: string[]): Promise<Map<string, RuntimeStepReceipt>>;
+  claim(
+    receiptKey: string,
+    runId: string,
+    reclaimRunning?: boolean,
+    forceRefresh?: boolean,
+  ): Promise<RuntimeStepReceipt | null>;
+  complete(
+    receiptKey: string,
+    runId: string,
+    output: unknown | null,
+  ): Promise<RuntimeStepReceipt | null>;
+  fail(
+    receiptKey: string,
+    runId: string,
+    error: string,
+  ): Promise<RuntimeStepReceipt | null>;
+  canPersistFailure: boolean;
+  canPersistCompletion: boolean;
+};
+
+export function runtimeReceiptOutput<T>(receipt: RuntimeStepReceipt): T {
+  return isSerializedToolExecuteResult(receipt.output)
+    ? (deserializeToolExecuteResult(receipt.output) as T)
+    : (receipt.output as T);
+}
+
+export async function waitForCompletedRuntimeReceipt(input: {
+  receiptKey: string;
+  store: Pick<DurableReceiptExecutionStore, 'getMany'>;
+  maxAttempts?: number;
+  delayMs?: number;
+}): Promise<RuntimeStepReceipt> {
+  const maxAttempts = input.maxAttempts ?? DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS;
+  const delayMs = input.delayMs ?? DURABLE_RECEIPT_WAIT_DELAY_MS;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    if (attempt > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    const receipt = (await input.store.getMany([input.receiptKey])).get(
+      input.receiptKey,
+    );
+    if (receipt?.status === 'completed' || receipt?.status === 'skipped') {
+      return receipt;
+    }
+    if (receipt?.status === 'failed') {
+      throw new Error(
+        `Durable tool call ${input.receiptKey} failed: ${receipt.error ?? 'unknown error'}`,
+      );
+    }
+  }
+  throw new RuntimeReceiptWaitTimeoutError(input.receiptKey);
+}
+
+export async function executeWithDurableRuntimeReceipt<T>(input: {
+  operation: DurableReceiptOperation;
+  id: string;
+  runId: string;
+  receiptKey: string;
+  store: DurableReceiptExecutionStore;
+  force?: boolean;
+  repairRunningReceiptForSameRun?: boolean;
+  repairRunningReceiptForSameRunAfterWaitTimeout?: boolean;
+  runningReceiptWaitMaxAttempts?: number;
+  runningReceiptWaitDelayMs?: number;
+  reclaimRunning?: boolean;
+  markSkipped?: (output: T) => Promise<void> | void;
+  onRecovered?: (
+    output: T,
+    receipt: RuntimeStepReceipt,
+    source: DurableReceiptRecoverySource,
+  ) => T;
+  onClaimedResult?: (output: T, receiptKey: string) => T;
+  formatError: (error: unknown) => string;
+  log: (message: string) => void;
+  execute: () => Promise<T>;
+}): Promise<T> {
+  if (!input.store.enabled) {
+    return await input.execute();
+  }
+
+  const recoverCompletedReceipt = async (
+    receipt: RuntimeStepReceipt,
+    source: DurableReceiptRecoverySource = 'cache',
+  ): Promise<T> => {
+    input.log(
+      `ctx.${input.operation}(${input.id}): recovered result from receipt`,
+    );
+    if (receipt.output === undefined) {
+      return receipt.output as T;
+    }
+    const output = runtimeReceiptOutput<T>(receipt);
+    const recovered = input.onRecovered
+      ? input.onRecovered(output, receipt, source)
+      : output;
+    if (input.markSkipped) {
+      await input.markSkipped(recovered);
+    }
+    return recovered;
+  };
+
+  const reclaimRunningReceipt = async (): Promise<
+    { kind: 'recovered'; output: T } | { kind: 'claimed' }
+  > => {
+    const reclaimed = await input.store.claim(
+      input.receiptKey,
+      input.runId,
+      true,
+    );
+    if (reclaimed?.status === 'completed' || reclaimed?.status === 'skipped') {
+      return {
+        kind: 'recovered',
+        output: await recoverCompletedReceipt(reclaimed, 'cache'),
+      };
+    }
+    if (reclaimed?.status === 'failed') {
+      throw new Error(
+        `ctx.${input.operation}(${input.id}): receipt is failed and could not be reclaimed: ${reclaimed.error ?? 'unknown error'}.`,
+      );
+    }
+    if (
+      reclaimed?.status === 'running' &&
+      reclaimed.claimState === 'existing'
+    ) {
+      throw new RuntimeReceiptWaitTimeoutError(input.receiptKey);
+    }
+    return { kind: 'claimed' };
+  };
+  const shouldRepairSameRunRunningReceipt = (
+    receipt: RuntimeStepReceipt,
+  ): boolean =>
+    input.repairRunningReceiptForSameRun === true &&
+    receipt.status === 'running' &&
+    typeof receipt.runId === 'string' &&
+    receipt.runId.trim() === input.runId;
+
+  const waitForRunningReceipt = async (): Promise<{
+    kind: 'recovered';
+    output: T;
+  }> => ({
+    kind: 'recovered',
+    output: await recoverCompletedReceipt(
+      await waitForCompletedRuntimeReceipt({
+        receiptKey: input.receiptKey,
+        store: input.store,
+        maxAttempts: input.runningReceiptWaitMaxAttempts,
+        delayMs: input.runningReceiptWaitDelayMs,
+      }),
+      'in_flight',
+    ),
+  });
+  const waitForRunningReceiptOrTimeout = async (): Promise<{
+    kind: 'recovered';
+    output: T;
+  }> => waitForRunningReceipt();
+  const repairOrWaitForRunningReceipt = async (
+    receipt: RuntimeStepReceipt,
+  ): Promise<{ kind: 'recovered'; output: T } | { kind: 'claimed' }> => {
+    if (shouldRepairSameRunRunningReceipt(receipt)) {
+      const recovered = await reclaimRunningReceipt();
+      if (recovered.kind === 'recovered') return recovered;
+      return { kind: 'claimed' };
+    }
+    try {
+      return await waitForRunningReceiptOrTimeout();
+    } catch (error) {
+      if (
+        input.repairRunningReceiptForSameRunAfterWaitTimeout === true &&
+        error instanceof RuntimeReceiptWaitTimeoutError &&
+        receipt.status === 'running' &&
+        typeof receipt.runId === 'string' &&
+        receipt.runId.trim() === input.runId
+      ) {
+        const recovered = await reclaimRunningReceipt();
+        if (recovered.kind === 'recovered') return recovered;
+        return { kind: 'claimed' };
+      }
+      throw error;
+    }
+  };
+
+  const claimed = await input.store.claim(
+    input.receiptKey,
+    input.runId,
+    input.reclaimRunning === true || input.force === true,
+    input.force === true,
+  );
+  if (
+    input.force !== true &&
+    (claimed?.status === 'completed' || claimed?.status === 'skipped')
+  ) {
+    return await recoverCompletedReceipt(claimed);
+  }
+  if (!claimed) {
+    const latest = await input.store.get(input.receiptKey);
+    if (latest?.status === 'completed' || latest?.status === 'skipped') {
+      return await recoverCompletedReceipt(latest);
+    }
+    if (latest?.status === 'running') {
+      const recovered = await repairOrWaitForRunningReceipt(latest);
+      if (recovered.kind === 'recovered') return recovered.output;
+    } else {
+      if (latest?.status === 'failed') {
+        throw new Error(
+          `ctx.${input.operation}(${input.id}): receipt is failed and could not be claimed: ${latest.error ?? 'unknown error'}.`,
+        );
+      }
+      throw new Error(
+        `ctx.${input.operation}(${input.id}): receipt claim did not return execution ownership.`,
+      );
+    }
+  } else if (claimed.status === 'running') {
+    if (claimed.claimState === 'existing') {
+      const recovered = await repairOrWaitForRunningReceipt(claimed);
+      if (recovered.kind === 'recovered') return recovered.output;
+    }
+  } else if (claimed.status === 'failed') {
+    throw new Error(
+      `ctx.${input.operation}(${input.id}): receipt is failed and could not be claimed: ${claimed.error ?? 'unknown error'}.`,
+    );
+  }
+
+  let result: T;
+  try {
+    const executed = await input.execute();
+    result = input.onClaimedResult
+      ? input.onClaimedResult(executed, input.receiptKey)
+      : executed;
+    assertNoSecretTaint(result, `ctx.${input.operation} result`);
+  } catch (error) {
+    const failed = await input.store.fail(
+      input.receiptKey,
+      input.runId,
+      input.formatError(error),
+    );
+    if (!failed && input.store.canPersistFailure) {
+      throw new Error(
+        `ctx.${input.operation}(${input.id}): execution failed and failed receipt could not be persisted: ${input.formatError(error)}`,
+      );
+    }
+    throw error;
+  }
+
+  const completed = await input.store.complete(
+    input.receiptKey,
+    input.runId,
+    isToolExecuteResult(result) ? serializeToolExecuteResult(result) : result,
+  );
+  if (!completed && input.store.canPersistCompletion) {
+    return result;
+  }
+  if (
+    completed &&
+    (completed.status === 'completed' || completed.status === 'skipped')
+  ) {
+    return await recoverCompletedReceipt(completed, 'owner');
+  }
+  return result;
+}