deepline 0.1.168 → 0.1.170

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/map-chunk-plan.ts

@@ -14,9 +14,10 @@ import {
 
 export const CACHE_ENABLED_SIMPLE_MAP_CHUNK_SIZE = 10_000;
 export { TOOL_CALLING_MAP_CHUNK_SIZE };
-// Cloudflare preview Workers enforce the 50-subrequest invocation limit. Leave
-// headroom for coordinator/storage calls around row-level unbatched tool RPCs.
-export const UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET = 40;
+// Paid Cloudflare Workers support a much higher configured subrequest limit.
+// Keep a large buffer for coordinator/storage calls around row-level unbatched
+// tool RPCs, but avoid pathological one-row chunks for provider waterfalls.
+export const UNBATCHED_TOOL_SUBREQUESTS_PER_CHUNK_BUDGET = 500;
 // Fresh unbatched tool calls use one RUNTIME_API integration execute RPC and
 // one HARNESS durable-receipt completion RPC. Batch-cap rows by both.
 export const SUBREQUESTS_PER_UNBATCHED_TOOL_CALL = 2;
@@ -46,6 +47,10 @@ type ChunkSizingPlan = {
 
 type MapToolStats = [totalToolCount: number, unbatchedToolCount: number];
 
+function fieldRoot(field: string | null | undefined): string {
+  return String(field ?? '').split('.', 1)[0] ?? '';
+}
+
 function declarationBelongsToMapOutput(
   declaration: { field?: string | null },
   outputFields: readonly string[],
@@ -76,39 +81,124 @@ function countToolSubsteps(
   let unbatchedToolCount = 0;
 
   for (const substep of substeps) {
-    if (substep.type === 'tool') {
+    const [nestedTotal, nestedUnbatched] = countToolSubstep(substep);
+    totalToolCount += nestedTotal;
+    unbatchedToolCount += nestedUnbatched;
+  }
+
+  return [totalToolCount, unbatchedToolCount];
+}
+
+function countToolSubstep(substep: PlayStaticSubstep): MapToolStats {
+  if (substep.type === 'tool') {
+    return [1, isUnbatchedTool(substep.toolId) ? 1 : 0];
+  }
+
+  if (substep.type === 'waterfall') {
+    let totalToolCount = 0;
+    let unbatchedToolCount = 0;
+    for (const step of substep.steps ?? []) {
+      if (!step.toolId) continue;
       totalToolCount += 1;
-      if (isUnbatchedTool(substep.toolId)) {
+      if (isUnbatchedTool(step.toolId)) {
         unbatchedToolCount += 1;
       }
-      continue;
     }
+    return [totalToolCount, unbatchedToolCount];
+  }
 
-    if (substep.type === 'waterfall') {
-      for (const step of substep.steps ?? []) {
-        if (!step.toolId) continue;
-        totalToolCount += 1;
-        if (isUnbatchedTool(step.toolId)) {
-          unbatchedToolCount += 1;
-        }
-      }
-      continue;
-    }
+  if (substep.type === 'step_suite') {
+    return countStepSuiteTools(substep);
+  }
 
-    if (
-      substep.type === 'step_suite' ||
-      substep.type === 'control_flow' ||
-      substep.type === 'dataset'
-    ) {
-      const [nestedTotal, nestedUnbatched] = countToolSubsteps(
-        substep.steps ?? [],
+  if (substep.type === 'control_flow') {
+    if (substep.kind === 'conditional' && substep.branches?.length) {
+      const branchStats = substep.branches.map((branch) =>
+        countToolSubsteps(branch.steps),
+      );
+      return branchStats.reduce<MapToolStats>(
+        ([totalMax, unbatchedMax], [total, unbatched]) => [
+          Math.max(totalMax, total),
+          Math.max(unbatchedMax, unbatched),
+        ],
+        [0, 0],
       );
-      totalToolCount += nestedTotal;
-      unbatchedToolCount += nestedUnbatched;
     }
+    return countToolSubsteps(substep.steps);
   }
 
-  return [totalToolCount, unbatchedToolCount];
+  if (substep.type === 'dataset') {
+    return countToolSubsteps(substep.steps ?? []);
+  }
+
+  return [0, 0];
+}
+
+function countStepSuiteTools(
+  substep: Extract<PlayStaticSubstep, { type: 'step_suite' }>,
+): MapToolStats {
+  const childStats = substep.steps.map((step) => ({
+    step,
+    stats: countToolSubstep(step),
+  }));
+  const conditionalChildren = childStats.filter(
+    ({ step }) =>
+      step.conditional ||
+      (step.type === 'control_flow' && step.kind === 'conditional'),
+  );
+  if (
+    conditionalChildren.length === 0 ||
+    conditionalChildren.length < childStats.length / 2
+  ) {
+    return childStats.reduce<MapToolStats>(
+      ([totalSum, unbatchedSum], { stats: [total, unbatched] }) => [
+        totalSum + total,
+        unbatchedSum + unbatched,
+      ],
+      [0, 0],
+    );
+  }
+
+  const suiteRoot = fieldRoot(substep.field);
+  const sameRoot = childStats.every(({ step }) => {
+    if (!('field' in step)) return true;
+    return fieldRoot(step.field) === suiteRoot;
+  });
+  if (!sameRoot) {
+    return childStats.reduce<MapToolStats>(
+      ([totalSum, unbatchedSum], { stats: [total, unbatched] }) => [
+        totalSum + total,
+        unbatchedSum + unbatched,
+      ],
+      [0, 0],
+    );
+  }
+
+  const unconditionalStats = childStats
+    .filter(
+      ({ step }) =>
+        !step.conditional &&
+        !(step.type === 'control_flow' && step.kind === 'conditional'),
+    )
+    .reduce<MapToolStats>(
+      ([totalSum, unbatchedSum], { stats: [total, unbatched] }) => [
+        totalSum + total,
+        unbatchedSum + unbatched,
+      ],
+      [0, 0],
+    );
+  const conditionalStats = conditionalChildren.reduce<MapToolStats>(
+    ([totalSum, unbatchedSum], { stats: [total, unbatched] }) => [
+      totalSum + total,
+      unbatchedSum + unbatched,
+    ],
+    [0, 0],
+  );
+
+  return [
+    unconditionalStats[0] + conditionalStats[0],
+    unconditionalStats[1] + conditionalStats[1],
+  ];
 }
 
 function countProducerTools(
@@ -125,13 +215,9 @@ function countProducerTools(
       }
     }
     if (producer.substep.type === 'waterfall') {
-      for (const step of producer.substep.steps ?? []) {
-        if (!step.toolId) continue;
-        totalToolCount += 1;
-        if (isUnbatchedTool(step.toolId)) {
-          unbatchedToolCount += 1;
-        }
-      }
+      const [nestedTotal, nestedUnbatched] = countToolSubstep(producer.substep);
+      totalToolCount += nestedTotal;
+      unbatchedToolCount += nestedUnbatched;
     }
     if (producer.steps?.length) {
       const [nestedTotal, nestedUnbatched] = countProducerTools(producer.steps);

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/receipts.ts

@@ -27,8 +27,11 @@ type RuntimeReceiptContext = {
   receiptStore: WorkerRuntimeReceiptStore;
 };
 
-const WORKER_RECEIPT_WAIT_MAX_ATTEMPTS = 240;
+const WORKER_RECEIPT_DEFAULT_WAIT_MS = 300_000;
 const WORKER_RECEIPT_WAIT_DELAY_MS = 250;
+const WORKER_RECEIPT_WAIT_MAX_ATTEMPTS = Math.ceil(
+  WORKER_RECEIPT_DEFAULT_WAIT_MS / WORKER_RECEIPT_WAIT_DELAY_MS,
+);
 
 class RuntimeReceiptWaitTimeoutError extends Error {
   constructor(key: string) {

package/dist/bundling-sources/apps/play-runner-workers/src/runtime/tool-receipts.ts

@@ -22,6 +22,8 @@ export type WorkerToolReceiptGroupPlan<TRequest> = {
 export function canReclaimTimedOutWorkerToolReceipt(input: {
   ownerRunId?: string | null;
   currentRunId: string;
+  updatedAt?: string | null;
+  nowMs?: number;
 }): boolean {
   const currentRunId = input.currentRunId.trim();
   return Boolean(currentRunId);
@@ -93,6 +95,60 @@ export function planWorkerToolReceiptGroups<TRequest>(
   };
 }
 
+export function resolveWorkerToolReceiptGroupWaitMaxAttempts<TRequest>(
+  requests: TRequest[],
+  getWaitMaxAttempts: (request: TRequest) => number,
+): number {
+  return requests.reduce((maxAttempts, request) => {
+    const attempts = getWaitMaxAttempts(request);
+    return Number.isFinite(attempts) && attempts > maxAttempts
+      ? attempts
+      : maxAttempts;
+  }, 1);
+}
+
+export type WorkerToolRuntimeTimeoutRequest = {
+  input: Record<string, unknown>;
+  runtimeTimeoutMs?: number;
+};
+
+export type WorkerToolRuntimeTimeoutClaim = {
+  request: WorkerToolRuntimeTimeoutRequest;
+  followers: WorkerToolRuntimeTimeoutRequest[];
+};
+
+export function resolveWorkerToolRuntimeTimeoutMs(
+  claimedRequests: WorkerToolRuntimeTimeoutClaim[],
+  input: {
+    resolveOwnerTimeoutMs: (
+      request: WorkerToolRuntimeTimeoutRequest,
+    ) => number | undefined;
+  },
+): number | undefined {
+  let timeoutMs = 0;
+  for (const claimed of claimedRequests) {
+    const ownerTimeoutMs = input.resolveOwnerTimeoutMs(claimed.request);
+    if (
+      typeof ownerTimeoutMs === 'number' &&
+      Number.isFinite(ownerTimeoutMs) &&
+      ownerTimeoutMs > timeoutMs
+    ) {
+      timeoutMs = ownerTimeoutMs;
+    }
+    for (const follower of claimed.followers) {
+      const followerTimeoutMs = follower.runtimeTimeoutMs;
+      if (
+        typeof followerTimeoutMs === 'number' &&
+        Number.isFinite(followerTimeoutMs) &&
+        followerTimeoutMs > timeoutMs
+      ) {
+        timeoutMs = followerTimeoutMs;
+      }
+    }
+  }
+  return timeoutMs > 0 ? timeoutMs : undefined;
+}
+
 export function markWorkerToolReceiptResultCached(
   value: unknown,
   cacheKey: string,

package/dist/bundling-sources/apps/play-runner-workers/src/workflow-instance-create.ts

@@ -19,11 +19,13 @@ export async function createOrAttachWorkflowInstance<
 >(input: {
   create: () => Promise<T>;
   getExisting: () => Promise<T>;
+  onCreateFailure?: (error: unknown) => Promise<void>;
 }): Promise<WorkflowInstanceCreateResult<T>> {
   try {
     return { instance: await input.create(), startMode: 'created' };
   } catch (error) {
     if (!isWorkflowInstanceAlreadyExistsError(error)) {
+      await input.onCreateFailure?.(error);
       throw error;
     }
     try {
@@ -32,6 +34,7 @@ export async function createOrAttachWorkflowInstance<
         startMode: 'reattached_existing',
       };
     } catch (attachError) {
+      await input.onCreateFailure?.(attachError);
       const message =
         attachError instanceof Error
           ? attachError.message

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

@@ -91,6 +91,23 @@ const REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
 const REGISTER_PLAY_ARTIFACTS_MAX_BATCH_COUNT = 3;
 const REGISTER_PLAY_ARTIFACTS_MAX_BATCH_BYTES = 2_500_000;
 
+function normalizePlayRunIntegrationMode(
+  value: unknown,
+): 'live' | 'eval_stub' | 'fixture' | undefined {
+  if (value === 'live' || value === 'eval_stub' || value === 'fixture') {
+    return value;
+  }
+  return undefined;
+}
+
+function resolvePlayRunIntegrationMode(
+  request: StartPlayRunRequest,
+): 'live' | 'eval_stub' | 'fixture' | undefined {
+  return normalizePlayRunIntegrationMode(
+    request.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE,
+  );
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1238,6 +1255,7 @@ export class DeeplineClient {
    * ```
    */
   async startPlayRun(request: StartPlayRunRequest): Promise<PlayRunStart> {
+    const integrationMode = resolvePlayRunIntegrationMode(request);
     const response = await this.http.post<Record<string, unknown>>(
       '/api/v2/plays/run',
       {
@@ -1279,6 +1297,7 @@ export class DeeplineClient {
         // defaults to workers_edge; tests and runtime probes that want a
         // different profile pass `request.profile` explicitly.
         ...(request.profile ? { profile: request.profile } : {}),
+        ...(integrationMode ? { integrationMode } : {}),
       },
     );
     return normalizePlayRunStart(response);
@@ -1299,6 +1318,7 @@ export class DeeplineClient {
     request: StartPlayRunRequest,
     options?: { signal?: AbortSignal },
   ): AsyncGenerator<PlayLiveEvent> {
+    const integrationMode = resolvePlayRunIntegrationMode(request);
     const body = {
       ...(request.name ? { name: request.name } : {}),
       ...(request.revisionId ? { revisionId: request.revisionId } : {}),
@@ -1335,6 +1355,7 @@ export class DeeplineClient {
         ? { waitForCompletionMs: request.waitForCompletionMs }
         : {}),
       ...(request.profile ? { profile: request.profile } : {}),
+      ...(integrationMode ? { integrationMode } : {}),
     };
     for await (const event of this.http.streamSse<PlayLiveEvent>(
       '/api/v2/plays/run?stream=true',
@@ -1538,8 +1559,15 @@ export class DeeplineClient {
     sourceFiles?: Record<string, string>;
     description?: string;
     artifact: Record<string, unknown>;
+    integrationMode?: 'live' | 'eval_stub' | 'fixture';
   }): Promise<PlayCheckResult> {
-    return this.http.post('/api/v2/plays/check', input);
+    const integrationMode = normalizePlayRunIntegrationMode(
+      input.integrationMode ?? process.env.DEEPLINE_EVAL_INTEGRATION_MODE,
+    );
+    return this.http.post('/api/v2/plays/check', {
+      ...input,
+      ...(integrationMode ? { integrationMode } : {}),
+    });
   }
 
   /**

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

@@ -300,6 +300,10 @@ export type ToolExecutionRequest = {
   force?: boolean;
   /** Numeric TTL in seconds for this tool checkpoint. */
   staleAfterSeconds?: number;
+  /** Runtime transport timeout in milliseconds. This is not sent to the provider. */
+  timeoutMs?: number;
+  /** Follower wait budget in milliseconds before a running receipt is reclaimable. */
+  receiptWaitMs?: number;
 };
 
 export type StepResolver<Row, Value> = (

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

@@ -104,10 +104,10 @@ export const SDK_RELEASE = {
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
-  version: '0.1.168',
+  version: '0.1.170',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.168',
+    latest: '0.1.170',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

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

@@ -919,6 +919,7 @@ export interface PlayRunStart {
 export interface PlayCheckResult {
   valid: boolean;
   errors: string[];
+  warnings?: string[];
   staticPipeline?: Record<string, unknown> | null;
   toolGetterHints?: PlayCheckToolGetterHint[];
   artifactHash?: string | null;
@@ -1005,6 +1006,8 @@ export interface StartPlayRunRequest {
    * should leave this unset.
    */
   profile?: string;
+  /** Optional per-run provider execution mode for eval/smoke runs. */
+  integrationMode?: 'live' | 'eval_stub' | 'fixture';
 }
 
 /**

package/dist/bundling-sources/shared_libs/play-data-plane/column-names.ts

@@ -1,11 +1,7 @@
-/**
- * SQL-safe physical column name for a play-authored logical field id.
- *
- * Runtime Sheet adapters must use this when they create or discover physical
- * JSONB columns so logical names such as `_metadata` and `person.email` do not
- * drift between writer and reader paths.
- */
-export function sqlSafePlayColumnName(id: string): string {
+const POSTGRES_IDENTIFIER_MAX_BYTES = 63;
+const HASH_SUFFIX_LENGTH = 10;
+
+function normalizePlayColumnName(id: string): string {
   const normalized = id
     .trim()
     .replace(/\.+/g, '__')
@@ -15,3 +11,49 @@ export function sqlSafePlayColumnName(id: string): string {
   const safe = normalized || 'column';
   return /^[A-Za-z_]/.test(safe) ? safe : `c_${safe}`;
 }
+
+function stableHexSuffix(value: string): string {
+  let primary = 0x811c9dc5;
+  let secondary = 0x811c9dc5 ^ value.length;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    primary = Math.imul(primary ^ code, 0x01000193) >>> 0;
+    secondary = Math.imul(secondary ^ (code + index), 0x01000193) >>> 0;
+  }
+  return `${primary.toString(16).padStart(8, '0')}${secondary
+    .toString(16)
+    .padStart(8, '0')}`.slice(0, HASH_SUFFIX_LENGTH);
+}
+
+/**
+ * SQL-safe physical column name for a play-authored logical field id.
+ *
+ * Runtime Sheet adapters must use this when they create or discover physical
+ * JSONB columns so logical names such as `_metadata` and `person.email` do not
+ * drift between writer and reader paths.
+ */
+export function sqlSafePlayColumnName(id: string): string {
+  const prefixed = normalizePlayColumnName(id);
+  if (prefixed.length <= POSTGRES_IDENTIFIER_MAX_BYTES) {
+    return prefixed;
+  }
+
+  const hash = stableHexSuffix(prefixed);
+  const maxPrefixLength =
+    POSTGRES_IDENTIFIER_MAX_BYTES - HASH_SUFFIX_LENGTH - 1;
+  const prefix = prefixed
+    .slice(0, maxPrefixLength)
+    .replace(/_+$/g, '')
+    .slice(0, maxPrefixLength);
+  return `${prefix}_${hash}`;
+}
+
+export function legacyPostgresTruncatedPlayColumnName(
+  id: string,
+): string | null {
+  const prefixed = normalizePlayColumnName(id);
+  if (prefixed.length <= POSTGRES_IDENTIFIER_MAX_BYTES) {
+    return null;
+  }
+  return prefixed.slice(0, POSTGRES_IDENTIFIER_MAX_BYTES);
+}

package/dist/bundling-sources/shared_libs/play-data-plane/sheet-contract.ts

@@ -1,11 +1,19 @@
 import type { PlaySheetContract } from '../plays/static-pipeline';
-import { sqlSafePlayColumnName } from './column-names';
+import {
+  legacyPostgresTruncatedPlayColumnName,
+  sqlSafePlayColumnName,
+} from './column-names';
 
 export type PhysicalSheetColumnProjection = {
   sqlName: string;
   fieldName: string;
 };
 
+export type LegacyPhysicalSheetColumnBackfill = {
+  sqlName: string;
+  legacySqlName: string;
+};
+
 const RUNTIME_SHEET_SYSTEM_FIELDS = new Set([
   '_key',
   '_status',
@@ -58,6 +66,37 @@ export function physicalSheetColumnNames(
   );
 }
 
+export function legacyPhysicalSheetColumnBackfills(
+  sheetContract: PlaySheetContract | null | undefined,
+): LegacyPhysicalSheetColumnBackfill[] {
+  if (!sheetContract) {
+    return [];
+  }
+  const seen = new Set<string>();
+  const backfills: LegacyPhysicalSheetColumnBackfill[] = [];
+  for (const column of sheetContract.columns) {
+    const sqlName = column.sqlName.trim();
+    if (!sqlName || sqlName.startsWith('_')) {
+      continue;
+    }
+    const candidates = [
+      typeof column.field === 'string' ? column.field : null,
+      column.id,
+    ];
+    for (const candidate of candidates) {
+      if (!candidate) continue;
+      const legacySqlName = legacyPostgresTruncatedPlayColumnName(candidate);
+      const key = legacySqlName ? `${sqlName}:${legacySqlName}` : '';
+      if (!legacySqlName || legacySqlName === sqlName || seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      backfills.push({ sqlName, legacySqlName });
+    }
+  }
+  return backfills;
+}
+
 export function physicalSheetColumnFieldLookup(
   sheetContract: PlaySheetContract | null | undefined,
 ): Map<string, string> {

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -230,6 +230,7 @@ type RuntimeApiRequest =
 export type WorkerRuntimeApiContext = {
   baseUrl: string;
   executorToken: string;
+  integrationMode?: 'live' | 'eval_stub' | 'fixture' | null;
   vercelProtectionBypassToken?: string | null;
   fetch?: typeof fetch;
 };