deepline 0.1.41 → 0.1.45

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;
   }
@@ -1296,12 +1314,44 @@ function parseExecuteToolMetadata(
       : toolId;
   return {
     toolId: metadataToolId,
-    resultIdentityGetters: parseGetterMetadata(record.resultIdentityGetters),
+    extractors: parseExtractorMetadata(record.extractors),
+    targetGetters: parseGetterMetadata(record.targetGetters),
     listExtractorPaths: parseStringArray(record.listExtractorPaths),
     listIdentityGetters: parseGetterMetadata(record.listIdentityGetters),
   };
 }
 
+function parseExtractorMetadata(
+  value: unknown,
+): ToolResultMetadataInput['extractors'] {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  const entries = Object.entries(value as Record<string, unknown>).flatMap(
+    ([key, descriptor]) => {
+      if (!descriptor || typeof descriptor !== 'object' || Array.isArray(descriptor)) {
+        return [];
+      }
+      const record = descriptor as Record<string, unknown>;
+      const paths = parseStringArray(record.paths);
+      if (paths.length === 0) return [];
+      const transforms = parseStringArray(record.transforms);
+      const enumValues = parseStringArray(record.enum);
+      return [
+        [
+          key,
+          {
+            paths,
+            ...(transforms.length > 0 ? { transforms } : {}),
+            ...(enumValues.length > 0 ? { enum: enumValues } : {}),
+          },
+        ],
+      ] as const;
+    },
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
 function parseGetterMetadata(
   value: unknown,
 ): Record<string, readonly string[]> | undefined {
@@ -1327,7 +1377,7 @@ function syntheticToolMetadata(toolId: string): ToolResultMetadataInput {
   if (toolId === 'test_rate_limit') {
     return {
       toolId,
-      resultIdentityGetters: {
+      targetGetters: {
         email: ['email', 'value'],
       },
     };
@@ -1463,6 +1513,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
@@ -1859,8 +1924,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 = (
@@ -1982,8 +2078,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,
@@ -1991,10 +2087,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 (
@@ -2003,7 +2104,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('.');
@@ -3562,10 +3663,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,
       };
     };
@@ -3793,13 +3894,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/client.ts

@@ -522,7 +522,7 @@ export class DeeplineClient {
       params.set('search_terms', options.searchTerms.trim());
     }
     return this.http.get<ToolSearchResult>(
-      `/api/v2/integrations/list?${params.toString()}`,
+      `/api/v2/tools/search?${params.toString()}`,
     );
   }
 

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

@@ -77,7 +77,10 @@ import type {
   PlayDataset,
   PlayDatasetInput,
 } from '../../shared_libs/plays/dataset.js';
-import type { ToolExecuteResult } from '../../shared_libs/play-runtime/tool-result-types.js';
+import type {
+  ToolExecuteResult,
+  ToolResultMetadataInput,
+} from '../../shared_libs/play-runtime/tool-result-types.js';
 import type {
   DeeplineClientOptions,
   PlayDetail,
@@ -1092,6 +1095,37 @@ function stringArray(value: unknown): string[] {
   return Array.isArray(value) ? value.map(String) : [];
 }
 
+function extractorDescriptorRecord(
+  value: unknown,
+): ToolResultMetadataInput['extractors'] {
+  if (!isRecord(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value).flatMap(([key, descriptor]) => {
+      if (!isRecord(descriptor)) return [];
+      const paths = stringArray(descriptor.paths)
+        .map((path) => path.trim())
+        .filter(Boolean);
+      if (paths.length === 0) return [];
+      const transforms = stringArray(descriptor.transforms)
+        .map((transform) => transform.trim())
+        .filter(Boolean);
+      const enumValues = stringArray(descriptor.enum)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+      return [
+        [
+          key,
+          {
+            paths,
+            ...(transforms.length > 0 ? { transforms } : {}),
+            ...(enumValues.length > 0 ? { enum: enumValues } : {}),
+          },
+        ],
+      ];
+    }),
+  );
+}
+
 function toolExecutionEnvelopeToResult(
   fallbackToolId: string,
   response: ToolExecution,
@@ -1115,8 +1149,9 @@ function toolExecutionEnvelopeToResult(
         typeof toolMetadata.toolId === 'string'
           ? toolMetadata.toolId
           : fallbackToolId,
-      resultIdentityGetters: stringArrayRecord(
-        toolMetadata.resultIdentityGetters,
+      extractors: extractorDescriptorRecord(toolMetadata.extractors),
+      targetGetters: stringArrayRecord(
+        toolMetadata.targetGetters,
       ),
       listExtractorPaths: stringArray(toolMetadata.listExtractorPaths),
       listIdentityGetters: stringArrayRecord(toolMetadata.listIdentityGetters),

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

@@ -168,7 +168,25 @@ export interface ToolSearchOptions {
 
 export interface ToolSearchResult {
   tools: ToolDefinition[];
+  count?: number;
+  total?: number;
+  truncated?: boolean;
+  query?: string;
+  categories?: string[];
+  search_terms?: string[];
+  search_mode?: 'v1' | 'v2';
   search_fallback_to_category?: boolean;
+  omitted_plays_hint?: string;
+  render?: {
+    sections?: Array<{
+      title: string;
+      lines: string[];
+    }>;
+    actions?: Array<{
+      label: string;
+      command: string;
+    }>;
+  };
 }
 
 /**
@@ -626,10 +644,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.41";
-export const SDK_API_CONTRACT = "2026-05-cloud-play-search";
+export const SDK_VERSION = "0.1.45";
+export const SDK_API_CONTRACT = "2026-05-promo-redemption-policy";