deepline 0.2.12 → 0.2.14

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

@@ -142,7 +142,17 @@ import {
   buildDurableToolCallCacheKey,
   buildDurableToolProviderIdempotencyKey,
   buildDurableToolReceiptPrefix,
+  resolveDurableCallCachePolicy,
 } from './durable-call-cache';
+import {
+  PLAY_AUTHORING_CONTRACT_EDITION,
+  normalizePlayAuthoringCustomerDbStatement,
+  validateOptionalPlayAuthoringField,
+  validatePlayAuthoringField,
+  type PlayAuthoringContractEdition,
+  type PlaySqlQuery,
+  type PlayAuthoringRuntimeContext,
+} from '../plays/authoring-contract';
 import {
   RuntimeReceiptLeaseLostError,
   RuntimeReceiptWaitTimeoutError,
@@ -236,7 +246,7 @@ import {
 import type {
   CsvOptions,
   RowState,
-  DatasetOptions,
+  RuntimeDatasetOptions,
   ToolCallRequest,
   ToolBatchResult,
   ContextOptions,
@@ -248,7 +258,7 @@ import type {
   MapFieldDefinition,
   MapFieldResolver,
   ToolCallOptions,
-  StepOptions,
+  RuntimeStepOptions,
   FetchOptions,
   ResolvedPlayExecution,
   PlayFetchResponse,
@@ -304,6 +314,8 @@ type InlineCompositionStore = {
   staticPipeline: ContextOptions['staticPipeline'];
   /** Immutable error contract pinned by the child play artifact. */
   toolErrorSchemaVersion: ToolExecutionErrorSchemaVersion;
+  /** Immutable authoring semantics pinned by the child play artifact. */
+  authoringContractEdition: PlayAuthoringContractEdition;
 };
 const inlineCompositionContext =
   new AsyncLocalStorage<InlineCompositionStore>();
@@ -575,13 +587,21 @@ export async function reconcileNodeRuntimeMapResultsWithPersistedSheet(input: {
 export function resolveToolRuntimeTimeoutMs(
   toolId: string,
   requestedTimeoutMs?: number,
+  authoringContractEdition: PlayAuthoringContractEdition = PLAY_AUTHORING_CONTRACT_EDITION,
 ): number | undefined {
-  if (
-    typeof requestedTimeoutMs === 'number' &&
-    Number.isFinite(requestedTimeoutMs) &&
-    requestedTimeoutMs > 0
-  ) {
-    return Math.max(1, Math.ceil(requestedTimeoutMs));
+  if (requestedTimeoutMs !== undefined) {
+    if (authoringContractEdition >= 2) {
+      validatePlayAuthoringField(
+        'ctx.tools.execute.timeoutMs',
+        requestedTimeoutMs,
+      );
+      return requestedTimeoutMs;
+    }
+    // Edition 1 rounded positive finite values and treated every other value
+    // as omitted. Preserve that behavior for already-published artifacts.
+    if (Number.isFinite(requestedTimeoutMs) && requestedTimeoutMs > 0) {
+      return Math.max(1, Math.ceil(requestedTimeoutMs));
+    }
   }
   const normalized = toolId.trim().toLowerCase();
   // Long-inference tools keep their explicit 15-minute budget. Every other tool
@@ -1135,7 +1155,7 @@ class RuntimeDatasetBuilder<T extends Record<string, unknown>> {
   private readonly builder: StepProgramDatasetBuilder<
     RuntimeStepProgramStep,
     RuntimeStepProgramStep['resolver'],
-    DatasetOptions<T>,
+    RuntimeDatasetOptions<T>,
     Promise<PlayDataset<Record<string, unknown>>>
   >;
 
@@ -1181,7 +1201,7 @@ class RuntimeDatasetBuilder<T extends Record<string, unknown>> {
   }
 
   run(
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): Promise<PlayDataset<Record<string, unknown>>> {
     return this.builder.run(options);
   }
@@ -1288,7 +1308,20 @@ function createPacingResolver(
   };
 }
 
-export class PlayContextImpl {
+type ScalarPlayAuthoringRuntimeContext = Pick<
+  PlayAuthoringRuntimeContext,
+  | 'tools'
+  | 'customerDb'
+  | 'tool'
+  | 'step'
+  | 'fetch'
+  | 'secrets'
+  | 'runPlay'
+  | 'log'
+  | 'sleep'
+>;
+
+export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
   private rowStates = new Map<number, RowState>();
   private toolCallQueue: ToolCallRequest[] = [];
   private pendingRuntimeToolOwnershipAssertions: Array<{
@@ -1423,7 +1456,7 @@ export class PlayContextImpl {
       input: Record<string, unknown>;
       description?: string;
       force?: boolean;
-      staleAfterSeconds?: number;
+      staleAfterSeconds?: number | null;
       timeoutMs?: number;
       receiptWaitMs?: number;
     }): Promise<TOutput> => {
@@ -1432,20 +1465,37 @@ export class PlayContextImpl {
           'ctx.tools.execute requires a request object: ctx.tools.execute({ id, tool, input, description }).',
         );
       }
+      validatePlayAuthoringField('ctx.tools.execute.id', request.id);
+      validatePlayAuthoringField('ctx.tools.execute.tool', request.tool);
+      validatePlayAuthoringField('ctx.tools.execute.input', request.input);
+      if (request.description !== undefined) {
+        validatePlayAuthoringField(
+          'ctx.tools.execute.description',
+          request.description,
+        );
+      }
+      if (request.force !== undefined) {
+        validatePlayAuthoringField('ctx.tools.execute.force', request.force);
+      }
+      assertNoSecretTaint(request.input, 'ctx.tools.execute input');
       if (
-        typeof request.id !== 'string' ||
-        !request.id.trim() ||
-        typeof request.tool !== 'string' ||
-        !request.tool.trim() ||
-        !request.input ||
-        typeof request.input !== 'object' ||
-        Array.isArray(request.input)
+        request.timeoutMs !== undefined &&
+        this.currentAuthoringContractEdition >= 2
       ) {
-        throw new Error(
-          'ctx.tools.execute({ id, tool, input }) requires a non-empty id, tool string, and input object.',
+        validatePlayAuthoringField(
+          'ctx.tools.execute.timeoutMs',
+          request.timeoutMs,
+        );
+      }
+      if (
+        request.receiptWaitMs !== undefined &&
+        this.currentAuthoringContractEdition >= 2
+      ) {
+        validatePlayAuthoringField(
+          'ctx.tools.execute.receiptWaitMs',
+          request.receiptWaitMs,
         );
       }
-      assertNoSecretTaint(request.input, 'ctx.tools.execute input');
       const force =
         request.force === true ||
         toolExecutionOverrides.getStore()?.force === true;
@@ -1478,19 +1528,55 @@ export class PlayContextImpl {
     },
   };
 
+  async tool<TOutput = unknown>(
+    key: string,
+    toolId: string,
+    input: Record<string, unknown>,
+    options?: { description?: string },
+  ): Promise<ToolExecuteResult<TOutput>> {
+    validatePlayAuthoringField('ctx.tool.key', key);
+    validatePlayAuthoringField('ctx.tool.tool', toolId);
+    validatePlayAuthoringField('ctx.tool.input', input);
+    if (options?.description !== undefined) {
+      validatePlayAuthoringField(
+        'ctx.tool.options.description',
+        options.description,
+      );
+    }
+    return (await this.tools.execute<ToolExecuteResult<TOutput>>({
+      id: key,
+      tool: toolId,
+      input,
+      ...(options?.description ? { description: options.description } : {}),
+    })) as ToolExecuteResult<TOutput>;
+  }
+
   async __deeplineRunWithForcedTools<T>(run: () => Promise<T>): Promise<T> {
     return await toolExecutionOverrides.run({ force: true }, run);
   }
   readonly customerDb = {
     query: async <TRow extends object = Record<string, unknown>>(
-      statement: string,
+      statement: PlaySqlQuery | string,
       options?: { maxRows?: number; timeoutMs?: number },
     ): Promise<TRow[]> => {
+      const sql = normalizePlayAuthoringCustomerDbStatement(statement);
+      if (options?.maxRows !== undefined) {
+        validatePlayAuthoringField(
+          'ctx.customerDb.query.options.maxRows',
+          options.maxRows,
+        );
+      }
+      if (options?.timeoutMs !== undefined) {
+        validatePlayAuthoringField(
+          'ctx.customerDb.query.options.timeoutMs',
+          options.timeoutMs,
+        );
+      }
       const result = (await this.tools.execute({
         id: `customer_db_query_${this.customerDbQueryIndex++}`,
         tool: 'query_customer_db',
         input: {
-          sql: statement,
+          sql,
           ...(options?.maxRows !== undefined
             ? { max_rows: options.maxRows }
             : {}),
@@ -1681,6 +1767,14 @@ export class PlayContextImpl {
     );
   }
 
+  private get currentAuthoringContractEdition(): PlayAuthoringContractEdition {
+    return (
+      this.activeInlineComposition?.authoringContractEdition ??
+      this.#options.authoringContractEdition ??
+      PLAY_AUTHORING_CONTRACT_EDITION
+    );
+  }
+
   private recordPlayCallStep(input: {
     playId: string;
     execution?: 'inline';
@@ -2276,23 +2370,16 @@ export class PlayContextImpl {
     if (!this.#options.heartbeatRuntimeStepReceipts) {
       return await this.assertRuntimeToolReceiptOwnership(requests);
     }
-    const byLeaseId = new Map<string, string[]>();
-    for (const target of targets) {
-      const keys = byLeaseId.get(target.leaseId) ?? [];
-      keys.push(target.receiptKey);
-      byLeaseId.set(target.leaseId, keys);
-    }
-    await Promise.all(
-      [...byLeaseId].map(async ([leaseId, keys]) => {
-        const receipts = await this.#options.heartbeatRuntimeStepReceipts!({
-          runId: this.currentReceiptOwnerRunId,
-          runAttempt: this.currentRunAttempt,
-          leaseId,
-          keys,
-        });
-        this.assertRuntimeToolReceiptHeartbeatResult(keys, leaseId, receipts);
-      }),
-    );
+    const uniqueTargets = [
+      ...new Map(targets.map((target) => [target.receiptKey, target])).values(),
+    ];
+    const receipts = await this.#options.heartbeatRuntimeStepReceipts({
+      runId: this.currentReceiptOwnerRunId,
+      runAttempt: this.currentRunAttempt,
+      keys: uniqueTargets.map((target) => target.receiptKey),
+      leaseIds: uniqueTargets.map((target) => target.leaseId),
+    });
+    this.assertRuntimeToolReceiptHeartbeatResults(uniqueTargets, receipts);
   }
 
   private async flushRuntimeToolOwnershipAssertionBatch(): Promise<void> {
@@ -2303,26 +2390,24 @@ export class PlayContextImpl {
 
     if (this.#options.heartbeatRuntimeStepReceipts) {
       try {
-        const byLeaseId = new Map<string, string[]>();
-        for (const target of targets) {
-          const keys = byLeaseId.get(target.leaseId) ?? [];
-          keys.push(target.receiptKey);
-          byLeaseId.set(target.leaseId, keys);
-        }
+        const uniqueTargets = [
+          ...new Map(
+            targets.map((target) => [target.receiptKey, target]),
+          ).values(),
+        ];
+        const receipts = await this.#options.heartbeatRuntimeStepReceipts({
+          runId: this.currentReceiptOwnerRunId,
+          runAttempt: this.currentRunAttempt,
+          keys: uniqueTargets.map((target) => target.receiptKey),
+          leaseIds: uniqueTargets.map((target) => target.leaseId),
+        });
         const renewed = new Map<string, RuntimeStepReceipt | null>();
-        await Promise.all(
-          [...byLeaseId].map(async ([leaseId, keys]) => {
-            const receipts = await this.#options.heartbeatRuntimeStepReceipts!({
-              runId: this.currentReceiptOwnerRunId,
-              runAttempt: this.currentRunAttempt,
-              leaseId,
-              keys,
-            });
-            for (let index = 0; index < keys.length; index += 1) {
-              renewed.set(keys[index]!, receipts[index] ?? null);
-            }
-          }),
-        );
+        for (let index = 0; index < uniqueTargets.length; index += 1) {
+          renewed.set(
+            uniqueTargets[index]!.receiptKey,
+            receipts[index] ?? null,
+          );
+        }
         for (const assertion of assertions) {
           const lost = assertion.targets.find((target) => {
             const receipt = renewed.get(target.receiptKey);
@@ -2385,21 +2470,21 @@ export class PlayContextImpl {
     for (const assertion of assertions) assertion.reject(error);
   }
 
-  private assertRuntimeToolReceiptHeartbeatResult(
-    keys: string[],
-    leaseId: string,
+  private assertRuntimeToolReceiptHeartbeatResults(
+    targets: Array<{ receiptKey: string; leaseId: string }>,
     receipts: Array<RuntimeStepReceipt | null>,
   ): void {
-    for (let index = 0; index < keys.length; index += 1) {
+    for (let index = 0; index < targets.length; index += 1) {
+      const target = targets[index]!;
       const receipt = this.normalizeRuntimeStepReceipt(
-        keys[index] ?? '',
+        target.receiptKey,
         receipts[index],
       );
-      if (!this.runtimeToolReceiptStillOwned(receipt, leaseId)) {
+      if (!this.runtimeToolReceiptStillOwned(receipt, target.leaseId)) {
         throw new RuntimeReceiptLeaseLostError({
-          receiptKey: keys[index] ?? 'unknown',
+          receiptKey: target.receiptKey,
           runId: this.currentReceiptOwnerRunId,
-          leaseId,
+          leaseId: target.leaseId,
         });
       }
     }
@@ -3146,6 +3231,14 @@ export class PlayContextImpl {
       execute: (context: { leaseId: string | null }) => Promise<T>;
     },
   ): Promise<T> {
+    const stalePolicy = resolveDurableCallCachePolicy(
+      opts.staleAfterSeconds,
+      operation === 'step'
+        ? 'ctx.step.staleAfterSeconds'
+        : operation === 'fetch'
+          ? 'ctx.fetch.staleAfterSeconds'
+          : 'ctx.tools.execute.staleAfterSeconds',
+    );
     const receiptKey =
       opts.receiptKey?.trim() ||
       durableCtxKey({
@@ -3154,7 +3247,7 @@ export class PlayContextImpl {
         operation,
         id,
         semanticKey: opts.semanticKey,
-        staleAfterSeconds: opts.staleAfterSeconds,
+        staleAfterSeconds: stalePolicy.staleAfterSeconds,
       });
     return await executeWithDurableRuntimeReceipt<T>({
       operation,
@@ -3162,7 +3255,7 @@ export class PlayContextImpl {
       runId: this.currentReceiptOwnerRunId,
       receiptKey,
       store: this.durableReceiptExecutionStore(),
-      force: opts.force,
+      force: opts.force === true || stalePolicy.forceRefresh,
       repairRunningReceiptForSameRun: opts.repairRunningReceiptForSameRun,
       repairRunningReceiptForSameRunAfterWaitTimeout:
         opts.repairRunningReceiptForSameRunAfterWaitTimeout,
@@ -3492,15 +3585,20 @@ export class PlayContextImpl {
     forceFailedRefresh: boolean;
     staleAfterSeconds?: number | null;
   } {
+    const stalePolicy = resolveDurableCallCachePolicy(
+      options?.staleAfterSeconds,
+    );
     return {
       force:
         options?.force === true ||
+        stalePolicy.forceRefresh ||
         this.#options.cachePolicy?.forceToolRefresh === true,
       forceFailedRefresh:
         options?.force === true ||
+        stalePolicy.forceRefresh ||
         this.#options.cachePolicy?.forceToolRefresh === true ||
         this.#options.cachePolicy?.forceFailedToolRefresh === true,
-      staleAfterSeconds: options?.staleAfterSeconds ?? null,
+      staleAfterSeconds: stalePolicy.staleAfterSeconds,
     };
   }
 
@@ -4033,10 +4131,19 @@ export class PlayContextImpl {
 
   async csv(
     path: string,
-    _options?: CsvOptions,
+    options?: CsvOptions,
   ): Promise<PlayDataset<Record<string, unknown>>> {
     this.assertInlineChildContract('dataset_child');
-    void _options;
+    if (options) {
+      for (const [field, value] of [
+        ['ctx.csv.options.description', options.description],
+        ['ctx.csv.options.columns', options.columns],
+        ['ctx.csv.options.rename', options.rename],
+        ['ctx.csv.options.required', options.required],
+      ] as const) {
+        validateOptionalPlayAuthoringField(field, value);
+      }
+    }
     // In cloud mode, CSV data is passed in — path is just a label
     // The activity loads the actual data before creating the ctx
     throw new Error(
@@ -4053,7 +4160,7 @@ export class PlayContextImpl {
     key: string,
     items: PlayDatasetInput<T>,
     input: RuntimeStepProgram,
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): Promise<PlayDataset<Record<string, unknown>>>;
   dataset<
     T extends Record<string, unknown>,
@@ -4062,7 +4169,7 @@ export class PlayContextImpl {
     key: string,
     items: PlayDatasetInput<T>,
     input?: MapFieldDefinition<T, TColumns> | RuntimeStepProgram,
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): RuntimeDatasetBuilder<T> | Promise<PlayDataset<Record<string, unknown>>> {
     this.assertInlineChildContract('dataset_child');
     if (rowContext.getStore()) {
@@ -4091,7 +4198,7 @@ export class PlayContextImpl {
     key: string,
     items: PlayDatasetInput<T>,
     input: RuntimeStepProgram,
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): never;
   map<T extends Record<string, unknown>>(
     _key: string,
@@ -4099,7 +4206,7 @@ export class PlayContextImpl {
     _input?:
       | MapFieldDefinition<T, Record<string, unknown>>
       | RuntimeStepProgram,
-    _options?: DatasetOptions<T>,
+    _options?: RuntimeDatasetOptions<T>,
   ): never {
     void _key;
     void _items;
@@ -4112,7 +4219,7 @@ export class PlayContextImpl {
     key: string,
     items: PlayDatasetInput<T>,
     program: RuntimeStepProgram,
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): Promise<PlayDataset<Record<string, unknown>>> {
     const definition = this.stepProgramToMapDefinition(program);
     return this.runMapDefinition(key, items, definition, options);
@@ -4126,7 +4233,11 @@ export class PlayContextImpl {
     if (!isRuntimeStepProgram(program)) {
       throw new Error('ctx.runSteps(program, input) requires steps().');
     }
-    if (options?.description) {
+    if (options?.description !== undefined) {
+      validatePlayAuthoringField(
+        'ctx.runSteps.options.description',
+        options.description,
+      );
       this.log(options.description);
     }
     return (await this.executeStepProgram(program, input, 0, [], {
@@ -4141,13 +4252,28 @@ export class PlayContextImpl {
     key: string,
     items: PlayDatasetInput<T>,
     input: MapFieldDefinition<T, TColumns>,
-    options?: DatasetOptions<T>,
+    options?: RuntimeDatasetOptions<T>,
   ): Promise<PlayDataset<Record<string, unknown>>> {
     if (rowContext.getStore()) {
       throw new Error(
         'Nested ctx.dataset() is not supported. Flatten your columns into one dataset, or keep custom per-row logic inside a single column.',
       );
     }
+    validatePlayAuthoringField('ctx.dataset.key', key);
+    if (options) {
+      validateOptionalPlayAuthoringField(
+        'ctx.dataset.run.description',
+        options.description,
+      );
+      validateOptionalPlayAuthoringField(
+        'ctx.dataset.run.onRowError',
+        options.onRowError,
+      );
+      validateOptionalPlayAuthoringField('ctx.dataset.run.mode', options.mode);
+      if (options.key !== undefined) {
+        validatePlayAuthoringField('ctx.dataset.run.key', options.key);
+      }
+    }
     const normalizedMapKey = this.normalizeContextKey(key, 'map');
 
     const normalizedMapNamespace = normalizeTableNamespace(normalizedMapKey);
@@ -6955,6 +7081,33 @@ export class PlayContextImpl {
     input: Record<string, unknown>,
     options?: ToolCallOptions,
   ): Promise<unknown> {
+    if (options?.description !== undefined) {
+      validatePlayAuthoringField(
+        'ctx.tools.execute.description',
+        options.description,
+      );
+    }
+    if (options?.force !== undefined) {
+      validatePlayAuthoringField('ctx.tools.execute.force', options.force);
+    }
+    if (
+      options?.timeoutMs !== undefined &&
+      this.currentAuthoringContractEdition >= 2
+    ) {
+      validatePlayAuthoringField(
+        'ctx.tools.execute.timeoutMs',
+        options.timeoutMs,
+      );
+    }
+    if (
+      options?.receiptWaitMs !== undefined &&
+      this.currentAuthoringContractEdition >= 2
+    ) {
+      validatePlayAuthoringField(
+        'ctx.tools.execute.receiptWaitMs',
+        options.receiptWaitMs,
+      );
+    }
     const executionScope = this.currentExecutionScope;
     const normalizedKey = this.normalizeContextKey(key, 'tool');
     const toolCachePolicy = this.effectiveToolCallCachePolicy(options);
@@ -7061,7 +7214,11 @@ export class PlayContextImpl {
                 logicalCallId,
               })
             : physicalDirectKey,
-          timeoutMs: resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs),
+          timeoutMs: resolveToolRuntimeTimeoutMs(
+            toolId,
+            options?.timeoutMs,
+            this.currentAuthoringContractEdition,
+          ),
           ...(directReceiptLeaseId &&
           (this.#options.heartbeatRuntimeStepReceipts ||
             this.#options.getRuntimeStepReceipt ||
@@ -7163,6 +7320,7 @@ export class PlayContextImpl {
         const timeoutMs = resolveToolRuntimeTimeoutMs(
           toolId,
           options?.timeoutMs,
+          this.currentAuthoringContractEdition,
         );
         this.enqueueToolCall({
           callId,
@@ -7177,7 +7335,7 @@ export class PlayContextImpl {
           toolId,
           input,
           ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-          ...(typeof options?.receiptWaitMs === 'number'
+          ...(options?.receiptWaitMs !== undefined
             ? { receiptWaitMs: options.receiptWaitMs }
             : {}),
           tableNamespace: store.tableNamespace,
@@ -7214,8 +7372,11 @@ export class PlayContextImpl {
               toolRetryPolicy?.requiresExecutionFence === true,
             executionLockTtlMs: Math.min(
               600_000,
-              resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs) ??
-                300_000,
+              resolveToolRuntimeTimeoutMs(
+                toolId,
+                options?.timeoutMs,
+                this.currentAuthoringContractEdition,
+              ) ?? 300_000,
             ),
             staleAfterSeconds: toolCachePolicy.staleAfterSeconds,
             onClaimedResult: (output, receiptKey) =>
@@ -7237,7 +7398,7 @@ export class PlayContextImpl {
             execute: ({ leaseId }) => executeTool({ leaseId }),
             runningReceiptWaitMaxAttempts:
               resolveRuntimeToolReceiptWaitMaxAttempts(
-                typeof options?.receiptWaitMs === 'number'
+                options?.receiptWaitMs !== undefined
                   ? { max_wait_ms: options.receiptWaitMs }
                   : input,
               ),
@@ -7391,8 +7552,6 @@ export class PlayContextImpl {
     input: Record<string, unknown>,
     options?: PlayCallOptions,
   ): Promise<TOutput> {
-    assertNoSecretTaint(input, 'ctx.runPlay input');
-    const normalizedKey = this.normalizeContextKey(key, 'runPlay');
     if (
       arguments.length === 3 &&
       typeof playRef === 'object' &&
@@ -7405,13 +7564,26 @@ export class PlayContextImpl {
     const resolvedName =
       typeof playRef === 'string'
         ? playRef
-        : typeof playRef.playName === 'string'
+        : playRef && typeof playRef.playName === 'string'
           ? playRef.playName
-          : (playRef.name ?? '');
+          : playRef && typeof playRef.name === 'string'
+            ? playRef.name
+            : '';
 
     if (!resolvedName.trim()) {
       throw new Error('ctx.runPlay(...) requires a resolvable play name.');
     }
+    validatePlayAuthoringField('ctx.runPlay.playRef', playRef);
+    validatePlayAuthoringField('ctx.runPlay.input', input);
+    assertNoSecretTaint(input, 'ctx.runPlay input');
+    validatePlayAuthoringField('ctx.runPlay.key', key);
+    if (options?.description !== undefined) {
+      validatePlayAuthoringField(
+        'ctx.runPlay.options.description',
+        options.description,
+      );
+    }
+    const normalizedKey = this.normalizeContextKey(key, 'runPlay');
     if (!this.#options.resolvePlay) {
       throw new Error(
         'ctx.runPlay(...) is unavailable because no play resolver was configured.',
@@ -7423,11 +7595,13 @@ export class PlayContextImpl {
         `Unable to resolve play "${resolvedName}" for ctx.runPlay(...).`,
       );
     }
-    const childToolErrorSchemaVersion = normalizePlayContractCompatibility(
+    const childCompatibility = normalizePlayContractCompatibility(
       resolvedPlay.contractSnapshot?.compatibility ??
         resolvedPlay.artifact?.compatibility ??
         buildPlayContractCompatibility(),
-    ).toolErrorSchemaVersion;
+    );
+    const childToolErrorSchemaVersion =
+      childCompatibility.toolErrorSchemaVersion;
     const childExecutionDecision = resolveChildExecutionStrategy({
       pipeline: resolvedPlay.staticPipeline,
       timeoutMs: options?.timeoutMs,
@@ -7499,6 +7673,8 @@ export class PlayContextImpl {
             playName: resolvedName,
             staticPipeline: resolvedPlay.staticPipeline ?? null,
             toolErrorSchemaVersion: childToolErrorSchemaVersion,
+            authoringContractEdition:
+              childCompatibility.authoringContractEdition,
           },
           () => this.executeResolvedPlay(resolvedPlay, this, input),
         );
@@ -7680,8 +7856,11 @@ export class PlayContextImpl {
 
   async sleep(ms: number): Promise<void> {
     this.assertInlineChildContract('suspending_child');
+    const delayMs =
+      this.currentAuthoringContractEdition >= 2
+        ? (validatePlayAuthoringField('ctx.sleep.ms', ms), ms)
+        : Math.max(0, Math.round(ms));
     if (this.#options.durableBoundaries) {
-      const delayMs = Math.max(0, Math.round(ms));
       const boundaryId = this.durableBoundaryId(
         `sleep-${this.sleepBoundaryIndex}-${delayMs}`,
       );
@@ -7704,7 +7883,7 @@ export class PlayContextImpl {
         delayMs,
       });
     }
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
   }
 
   async fetch(
@@ -7713,6 +7892,7 @@ export class PlayContextImpl {
     init: SecretAwareRequestInit = {},
     options?: FetchOptions,
   ): Promise<PlayFetchResponse> {
+    validatePlayAuthoringField('ctx.fetch.key', key);
     const normalizedKey = this.normalizeContextKey(key, 'fetch');
     const rowStore = rowContext.getStore();
     const rowFetchScope = rowStore
@@ -7899,8 +8079,13 @@ export class PlayContextImpl {
   async step<T>(
     key: string,
     run: () => T | Promise<T>,
-    options?: StepOptions,
+    options?: RuntimeStepOptions,
   ): Promise<T> {
+    validatePlayAuthoringField('ctx.step.id', key);
+    validateOptionalPlayAuthoringField(
+      'ctx.step.semanticKey',
+      options?.semanticKey,
+    );
     const normalizedKey = this.normalizeContextKey(key, 'step');
     if (!normalizedKey.trim()) {
       throw new Error('ctx.step(key, fn) requires a non-empty stable step id.');
@@ -8040,58 +8225,50 @@ export class PlayContextImpl {
           this.toolCallResolvers.has(request.callId),
         );
         if (unsettled.length === 0) return 'terminal';
-        const byLeaseId = new Map<string, Map<string, ToolCallRequest[]>>();
+        const byReceiptKey = new Map<string, ToolCallRequest[]>();
         for (const request of unsettled) {
-          const leaseId = request.receiptLeaseId!;
-          const byReceiptKey = byLeaseId.get(leaseId) ?? new Map();
           const receiptKey = request.receiptKey!;
           const group = byReceiptKey.get(receiptKey) ?? [];
           group.push(request);
           byReceiptKey.set(receiptKey, group);
-          byLeaseId.set(leaseId, byReceiptKey);
         }
-        await Promise.all(
-          [...byLeaseId].map(async ([leaseId, byReceiptKey]) => {
-            // One content-addressed receipt can have many same-run followers.
-            // The store renews unique receipt rows, not request positions, so
-            // duplicate keys in one heartbeat would yield null duplicate
-            // positions and falsely stop the supervisor as if ownership were
-            // lost.
-            const entries = [...byReceiptKey];
-            const keys = entries.map(([receiptKey]) => receiptKey);
-            const receipts = await heartbeatReceipts({
+        // One content-addressed receipt can have many same-run followers. The
+        // store renews unique receipt rows, not request positions, so dedupe by
+        // key while preserving the matching per-row lease id.
+        const entries = [...byReceiptKey];
+        const keys = entries.map(([receiptKey]) => receiptKey);
+        const leaseIds = entries.map(
+          ([, requests]) => requests[0]!.receiptLeaseId!,
+        );
+        const receipts = await heartbeatReceipts({
+          runId: this.currentReceiptOwnerRunId,
+          runAttempt: this.currentRunAttempt,
+          keys,
+          leaseIds,
+        });
+        for (let index = 0; index < entries.length; index += 1) {
+          const [receiptKey, requests] = entries[index]!;
+          const leaseId = leaseIds[index]!;
+          // Completion can race this bulk heartbeat response. A settled
+          // receipt group no longer needs ownership and must not turn that
+          // race into a false lease-loss failure.
+          if (
+            !requests.some((request) =>
+              this.toolCallResolvers.has(request.callId),
+            )
+          ) {
+            continue;
+          }
+          if (
+            !this.runtimeToolReceiptStillOwned(receipts[index] ?? null, leaseId)
+          ) {
+            throw new RuntimeReceiptLeaseLostError({
+              receiptKey,
               runId: this.currentReceiptOwnerRunId,
-              runAttempt: this.currentRunAttempt,
               leaseId,
-              keys,
             });
-            for (let index = 0; index < entries.length; index += 1) {
-              const [receiptKey, requests] = entries[index]!;
-              // Completion can race this bulk heartbeat response. A settled
-              // receipt group no longer needs ownership and must not turn that
-              // race into a false lease-loss failure.
-              if (
-                !requests.some((request) =>
-                  this.toolCallResolvers.has(request.callId),
-                )
-              ) {
-                continue;
-              }
-              if (
-                !this.runtimeToolReceiptStillOwned(
-                  receipts[index] ?? null,
-                  leaseId,
-                )
-              ) {
-                throw new RuntimeReceiptLeaseLostError({
-                  receiptKey,
-                  runId: this.currentReceiptOwnerRunId,
-                  leaseId,
-                });
-              }
-            }
-          }),
-        );
+          }
+        }
         return 'active';
       },
       isLeaseLost: (error) => error instanceof RuntimeReceiptLeaseLostError,
@@ -9224,7 +9401,11 @@ export class PlayContextImpl {
       this.#options.executionGatewayBaseUrl?.trim() || this.#options.baseUrl;
     const url = `${executionBaseUrl.replace(/\/$/, '')}/api/v2/integrations/${encodeURIComponent(toolId)}/${executeSuffix}`;
     const toolErrorSchemaVersion = this.currentToolErrorSchemaVersion;
-    const timeoutMs = resolveToolRuntimeTimeoutMs(toolId, options?.timeoutMs);
+    const timeoutMs = resolveToolRuntimeTimeoutMs(
+      toolId,
+      options?.timeoutMs,
+      this.currentAuthoringContractEdition,
+    );
     const provider = toolId.split(/[._]/)[0]?.trim() || 'provider';
     const activityId = `provider:${toolId}`;
     let retryActivityEmitted = false;