deepline 0.1.40 → 0.1.42

package/dist/repo/apps/play-runner-workers/src/entry.ts

@@ -52,7 +52,10 @@ import {
 import {
   adaptV2ExecuteResponseToToolResult,
   createToolExecuteResult,
+  deserializeToolExecuteResult,
+  isSerializedToolExecuteResult,
   isToolExecuteResult,
+  serializeToolExecuteResult,
   type ToolExecuteResult,
   type ToolResultMetadataInput,
 } from '../../../shared_libs/play-runtime/tool-result';
@@ -448,7 +451,7 @@ async function probeHarnessOnce(
  */
 const RUNTIME_API_TIMEOUT_MS = 30_000;
 const RUNTIME_API_PLAY_RUN_TIMEOUT_MS = 75_000;
-const RUNTIME_API_RETRY_DELAYS_MS = [250, 750, 1500] as const;
+const RUNTIME_API_RETRY_DELAYS_MS = [250, 750, 1500, 3000, 5000, 10000] as const;
 let loggedMissingRuntimeApiBinding = false;
 
 async function fetchRuntimeApi(
@@ -461,7 +464,17 @@ async function fetchRuntimeApi(
       ? RUNTIME_API_PLAY_RUN_TIMEOUT_MS
       : RUNTIME_API_TIMEOUT_MS;
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeout = setTimeout(() => {
+      controller.abort();
+      reject(
+        new Error(
+          `[play-harness] runtime API call timed out after ${timeoutMs}ms. path=${path} baseUrl=${baseUrl}`,
+        ),
+      );
+    }, timeoutMs);
+  });
   try {
     const mergedInit: RequestInit = {
       ...init,
@@ -475,11 +488,15 @@ async function fetchRuntimeApi(
           `[play-harness] RUNTIME_API binding missing; using public runtime API transport. path=${path}`,
         );
       }
-      return await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit);
+      return await Promise.race([
+        fetch(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit),
+        timeoutPromise,
+      ]);
     }
-    return await cachedRuntimeApiBinding.fetch(
+    const responsePromise = cachedRuntimeApiBinding.fetch(
       new Request(`${baseUrl.replace(/\/$/, '')}${path}`, mergedInit),
     );
+    return await Promise.race([responsePromise, timeoutPromise]);
   } catch (err) {
     if (err instanceof Error && err.name === 'AbortError') {
       throw new Error(
@@ -488,7 +505,7 @@ async function fetchRuntimeApi(
     }
     throw err;
   } finally {
-    clearTimeout(timer);
+    if (timeout) clearTimeout(timeout);
   }
 }
 
@@ -724,7 +741,8 @@ function isRetryableRuntimeApiResponse(status: number, body: string): boolean {
     status === 429 ||
     status === 502 ||
     status === 503 ||
-    status === 504
+    status === 504 ||
+    status === 530
   ) {
     return true;
   }
@@ -1357,6 +1375,15 @@ async function executeSyntheticTestRateLimitBatch(
   req: RunRequest,
   input: Record<string, unknown>,
 ): Promise<Record<string, unknown>> {
+  const delayMs =
+    typeof input.simulated_delay_ms === 'number' &&
+    Number.isInteger(input.simulated_delay_ms) &&
+    input.simulated_delay_ms > 0
+      ? input.simulated_delay_ms
+      : 0;
+  if (delayMs > 0) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
   const rawItems = Array.isArray(input.items) ? input.items : [];
   const items = rawItems
     .filter((item): item is Record<string, unknown> =>
@@ -1454,6 +1481,21 @@ function executeSyntheticTransientRetry(
 function executeSyntheticTestRateLimit(
   input: Record<string, unknown>,
 ): Record<string, unknown> {
+  if (
+    typeof input.key === 'string' &&
+    input.key.startsWith('public-error-message-regression')
+  ) {
+    throw new ToolHttpError(
+      [
+        'tool test_rate_limit 422 attempt 1/1:',
+        'Synthetic public test error with a redacted token=[REDACTED].',
+        'code=TEST_PUBLIC_ERROR.',
+        'failure_description=The fake test provider intentionally raised a typed public error so V2 runner output preserves actionable details.',
+        'operator_hint=Use this no-bill test provider fixture when verifying play runner error rendering.',
+      ].join(' '),
+      null,
+    );
+  }
   const rowNumber =
     typeof input.row_number === 'number' && Number.isInteger(input.row_number)
       ? input.row_number
@@ -1850,8 +1892,39 @@ type WorkerMapChunkSummary<T extends Record<string, unknown>> = {
   cachedRows?: T[];
 };
 
-function toWorkflowSerializableValue<T>(value: T): T {
-  return JSON.parse(JSON.stringify(serializeValue(value, 0))) as T;
+function serializeDurableStepValue<T>(value: T, depth = 0): T {
+  if (depth > 20 || value == null) return value;
+  if (isToolExecuteResult(value)) return serializeToolExecuteResult(value) as T;
+  if (isDatasetHandle(value)) return serializeValue(value, depth) as T;
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeDurableStepValue(entry, depth + 1)) as T;
+  }
+  if (typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, child]) => [
+      key,
+      serializeDurableStepValue(child, depth + 1),
+    ]),
+  ) as T;
+}
+
+function deserializeDurableStepValue<T>(value: T, depth = 0): T {
+  if (depth > 20 || value == null) return value;
+  if (isSerializedToolExecuteResult(value)) {
+    return deserializeToolExecuteResult(value) as T;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) =>
+      deserializeDurableStepValue(entry, depth + 1),
+    ) as T;
+  }
+  if (typeof value !== 'object') return value;
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, child]) => [
+      key,
+      deserializeDurableStepValue(child, depth + 1),
+    ]),
+  ) as T;
 }
 
 type WorkerStepResolver = (
@@ -1973,8 +2046,8 @@ async function executeWorkerStepProgram(
   let currentRow: Record<string, unknown> = cloneCsvAliasedRow(inputRow);
   for (const step of program.steps) {
     const stepPath = [...(recorder?.path ?? []), step.name];
-    const runStep = async () =>
-      await executeWorkerStepResolver(
+    const runStep = async (): Promise<WorkerStepResolution> => {
+      const resolution = await executeWorkerStepResolver(
         step.resolver,
         currentRow,
         ctx,
@@ -1982,10 +2055,15 @@ async function executeWorkerStepProgram(
         recorder
           ? {
               ...recorder,
-              path: stepPath,
-            }
-          : undefined,
+            path: stepPath,
+          }
+        : undefined,
       );
+      return {
+        value: serializeDurableStepValue(resolution.value),
+        ...(resolution.status ? { status: resolution.status } : {}),
+      };
+    };
     const resolution = workflowStep
       ? await (
           workflowStep.do as unknown as (
@@ -1994,7 +2072,7 @@ async function executeWorkerStepProgram(
           ) => Promise<WorkerStepResolution>
         )(stepPath.join('.'), runStep)
       : await runStep();
-    const value = resolution.value;
+    const value = deserializeDurableStepValue(resolution.value);
     currentRow = cloneCsvAliasedRow(currentRow, { [step.name]: value });
     if (recorder) {
       const stepId = stepPath.join('.');
@@ -3553,10 +3631,10 @@ function createMinimalWorkerCtx(
         rowsSkipped,
         outputDatasetId: `map:${name}`,
         hash,
-        preview: toWorkflowSerializableValue(out.slice(0, 5)),
+        preview: serializeDurableStepValue(out.slice(0, 5)),
         cachedRows:
           out.length <= WORKER_DATASET_IN_MEMORY_ROWS
-            ? toWorkflowSerializableValue(out)
+            ? serializeDurableStepValue(out)
             : undefined,
       };
     };
@@ -3784,13 +3862,16 @@ function createMinimalWorkerCtx(
           ts: nowMs(),
         });
       }
+      // Static pipeline JS blocks already execute inside a Workflow step.
+      // Wrapping each generated waterfall step in another step.do can leave
+      // Workers preview runs parked after the last provider callback.
       return (await executeWorkerStepProgram(
         program,
         input,
         ctx,
         0,
         undefined,
-        workflowStep,
+        undefined,
       )) as T;
     },
     async csv<T extends Record<string, unknown> = Record<string, unknown>>(

package/dist/repo/sdk/src/types.ts

@@ -626,10 +626,27 @@ export interface PlayCheckResult {
   valid: boolean;
   errors: string[];
   staticPipeline?: Record<string, unknown> | null;
+  toolGetterHints?: PlayCheckToolGetterHint[];
   artifactHash?: string | null;
   graphHash?: string | null;
 }
 
+export interface PlayCheckToolGetterHint {
+  toolId: string;
+  lists: Array<{
+    name: string;
+    expression: string;
+    raw?: string;
+  }>;
+  values: Array<{
+    name: string;
+    expression: string;
+    raw?: string;
+  }>;
+  raw?: string;
+  unavailable?: string;
+}
+
 /**
  * Request body for starting a play run via {@link DeeplineClient.startPlayRun}.
  *

package/dist/repo/sdk/src/version.ts

@@ -1,2 +1,2 @@
-export const SDK_VERSION = "0.1.40";
-export const SDK_API_CONTRACT = "2026-05-cloud-play-search";
+export const SDK_VERSION = "0.1.42";
+export const SDK_API_CONTRACT = "2026-05-play-tool-result-errors";

package/dist/repo/shared_libs/play-runtime/tool-result.ts

@@ -1,4 +1,5 @@
 export type {
+  SerializedToolExecuteResult,
   ToolExecuteResult,
   ToolResultExecutionMetadata,
   ToolResultMetadata,
@@ -10,6 +11,7 @@ export type {
 } from './tool-result-types';
 
 import type {
+  SerializedToolExecuteResult,
   ToolExecuteResult,
   ToolResultExecutionMetadata,
   ToolResultListAccessor,
@@ -22,6 +24,8 @@ import type {
 
 type PathSegment = string | number | '*';
 
+const SERIALIZED_TOOL_EXECUTE_RESULT_KIND = 'deepline.tool_execute_result.v1';
+
 const TARGET_FALLBACK_KEYS: Record<string, readonly RegExp[]> = {
   email: [/^email$/i, /^address$/i, /email/i],
   phone: [/^phone$/i, /mobile/i, /phone/i, /telephone/i],
@@ -455,11 +459,10 @@ function buildTargets(
 }
 
 function buildLists(
-  result: unknown,
+  resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   metadata: ToolResultMetadataInput,
 ): Record<string, ToolResultListMetadata> {
   const lists: Record<string, ToolResultListMetadata> = {};
-  const resolved = resolveListRows(result, metadata.listExtractorPaths);
   for (const [name, list] of Object.entries(resolved)) {
     lists[name] = {
       path: list.path,
@@ -499,11 +502,12 @@ function buildExtractedAccessors(
 }
 
 function buildListAccessors(
-  result: unknown,
+  resolved: Record<string, { path: string; rows: Record<string, unknown>[] }>,
   lists: Record<string, ToolResultListMetadata>,
 ): Record<string, ToolResultListAccessor> {
   return Object.fromEntries(
     Object.entries(lists).map(([name, metadata]) => {
+      const rows = resolved[name]?.rows ?? [];
       const accessor = {
         path: metadata.path,
         count: metadata.count,
@@ -511,7 +515,7 @@ function buildListAccessors(
       } as ToolResultListAccessor;
       Object.defineProperty(accessor, 'get', {
         value() {
-          return normalizeRows(getAtPath(result, metadata.path)) ?? [];
+          return rows;
         },
         enumerable: false,
       });
@@ -539,7 +543,11 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     resultRoot,
     input.metadata.resultIdentityGetters,
   );
-  const lists = buildLists(resultRoot, input.metadata);
+  const resolvedLists = resolveListRows(
+    resultRoot,
+    input.metadata.listExtractorPaths,
+  );
+  const lists = buildLists(resolvedLists, input.metadata);
   const metadata = {
     toolId: input.metadata.toolId,
     execution: input.execution,
@@ -551,7 +559,7 @@ export function createToolExecuteResult<TResult = unknown>(input: {
     ...(result.meta ? { meta: result.meta } : {}),
   };
   const extractedValues = buildExtractedAccessors(targets);
-  const extractedLists = buildListAccessors(resultRoot, lists);
+  const extractedLists = buildListAccessors(resolvedLists, lists);
   const wrapper = {
     status: input.status,
     ...(input.jobId ? { job_id: input.jobId } : {}),
@@ -586,6 +594,70 @@ export function isToolExecuteResult(
   );
 }
 
+function metadataInputFromToolExecuteResult(
+  value: ToolExecuteResult,
+): ToolResultMetadataInput {
+  return {
+    toolId: value._metadata.toolId,
+    resultIdentityGetters: Object.fromEntries(
+      Object.entries(value._metadata.targets).map(([target, info]) => [
+        target,
+        [info.path],
+      ]),
+    ),
+    listExtractorPaths: Object.values(value._metadata.lists).map(
+      (list) => list.path,
+    ),
+    listIdentityGetters: Object.fromEntries(
+      Object.values(value._metadata.lists)
+        .flatMap((list) => Object.entries(list.keys))
+        .map(([target, path]) => [target, [path]]),
+    ),
+  };
+}
+
+export function serializeToolExecuteResult(
+  value: ToolExecuteResult,
+): SerializedToolExecuteResult {
+  return {
+    __kind: SERIALIZED_TOOL_EXECUTE_RESULT_KIND,
+    status: value.status,
+    toolResponse: {
+      raw: value.toolResponse.raw,
+      ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
+    },
+    metadata: metadataInputFromToolExecuteResult(value),
+    execution: value._metadata.execution,
+  };
+}
+
+export function isSerializedToolExecuteResult(
+  value: unknown,
+): value is SerializedToolExecuteResult {
+  return (
+    isRecord(value) &&
+    value.__kind === SERIALIZED_TOOL_EXECUTE_RESULT_KIND &&
+    typeof value.status === 'string' &&
+    isRecord(value.toolResponse) &&
+    isRecord(value.metadata) &&
+    isRecord(value.execution)
+  );
+}
+
+export function deserializeToolExecuteResult(
+  value: SerializedToolExecuteResult,
+): ToolExecuteResult {
+  return createToolExecuteResult({
+    status: value.status,
+    result: {
+      data: value.toolResponse.raw,
+      ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
+    },
+    metadata: value.metadata,
+    execution: value.execution,
+  });
+}
+
 export function cloneToolExecuteResultWithExecution<TResult>(
   value: ToolExecuteResult<TResult>,
   execution: ToolResultExecutionMetadata,
@@ -600,23 +672,7 @@ export function cloneToolExecuteResultWithExecution<TResult>(
       data: value.toolResponse.raw,
       ...(value.toolResponse.meta ? { meta: value.toolResponse.meta } : {}),
     } as TResult,
-    metadata: {
-      toolId: value._metadata.toolId,
-      resultIdentityGetters: Object.fromEntries(
-        Object.entries(value._metadata.targets).map(([target, info]) => [
-          target,
-          [info.path],
-        ]),
-      ),
-      listExtractorPaths: Object.values(value._metadata.lists).map(
-        (list) => list.path,
-      ),
-      listIdentityGetters: Object.fromEntries(
-        Object.values(value._metadata.lists)
-          .flatMap((list) => Object.entries(list.keys))
-          .map(([target, path]) => [target, [path]]),
-      ),
-    },
+    metadata: metadataInputFromToolExecuteResult(value),
     execution,
     meta: isRecord(value.meta) ? value.meta : undefined,
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {