deepline 0.1.301 → 0.1.302

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -81,6 +81,17 @@ import {
 } from './resource-governor';
 import { CTX_FETCH_EGRESS_TOOL_ID } from './builtin-pacing';
 import { ProviderExhaustedError } from './run-failure';
+import {
+  buildPlayContractCompatibility,
+  normalizePlayContractCompatibility,
+} from '@shared_libs/plays/contracts';
+import {
+  LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  serializeToolExecutionFailure,
+  TOOL_EXECUTION_ERROR_SCHEMA_HEADER,
+  type ToolExecutionErrorSchemaVersion,
+  type ToolExecutionFailureV1,
+} from '../tool-execution-error';
 import { InMemoryRateStateBackend } from './governor/in-memory-rate-state-backend';
 import { pacingPolicyForTool } from './pacing';
 import {
@@ -112,7 +123,7 @@ import {
   parseToolExecuteAuthScopeChangedError,
   ToolExecuteAuthScopeChangedError,
 } from './tool-execute-retry-policy';
-import { ToolHttpError } from './tool-http-errors';
+import { createToolHttpError } from './tool-http-errors';
 import {
   describeTransportError,
   transportGatewayOriginForDiagnostic,
@@ -132,6 +143,7 @@ import {
   RuntimeReceiptWaitTimeoutError,
   executeWithDurableRuntimeReceipt,
   resolveRuntimeToolReceiptWaitMaxAttempts,
+  runtimeReceiptFailureError,
   runtimeReceiptFailureKindForError,
   runtimeReceiptOutput as durableRuntimeReceiptOutput,
   waitForCompletedRuntimeReceipt,
@@ -285,6 +297,8 @@ type InlineCompositionStore = {
   governor: PlayExecutionGovernor;
   playName: string;
   staticPipeline: ContextOptions['staticPipeline'];
+  /** Immutable error contract pinned by the child play artifact. */
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
 };
 const inlineCompositionContext =
   new AsyncLocalStorage<InlineCompositionStore>();
@@ -1586,6 +1600,19 @@ export class PlayContextImpl {
     return active ? active.staticPipeline : this.#options.staticPipeline;
   }
 
+  /**
+   * Inline children share this context's queues, but not its artifact contract.
+   * Each child tool call must preserve the error shape pinned when that child
+   * was published, even when the parent was published under another schema.
+   */
+  private get currentToolErrorSchemaVersion(): ToolExecutionErrorSchemaVersion {
+    return (
+      this.activeInlineComposition?.toolErrorSchemaVersion ??
+      this.#options.toolErrorSchemaVersion ??
+      LEGACY_TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+    );
+  }
+
   private recordPlayCallStep(input: {
     playId: string;
     execution?: 'inline';
@@ -2197,6 +2224,7 @@ export class PlayContextImpl {
     error: string,
     leaseId?: string | null,
     failureKind?: WorkReceiptFailureKind | null,
+    errorPayload?: ToolExecutionFailureV1 | null,
   ): Promise<RuntimeStepReceipt | null> {
     if (!this.#options.failRuntimeStepReceipt) {
       return null;
@@ -2207,6 +2235,7 @@ export class PlayContextImpl {
       runAttempt: this.currentRunAttempt,
       ...(leaseId ? { leaseId } : {}),
       ...(failureKind ? { failureKind } : {}),
+      ...(errorPayload ? { errorPayload } : {}),
       error,
     });
     if (!failed || typeof failed.key !== 'string' || !failed.key.trim()) {
@@ -2642,6 +2671,7 @@ export class PlayContextImpl {
       error: string;
       leaseId?: string | null;
       failureKind?: WorkReceiptFailureKind | null;
+      errorPayload?: ToolExecutionFailureV1 | null;
     }>,
   ): Promise<Map<string, RuntimeStepReceipt>> {
     const normalizedInputs = receipts.filter((receipt) => receipt.key.trim());
@@ -2664,6 +2694,7 @@ export class PlayContextImpl {
               receipt.error,
               receipt.leaseId,
               receipt.failureKind,
+              receipt.errorPayload,
             ),
           ),
         );
@@ -2786,13 +2817,14 @@ export class PlayContextImpl {
               this.heartbeatRuntimeStepReceipt(receiptKey, runId, leaseId),
           }
         : {}),
-      fail: (receiptKey, runId, error, leaseId, failureKind) =>
+      fail: (receiptKey, runId, error, leaseId, failureKind, errorPayload) =>
         this.failRuntimeStepReceipt(
           receiptKey,
           runId,
           error,
           leaseId,
           failureKind,
+          errorPayload,
         ),
       canPersistFailure: Boolean(this.#options.failRuntimeStepReceipt),
       canPersistCompletion: Boolean(
@@ -2832,6 +2864,7 @@ export class PlayContextImpl {
       receiptKey: key,
       store: this.durableReceiptExecutionStore(),
       maxAttempts,
+      toolErrorSchemaVersion: this.currentToolErrorSchemaVersion,
     });
   }
 
@@ -2848,6 +2881,7 @@ export class PlayContextImpl {
       store: this.durableReceiptExecutionStore(),
       maxAttempts,
       log: (message) => this.log(message),
+      toolErrorSchemaVersion: this.currentToolErrorSchemaVersion,
     });
   }
 
@@ -2910,6 +2944,7 @@ export class PlayContextImpl {
       completedCacheOnly: operation === 'tool',
       requiresExecutionLock: opts.requiresExecutionLock,
       executionLockTtlMs: opts.executionLockTtlMs,
+      toolErrorSchemaVersion: this.currentToolErrorSchemaVersion,
       formatError: (error) => this.formatRuntimeError(error),
       log: (message) => this.log(message),
       execute: opts.execute,
@@ -3635,6 +3670,7 @@ export class PlayContextImpl {
             runId: this.currentReceiptOwnerRunId,
             leaseId: request.receiptLeaseId ?? null,
             error: message,
+            errorPayload: serializeToolExecutionFailure(error),
             failureKind: runtimeReceiptFailureKindForError(error),
           },
         ]);
@@ -7008,6 +7044,11 @@ export class PlayContextImpl {
         `Unable to resolve play "${resolvedName}" for ctx.runPlay(...).`,
       );
     }
+    const childToolErrorSchemaVersion = normalizePlayContractCompatibility(
+      resolvedPlay.contractSnapshot?.compatibility ??
+        resolvedPlay.artifact?.compatibility ??
+        buildPlayContractCompatibility(),
+    ).toolErrorSchemaVersion;
     const childExecutionDecision = resolveChildExecutionStrategy({
       pipeline: resolvedPlay.staticPipeline,
       timeoutMs: options?.timeoutMs,
@@ -7078,6 +7119,7 @@ export class PlayContextImpl {
             governor: inlineChildGovernor,
             playName: resolvedName,
             staticPipeline: resolvedPlay.staticPipeline ?? null,
+            toolErrorSchemaVersion: childToolErrorSchemaVersion,
           },
           () => this.executeResolvedPlay(resolvedPlay, this, input),
         );
@@ -8023,7 +8065,11 @@ export class PlayContextImpl {
                 await this.rejectToolCall(
                   toolId,
                   request,
-                  new Error(reclaimed.error ?? 'Durable tool call failed.'),
+                  runtimeReceiptFailureError(
+                    reclaimed,
+                    'Durable tool call failed',
+                    this.currentToolErrorSchemaVersion,
+                  ),
                 );
               }
               return;
@@ -8194,7 +8240,11 @@ export class PlayContextImpl {
                 await this.rejectToolCall(
                   toolId,
                   request,
-                  new Error(claim.error ?? 'Durable tool call failed.'),
+                  runtimeReceiptFailureError(
+                    claim,
+                    'Durable tool call failed',
+                    this.currentToolErrorSchemaVersion,
+                  ),
                 );
               }
               continue;
@@ -8668,6 +8718,7 @@ export class PlayContextImpl {
       ? 'execute-fenced-v1'
       : 'execute';
     const url = `${this.#options.baseUrl}/api/v2/integrations/${encodeURIComponent(toolId)}/${executeSuffix}`;
+    const toolErrorSchemaVersion = this.currentToolErrorSchemaVersion;
     const timeoutMs = resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs);
     const provider = toolId.split(/[._]/)[0]?.trim() || 'provider';
     const activityId = `provider:${toolId}`;
@@ -8678,11 +8729,39 @@ export class PlayContextImpl {
     // execution. Per-provider rate admission is intentionally deferred until
     // each physical fetch is ready to leave this process.
     const admissionStartedAt = Date.now();
-    const toolSlot = await this.resourceGovernor.acquireTool({
-      orgId: this.#options.orgId ?? null,
-      providerResourceKey: `tool:${toolId}`,
-      toolId,
-    });
+    const toolSlot = await this.resourceGovernor
+      .acquireTool({
+        orgId: this.#options.orgId ?? null,
+        providerResourceKey: `tool:${toolId}`,
+        toolId,
+      })
+      .catch((error: unknown) => {
+        if (!(error instanceof ProviderExhaustedError)) throw error;
+        const retryAtMs = Date.parse(error.retryAt);
+        throw createToolHttpError(
+          toolErrorSchemaVersion,
+          error.message,
+          null,
+          429,
+          'repairable',
+          {
+            toolId,
+            provider: error.provider,
+            operation: toolId,
+            code: error.code,
+            origin: 'provider',
+            category: 'rate_limit',
+            retryable: true,
+            statusCode: 429,
+            requestId: null,
+            retryAfterMs: Number.isFinite(retryAtMs)
+              ? Math.max(0, retryAtMs - Date.now())
+              : null,
+            networkKind: null,
+            networkScope: null,
+          },
+        );
+      });
     if (runtimeReceiptReadTraceEnabled) {
       this.log(
         `[perf] tool call id=${toolId} phase=governor_admission elapsed_ms=${Date.now() - admissionStartedAt}`,
@@ -8822,11 +8901,30 @@ export class PlayContextImpl {
               await this.sleepWithCheckpointHeartbeat(retryAfterMs);
               return;
             }
-            throw new ToolHttpError(
+            throw createToolHttpError(
+              toolErrorSchemaVersion,
               `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${diagnostic.message ?? 'unknown transport error'}`,
               null,
               0,
               'repairable',
+              {
+                toolId,
+                provider,
+                operation: toolId,
+                code: 'NETWORK_ERROR',
+                origin: 'deepline',
+                category: 'network',
+                retryable: false,
+                statusCode: null,
+                requestId: input.requestId,
+                retryAfterMs: null,
+                networkKind: diagnostic.message
+                  ?.toLowerCase()
+                  .includes('timed out')
+                  ? 'timeout'
+                  : 'unavailable',
+                networkScope: 'runtime_to_deepline',
+              },
             );
           };
 
@@ -8916,6 +9014,9 @@ export class PlayContextImpl {
                         V2_EXECUTE_RESPONSE_CONTRACT,
                       [EXECUTE_RESPONSE_INTENT_HEADER]: 'dataset',
                       [EXECUTE_TOOL_METADATA_HEADER]: 'true',
+                      [TOOL_EXECUTION_ERROR_SCHEMA_HEADER]: String(
+                        toolErrorSchemaVersion,
+                      ),
                       'x-deepline-request-id': deeplineRequestId,
                       ...(providerIdempotencyKey
                         ? {
@@ -8982,7 +9083,8 @@ export class PlayContextImpl {
                 throw heartbeatFailure;
               }
               if (error instanceof ToolExecuteInvalidJsonError) {
-                throw new ToolHttpError(
+                throw createToolHttpError(
+                  toolErrorSchemaVersion,
                   `Tool ${toolId} returned an invalid JSON response body.`,
                   null,
                   response?.status ?? 0,
@@ -9003,7 +9105,8 @@ export class PlayContextImpl {
                 response?.status === 402
               ) {
                 const diagnostic = describeTransportError(transportError);
-                throw new ToolHttpError(
+                throw createToolHttpError(
+                  toolErrorSchemaVersion,
                   `Tool ${toolId} returned HTTP 402 but its response body could not be read; the run was halted because the payment or capacity denial could not be classified safely: ${diagnostic.message ?? 'unknown transport error'}`,
                   {
                     kind: 'billing_cap_exceeded',
@@ -9069,7 +9172,8 @@ export class PlayContextImpl {
                   error instanceof ToolExecuteResponseBodyTransportError
                     ? 'response body transport failed after response headers'
                     : 'request transport failed after dispatch before response headers';
-                throw new ToolHttpError(
+                throw createToolHttpError(
+                  toolErrorSchemaVersion,
                   `Tool ${toolId} ${failureBoundary}; the ambiguous call was not retried because this runtime has no durable invocation fence: ${diagnostic.message ?? 'unknown transport error'}`,
                   null,
                   0,
@@ -9147,6 +9251,7 @@ export class PlayContextImpl {
                 status: response.status,
                 attempt: httpFailureAttempt,
                 bodyText: text,
+                schemaVersion: toolErrorSchemaVersion,
                 retryAfterHeader: response.headers.get('retry-after'),
                 transientHttpRetrySafe: retrySafeTransientHttp,
                 ...(providerCallElapsedMs !== null
@@ -9230,7 +9335,8 @@ export class PlayContextImpl {
             }
 
             if (!responseData) {
-              throw new ToolHttpError(
+              throw createToolHttpError(
+                toolErrorSchemaVersion,
                 `Tool ${toolId} returned an empty successful response body.`,
                 null,
                 response.status,

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

@@ -26,6 +26,10 @@ import type { WorkReceiptFailureKind } from './work-receipts';
 import type { RunExecutionScope } from './run-execution-scope';
 import type { PlayCallExecution } from './play-call-execution';
 import type { PlayActivityEvent } from './activity-observation';
+import type {
+  ToolExecutionErrorSchemaVersion,
+  ToolExecutionFailureV1,
+} from '../tool-execution-error';
 
 export interface RowState {
   results: Map<string, unknown>;
@@ -41,6 +45,7 @@ export interface ToolCallRequest {
   receiptLeaseExpiresAt?: string | null;
   force?: boolean;
   forceFailedRefresh?: boolean;
+  requiresExecutionFence?: boolean;
   rowId: number;
   fieldName?: string;
   toolId: string;
@@ -62,6 +67,7 @@ export interface RuntimeStepReceipt {
   status: 'queued' | 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
   output?: unknown;
   error?: string;
+  errorPayload?: ToolExecutionFailureV1 | null;
   failureKind?: WorkReceiptFailureKind | null;
   runId?: string | null;
   leaseId?: string | null;
@@ -127,6 +133,7 @@ export interface FailRuntimeStepReceiptInput {
   runAttempt?: number | null;
   leaseId?: string | null;
   error: string;
+  errorPayload?: ToolExecutionFailureV1 | null;
   failureKind?: WorkReceiptFailureKind | null;
 }
 
@@ -188,6 +195,7 @@ export interface FailRuntimeStepReceiptsInput {
     runAttempt?: number | null;
     leaseId?: string | null;
     error: string;
+    errorPayload?: ToolExecutionFailureV1 | null;
     failureKind?: WorkReceiptFailureKind | null;
   }>;
 }
@@ -509,6 +517,8 @@ export type IntegrationEventWaitHandler = {
 export interface ContextOptions {
   /** Immutable logical and physical execution identity for this context. */
   executionScope?: RunExecutionScope;
+  /** Error shape pinned by the immutable play artifact; missing preserves legacy schema 0. */
+  toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   /** Short-lived HMAC-signed internal token for tool callbacks. Required for cloud execution. */
   executorToken?: string;
   baseUrl?: string;

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

@@ -20,6 +20,14 @@ import {
   runtimeLeaseHeartbeatIntervalMs,
 } from './lease-policy';
 import { createRuntimeReceiptHeartbeatSupervisor } from './receipt-heartbeat-supervisor';
+import {
+  deserializeToolExecutionFailure,
+  serializeToolExecutionFailure,
+} from '../tool-execution-error';
+import type {
+  ToolExecutionErrorSchemaVersion,
+  ToolExecutionFailureV1,
+} from '../tool-execution-error';
 
 const DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS = 240;
 const DURABLE_RECEIPT_WAIT_DELAY_MS = 250;
@@ -196,6 +204,7 @@ export type DurableReceiptExecutionStore = {
     error: string,
     leaseId?: string | null,
     failureKind?: WorkReceiptFailureKind | null,
+    errorPayload?: ToolExecutionFailureV1 | null,
   ): Promise<RuntimeStepReceipt | null>;
   canPersistFailure: boolean;
   canPersistCompletion: boolean;
@@ -290,12 +299,28 @@ export function runtimeReceiptOutput<T>(receipt: RuntimeStepReceipt): T {
     : (receipt.output as T);
 }
 
+export function runtimeReceiptFailureError(
+  receipt: RuntimeStepReceipt,
+  legacyPrefix: string,
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion,
+): Error {
+  const message = receipt.error ?? 'unknown error';
+  return (
+    deserializeToolExecutionFailure(
+      message,
+      receipt.errorPayload,
+      toolErrorSchemaVersion,
+    ) ?? new Error(`${legacyPrefix}: ${message}`)
+  );
+}
+
 export async function waitForCompletedRuntimeReceipt(input: {
   receiptKey: string;
   store: Pick<DurableReceiptExecutionStore, 'getMany'>;
   maxAttempts?: number;
   delayMs?: number;
   abortSignal?: AbortSignal;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
 }): Promise<RuntimeStepReceipt> {
   const maxAttempts = input.maxAttempts ?? DURABLE_RECEIPT_WAIT_MAX_ATTEMPTS;
   const delayMs = input.delayMs ?? DURABLE_RECEIPT_WAIT_DELAY_MS;
@@ -311,8 +336,10 @@ export async function waitForCompletedRuntimeReceipt(input: {
       return receipt;
     }
     if (receipt?.status === 'failed') {
-      throw new Error(
-        `Durable tool call ${input.receiptKey} failed: ${receipt.error ?? 'unknown error'}`,
+      throw runtimeReceiptFailureError(
+        receipt,
+        `Durable tool call ${input.receiptKey} failed`,
+        input.toolErrorSchemaVersion,
       );
     }
   }
@@ -326,6 +353,7 @@ export async function waitForCompletedRuntimeReceipts(input: {
   delayMs?: number;
   abortSignal?: AbortSignal;
   log?: (message: string) => void;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
 }): Promise<{
   completed: Map<string, RuntimeStepReceipt>;
   failed: Map<string, Error>;
@@ -382,8 +410,10 @@ export async function waitForCompletedRuntimeReceipts(input: {
       if (receipt?.status === 'failed') {
         failed.set(
           key,
-          new Error(
-            `Durable tool call ${key} failed: ${receipt.error ?? 'unknown error'}`,
+          runtimeReceiptFailureError(
+            receipt,
+            `Durable tool call ${key} failed`,
+            input.toolErrorSchemaVersion,
           ),
         );
         pending.delete(key);
@@ -424,9 +454,13 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   completedCacheOnly?: boolean;
   requiresExecutionLock?: boolean;
   executionLockTtlMs?: number;
+  toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
   formatError: (error: unknown) => string;
   log: (message: string) => void;
-  execute: (context: { leaseId: string | null }) => Promise<T>;
+  execute: (context: {
+    leaseId: string | null;
+    signal?: AbortSignal;
+  }) => Promise<T>;
 }): Promise<T> {
   const lifecycleStartedAt = Date.now();
   const logPhase = (phase: string, startedAt: number): void => {
@@ -477,6 +511,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     let lockSupervisor: ReturnType<
       typeof createRuntimeReceiptHeartbeatSupervisor
     > | null = null;
+    const executionAbortController = needsLock ? new AbortController() : null;
     if (needsLock) {
       if (
         !input.store.acquireExecutionLock ||
@@ -521,7 +556,9 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       const lockTtlMs =
         input.executionLockTtlMs ?? TOOL_RECEIPT_DEFAULT_WAIT_MS;
       lockSupervisor = createRuntimeReceiptHeartbeatSupervisor({
-        intervalMs: Math.max(1_000, Math.floor(lockTtlMs / 3)),
+        intervalMs:
+          input.heartbeatIntervalMs ??
+          Math.max(1_000, Math.floor(lockTtlMs / 3)),
         heartbeat: async () => {
           const renewed = await input.store.acquireExecutionLock!({
             receiptKey: input.receiptKey,
@@ -542,6 +579,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
           input.log(
             `ctx.${input.operation}(${input.id}): dangerous side-effect execution fence lost: ${error instanceof Error ? error.message : String(error)}`,
           );
+          executionAbortController?.abort(error);
         },
       });
       lockSupervisor.start();
@@ -559,7 +597,11 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
     };
     let executed: T;
     try {
-      executed = await input.execute({ leaseId: null });
+      executed = await input.execute({
+        leaseId: null,
+        signal: executionAbortController?.signal,
+      });
+      executionAbortController?.signal.throwIfAborted();
     } catch (error) {
       await releaseOwnLock();
       throw error;
@@ -622,8 +664,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       };
     }
     if (reclaimed?.status === 'failed') {
-      throw new Error(
-        `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused: ${reclaimed.error ?? 'unknown error'}.`,
+      throw runtimeReceiptFailureError(
+        reclaimed,
+        `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused`,
+        input.toolErrorSchemaVersion,
       );
     }
     if (
@@ -654,6 +698,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
         store: input.store,
         maxAttempts: input.runningReceiptWaitMaxAttempts,
         delayMs: input.runningReceiptWaitDelayMs,
+        toolErrorSchemaVersion: input.toolErrorSchemaVersion,
       }),
       'in_flight',
     ),
@@ -684,8 +729,10 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
   const repairFailedReceipt = async (
     receipt: RuntimeStepReceipt,
   ): Promise<never> => {
-    throw new Error(
-      `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused: ${receipt.error ?? 'unknown error'}.`,
+    throw runtimeReceiptFailureError(
+      receipt,
+      `ctx.${input.operation}(${input.id}): previous execution failed and cannot be reused`,
+      input.toolErrorSchemaVersion,
     );
   };
 
@@ -810,6 +857,7 @@ export async function executeWithDurableRuntimeReceipt<T>(input: {
       input.formatError(error),
       ownedLeaseId,
       runtimeReceiptFailureKindForError(error),
+      serializeToolExecutionFailure(error),
     );
     if (!failed && input.store.canPersistFailure) {
       throw new Error(

package/dist/bundling-sources/shared_libs/play-runtime/execution-ledger-store.ts

@@ -9,6 +9,7 @@ import type {
   WorkReceiptFailureKind,
   WorkReceiptGetCommand,
 } from './work-receipts';
+import type { ToolExecutionFailureV1 } from '../tool-execution-error';
 
 export type WorkReceiptBatchGetCommand = {
   playName: string;
@@ -21,6 +22,7 @@ export type WorkReceiptCompleteCommand = WorkReceiptCommand & {
 
 export type WorkReceiptFailCommand = WorkReceiptCommand & {
   error: string;
+  errorPayload?: ToolExecutionFailureV1 | null;
   failureKind?: WorkReceiptFailureKind | null;
 };
 
@@ -114,9 +116,7 @@ export interface ExecutionLedgerStore {
   failReceipts(
     input: WorkReceiptBatchFailCommand,
   ): Promise<Array<WorkReceipt | null>>;
-  releaseReceipt(
-    input: WorkReceiptReleaseCommand,
-  ): Promise<WorkReceipt | null>;
+  releaseReceipt(input: WorkReceiptReleaseCommand): Promise<WorkReceipt | null>;
   skipReceipt(input: WorkReceiptSkipCommand): Promise<WorkReceipt | null>;
   heartbeatReceipts(
     input: WorkReceiptBatchHeartbeatCommand,

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

@@ -59,11 +59,6 @@ export type ExecutionPlan = {
     datasetBacking: 'neon_sheet';
     compactWorkflowState: true;
   };
-  sdkContract: {
-    apiVersion: number;
-    artifactVersion: number;
-    minRunnerVersion: number;
-  };
 };
 
 export type BuildExecutionPlanInput = {
@@ -73,11 +68,6 @@ export type BuildExecutionPlanInput = {
   assets?: Array<{ playPath?: string | null; storageKey: string }>;
   staticPipeline?: PlayStaticPipeline | null;
   totalRows?: number | null;
-  sdkContract?: {
-    apiVersion?: number | null;
-    artifactVersion?: number | null;
-    minRunnerVersion?: number | null;
-  } | null;
 };
 
 export function buildExecutionPlan(
@@ -120,11 +110,6 @@ export function buildExecutionPlan(
       datasetBacking: 'neon_sheet',
       compactWorkflowState: true,
     },
-    sdkContract: {
-      apiVersion: input.sdkContract?.apiVersion ?? 1,
-      artifactVersion: input.sdkContract?.artifactVersion ?? 1,
-      minRunnerVersion: input.sdkContract?.minRunnerVersion ?? 1,
-    },
   };
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/protocol.ts

@@ -13,6 +13,7 @@ import type { PacingRule } from './governor/rate-state-backend';
 import type { GovernanceSnapshot } from './governor/governor';
 import type { PlayRunInputPayload } from './play-input';
 import type { PlayRunFailureDetails } from './run-failure';
+import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
 
 export type PlayRunnerRateStateBackendConfig =
   | {
@@ -103,6 +104,8 @@ export interface PlayRunnerContextConfig {
   runtimeTestFaultHeader?: string | null;
   vercelProtectionBypassToken?: string | null;
   integrationMode?: 'live' | 'eval_stub' | 'fixture';
+  /** Immutable tool-error payload schema copied from the run contract. */
+  toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   orgId?: string;
   workflowId?: string;
   playId?: string;

package/dist/bundling-sources/shared_libs/play-runtime/runtime-actions.ts

@@ -4,6 +4,7 @@ import type { PlayRowUpdate } from './ctx-types';
 import type { PlaySheetContract } from '../plays/static-pipeline';
 import type { PlayRunLedgerEvent } from './run-ledger';
 import type { WorkReceiptFailureKind } from './work-receipts';
+import type { ToolExecutionFailureV1 } from '../tool-execution-error';
 
 export type RuntimeAppendRunEventsAction = {
   action: 'append_run_events';
@@ -165,6 +166,7 @@ export type RuntimeReceiptAction =
       runAttempt?: number | null;
       leaseId?: string | null;
       error: string;
+      errorPayload?: ToolExecutionFailureV1 | null;
       failureKind?: WorkReceiptFailureKind | null;
     }
   | {
@@ -230,6 +232,7 @@ export type RuntimeReceiptCompletion = RuntimeReceiptLease & {
 
 export type RuntimeReceiptFailure = RuntimeReceiptLease & {
   error: string;
+  errorPayload?: ToolExecutionFailureV1 | null;
   failureKind?: WorkReceiptFailureKind | null;
 };