deepline 0.2.13 → 0.2.15

package/dist/bundling-sources/sdk/src/release.ts

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.13',
+  version: '0.2.15',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -36,6 +36,12 @@ export function ctxRunPlayInlineOnlyMessage(
   childPlayName: string,
   reason: CtxRunPlayInlineOnlyReason,
 ): string {
+  const contractPath =
+    reason === 'explicit_timeout'
+      ? 'ctx.runPlay.options.timeoutMs'
+      : reason === 'explicit_child_workflow'
+        ? 'ctx.runPlay.options.execution'
+        : 'ctx.runPlay';
   const detail: Record<CtxRunPlayInlineOnlyReason, string> = {
     missing_static_contract: 'its static contract could not be resolved',
     dataset_child: 'it uses ctx.dataset(), ctx.csv(), or a Runtime Sheet',
@@ -59,7 +65,7 @@ export function ctxRunPlayInlineOnlyMessage(
       'Remove execution: "child-workflow" for a scalar lookup, or trigger the child as a top-level play when it needs its own lifecycle.',
   };
   return (
-    `${CTX_RUN_PLAY_INLINE_ONLY}: ctx.runPlay("${childPlayName}") can only call a scalar, per-record play; ` +
+    `${CTX_RUN_PLAY_INLINE_ONLY}: [play_authoring_run_play_option_invalid path=${contractPath}] ctx.runPlay("${childPlayName}") can only call a scalar, per-record play; ` +
     `${detail[reason]}. ${nextStep[reason]}`
   );
 }

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';
@@ -3137,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({
@@ -3145,7 +3247,7 @@ export class PlayContextImpl {
         operation,
         id,
         semanticKey: opts.semanticKey,
-        staleAfterSeconds: opts.staleAfterSeconds,
+        staleAfterSeconds: stalePolicy.staleAfterSeconds,
       });
     return await executeWithDurableRuntimeReceipt<T>({
       operation,
@@ -3153,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,
@@ -3483,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,
     };
   }
 
@@ -4024,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(
@@ -4044,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>,
@@ -4053,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()) {
@@ -4082,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,
@@ -4090,7 +4206,7 @@ export class PlayContextImpl {
     _input?:
       | MapFieldDefinition<T, Record<string, unknown>>
       | RuntimeStepProgram,
-    _options?: DatasetOptions<T>,
+    _options?: RuntimeDatasetOptions<T>,
   ): never {
     void _key;
     void _items;
@@ -4103,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);
@@ -4117,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, [], {
@@ -4132,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);
@@ -6946,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);
@@ -7052,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 ||
@@ -7154,6 +7320,7 @@ export class PlayContextImpl {
         const timeoutMs = resolveToolRuntimeTimeoutMs(
           toolId,
           options?.timeoutMs,
+          this.currentAuthoringContractEdition,
         );
         this.enqueueToolCall({
           callId,
@@ -7168,7 +7335,7 @@ export class PlayContextImpl {
           toolId,
           input,
           ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-          ...(typeof options?.receiptWaitMs === 'number'
+          ...(options?.receiptWaitMs !== undefined
             ? { receiptWaitMs: options.receiptWaitMs }
             : {}),
           tableNamespace: store.tableNamespace,
@@ -7205,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) =>
@@ -7228,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,
               ),
@@ -7382,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' &&
@@ -7396,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.',
@@ -7414,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,
@@ -7490,6 +7673,8 @@ export class PlayContextImpl {
             playName: resolvedName,
             staticPipeline: resolvedPlay.staticPipeline ?? null,
             toolErrorSchemaVersion: childToolErrorSchemaVersion,
+            authoringContractEdition:
+              childCompatibility.authoringContractEdition,
           },
           () => this.executeResolvedPlay(resolvedPlay, this, input),
         );
@@ -7671,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}`,
       );
@@ -7695,7 +7883,7 @@ export class PlayContextImpl {
         delayMs,
       });
     }
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
   }
 
   async fetch(
@@ -7704,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
@@ -7890,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.');
@@ -9207,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;

package/dist/bundling-sources/shared_libs/play-runtime/csv-rename.ts

@@ -1,10 +1,14 @@
-export type CsvRenameMap = Record<string, string | readonly string[]>;
+import type {
+  PlayAuthoringCsvOptions,
+  PlayAuthoringCsvRenameMap,
+} from '../plays/authoring-contract';
 
-export type CsvRenameOptions = {
-  columns?: CsvRenameMap;
-  rename?: CsvRenameMap;
-  required?: readonly string[];
-};
+export type CsvRenameMap = PlayAuthoringCsvRenameMap;
+
+export type CsvRenameOptions = Pick<
+  PlayAuthoringCsvOptions,
+  'columns' | 'rename' | 'required'
+>;
 
 const CSV_PROJECTED_FIELDS = Symbol.for('deepline.play.csv.projected_fields');
 const CSV_PROJECTED_FIELDS_KEY = '__deeplineCsvProjectedFields';