deepline 0.1.85 → 0.1.89

package/dist/repo/shared_libs/play-runtime/coordinator-headers.ts

@@ -24,6 +24,16 @@ export const COORDINATOR_RUN_SCOPE_HEADER = 'x-deepline-run-scope';
 export const COORDINATOR_URL_OVERRIDE_HEADER = 'x-deepline-coordinator-url';
 export const WORKER_CALLBACK_URL_OVERRIDE_HEADER =
   'x-deepline-worker-callback-url';
+/**
+ * CLI→app marker (NOT a coordinator header — it lives here only because both
+ * the SDK HTTP client and the run route already import this module). Set by
+ * automated test harnesses (e.g. `tests/v2-plays`) so their intentionally
+ * failing plays — depth-guard probes, error-path scenarios — do not page the
+ * SDK CLI error channel as if a real customer run had failed. The run route
+ * honors it ONLY in non-prod (see run/route.ts); a forged header from a real
+ * prod customer can never suppress their own failure alerts.
+ */
+export const SYNTHETIC_RUN_HEADER = 'x-deepline-synthetic-run';
 
 let warnedAboutMissingInternalToken = false;
 

package/dist/repo/shared_libs/play-runtime/scheduler-backend.ts

@@ -136,7 +136,16 @@ export type PlaySchedulerSubmitInput = {
 };
 
 export type PlaySchedulerProgressEvent =
-  | { type: 'status'; status: string; logs?: string[]; ts: number }
+  | {
+      type: 'status';
+      status: string;
+      logs?: string[];
+      ts: number;
+      activeNodeId?: string | null;
+      activeArtifactTableNamespace?: string | null;
+      updatedAt?: number | null;
+      liveNodeProgress?: unknown;
+    }
   | { type: 'log'; line: string; ts: number }
   | { type: 'row'; update: PlayRowUpdate; ts: number }
   | { type: 'execution_event'; event: PlayExecutionEvent; ts: number }

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

@@ -17,7 +17,10 @@ export type {
   EmailStatusVerdict,
 } from './email-status';
 
-import { buildEmailStatus } from './email-status';
+import {
+  buildEmailStatus,
+  type EmailStatusExtractorConfig,
+} from './email-status';
 import {
   JOB_CHANGE_STATUS_VALUES,
   type JobChangeGetterValue,
@@ -56,12 +59,12 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
 
-export type V2ToolExecuteOutput = {
+type V2ToolExecuteOutput = {
   raw: unknown;
   meta?: Record<string, unknown>;
 };
 
-export function parseV2ToolExecuteOutput(
+function parseV2ToolExecuteOutput(
   data: Record<string, unknown>,
 ): V2ToolExecuteOutput | null {
   const toolResponse = data.toolResponse;
@@ -77,9 +80,10 @@ export function parseV2ToolExecuteOutput(
   return null;
 }
 
-export function adaptV2ExecuteResponseToToolResult(
-  data: Record<string, unknown>,
-): { output?: V2ToolExecuteOutput; result: unknown } {
+function adaptV2ExecuteResponseToToolResult(data: Record<string, unknown>): {
+  output?: V2ToolExecuteOutput;
+  result: unknown;
+} {
   const output = parseV2ToolExecuteOutput(data);
   if (!output) {
     return { result: data.result ?? data };
@@ -93,7 +97,195 @@ export function adaptV2ExecuteResponseToToolResult(
   };
 }
 
-export function toV2RawToolOutputPath(path: string): string {
+/**
+ * Parsed view of a raw `/api/v2/integrations/:toolId/execute` JSON body.
+ *
+ * This is the single runtime-side seam from a V2 execute response to the
+ * inputs of {@link createToolExecuteResult}. Both runner substrates (the
+ * in-process cjs runtime in `shared_libs/play-runtime/context.ts` and the
+ * Workers runtime in `apps/play-runner-workers`) must go through
+ * {@link parseToolExecuteResponse}; the intermediate envelope shapes
+ * (`toolResponse` adaptation, `_metadata.tool` parsing, status derivation)
+ * are private to this module.
+ *
+ * Boundary note: provider-specific redaction (wiza/apify/bettercontact billing
+ * fields) happens server-side in
+ * `src/lib/integrations/execute-result-normalization.ts` BEFORE the response
+ * leaves the API. This module only ever sees the already-redacted public
+ * response — do not move redaction here, it would leak provider internals
+ * into the shared runtime bundles.
+ */
+export type ParsedToolExecuteResponse = {
+  status: string;
+  jobId?: string;
+  meta?: Record<string, unknown>;
+  toolResponse?: {
+    raw?: unknown;
+    meta?: Record<string, unknown>;
+  };
+  /** Legacy `{ data, meta }` envelope consumed by createToolExecuteResult. */
+  result: unknown;
+  /** Tool extractor metadata parsed from `_metadata.tool`, if present. */
+  metadata: ToolResultMetadataInput | null;
+};
+
+export function parseToolExecuteResponse(
+  toolId: string,
+  body: Record<string, unknown>,
+): ParsedToolExecuteResponse {
+  const { result } = adaptV2ExecuteResponseToToolResult(body);
+  const status =
+    typeof body.status === 'string'
+      ? body.status
+      : result == null
+        ? 'no_result'
+        : 'completed';
+  return {
+    status,
+    jobId: typeof body.job_id === 'string' ? body.job_id : undefined,
+    meta: isRecord(body.meta) ? body.meta : undefined,
+    toolResponse: isRecord(body.toolResponse)
+      ? (body.toolResponse as ParsedToolExecuteResponse['toolResponse'])
+      : undefined,
+    result,
+    metadata: parseExecuteToolMetadata(toolId, body),
+  };
+}
+
+function parseExecuteToolMetadata(
+  toolId: string,
+  data: Record<string, unknown>,
+): ToolResultMetadataInput | null {
+  const metadata = data._metadata;
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+    return null;
+  }
+  const tool = (metadata as Record<string, unknown>).tool;
+  if (!tool || typeof tool !== 'object' || Array.isArray(tool)) return null;
+  const record = tool as Record<string, unknown>;
+  const metadataToolId =
+    typeof record.toolId === 'string' && record.toolId.trim()
+      ? record.toolId
+      : toolId;
+  const readGetters = (value: unknown): Record<string, readonly string[]> => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).flatMap(
+        ([key, paths]) => {
+          if (!Array.isArray(paths)) return [];
+          const normalized = paths.filter(
+            (path): path is string =>
+              typeof path === 'string' && path.trim().length > 0,
+          );
+          return normalized.length > 0 ? [[key, normalized]] : [];
+        },
+      ),
+    );
+  };
+  const readExtractors = (
+    value: unknown,
+  ): ToolResultMetadataInput['extractors'] => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).flatMap(
+        ([key, entry]) => {
+          if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return [];
+          const recordEntry = entry as Record<string, unknown>;
+          if (!Array.isArray(recordEntry.paths)) return [];
+          const paths = recordEntry.paths.filter(
+            (path): path is string =>
+              typeof path === 'string' && path.trim().length > 0,
+          );
+          if (paths.length === 0) return [];
+          const overrides = Array.isArray(recordEntry.overrides)
+            ? recordEntry.overrides.flatMap((override) => {
+                if (
+                  !override ||
+                  typeof override !== 'object' ||
+                  Array.isArray(override)
+                ) {
+                  return [];
+                }
+                const overrideRecord = override as Record<string, unknown>;
+                const overridePaths = Array.isArray(overrideRecord.paths)
+                  ? overrideRecord.paths.filter(
+                      (path): path is string =>
+                        typeof path === 'string' && path.trim().length > 0,
+                    )
+                  : [];
+                if (overridePaths.length === 0) return [];
+                const readOverridePrimitive = (
+                  candidate: unknown,
+                ): string | number | boolean | null | undefined => {
+                  if (candidate === null) return null;
+                  if (typeof candidate === 'string') return candidate;
+                  if (typeof candidate === 'number') return candidate;
+                  if (typeof candidate === 'boolean') return candidate;
+                  return undefined;
+                };
+                const value = readOverridePrimitive(overrideRecord.value);
+                if (value === undefined) {
+                  return [];
+                }
+                const equals: string | number | boolean | null =
+                  readOverridePrimitive(overrideRecord.equals) ?? true;
+                return [{ paths: overridePaths, equals, value }];
+              })
+            : [];
+          const emailStatus =
+            recordEntry.emailStatus &&
+            typeof recordEntry.emailStatus === 'object' &&
+            !Array.isArray(recordEntry.emailStatus)
+              ? (recordEntry.emailStatus as EmailStatusExtractorConfig)
+              : undefined;
+          return [
+            [
+              key,
+              {
+                paths,
+                ...(Array.isArray(recordEntry.transforms)
+                  ? {
+                      transforms: recordEntry.transforms.filter(
+                        (transform): transform is string =>
+                          typeof transform === 'string' &&
+                          transform.trim().length > 0,
+                      ),
+                    }
+                  : {}),
+                ...(Array.isArray(recordEntry.enum)
+                  ? {
+                      enum: recordEntry.enum.filter(
+                        (value): value is string =>
+                          typeof value === 'string' && value.trim().length > 0,
+                      ),
+                    }
+                  : {}),
+                ...(overrides.length > 0 ? { overrides } : {}),
+                ...(emailStatus ? { emailStatus } : {}),
+              },
+            ],
+          ];
+        },
+      ),
+    );
+  };
+  const listExtractorPaths = Array.isArray(record.listExtractorPaths)
+    ? record.listExtractorPaths.filter(
+        (path): path is string =>
+          typeof path === 'string' && path.trim().length > 0,
+      )
+    : [];
+  return {
+    toolId: metadataToolId,
+    extractors: readExtractors(record.extractors),
+    targetGetters: readGetters(record.targetGetters),
+    listExtractorPaths,
+    listIdentityGetters: readGetters(record.listIdentityGetters),
+  };
+}
+
+function toV2RawToolOutputPath(path: string): string {
   const normalized = String(path || '')
     .trim()
     .replace(/^\./, '');
@@ -445,9 +637,7 @@ function normalizeJobChangeStatus(value: unknown): unknown {
   if (['false', 'no', 'same', 'no_change'].includes(normalized))
     return 'no_change';
   if (['left', 'left_company'].includes(normalized)) return 'left_company';
-  if (
-    (JOB_CHANGE_STATUS_VALUES as readonly string[]).includes(normalized)
-  ) {
+  if ((JOB_CHANGE_STATUS_VALUES as readonly string[]).includes(normalized)) {
     return normalized;
   }
   return 'unknown';
@@ -481,12 +671,12 @@ function normalizeJobChange(value: unknown): JobChangeGetterValue {
   return {
     status,
     date: moved
-      ? normalizeString(
+      ? (normalizeString(
           output.date ??
             output.job_change_date ??
             output.change_date ??
             output.changed_at,
-        ) ?? firstExperienceDate(person.experiences)
+        ) ?? firstExperienceDate(person.experiences))
       : null,
     new_company: moved
       ? normalizeString(

package/dist/repo/shared_libs/plays/bundling/index.ts

@@ -26,10 +26,7 @@ import type {
 } from '../artifact-types';
 import { buildPlayContractCompatibility } from '../contracts';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
-import {
-  MAX_ESM_WORKERS_BUNDLE_BYTES,
-  MAX_PLAY_BUNDLE_BYTES,
-} from './limits';
+import { MAX_ESM_WORKERS_BUNDLE_BYTES, MAX_PLAY_BUNDLE_BYTES } from './limits';
 
 const PLAY_BUNDLE_CACHE_VERSION = 24;
 const PLAY_ARTIFACT_CACHE_DIR = join(
@@ -443,7 +440,13 @@ function findPackageJsonPathFrom(
   startDir: string,
   packageName: string,
 ): string | null {
-  let current = resolve(startDir);
+  if (!isAbsolute(startDir)) {
+    throw new Error(
+      `Package resolution requires an absolute start directory, got ${startDir}`,
+    );
+  }
+
+  let current = startDir;
   while (true) {
     const packageJsonPath = join(
       current,
@@ -469,17 +472,15 @@ function findPackageJsonPath(
   adapter: PlayBundlingAdapter,
 ): string | null {
   const startDirs = [
-    dirname(fromFile),
-    adapter.projectRoot,
-    dirname(adapter.sdkPackageJson),
-    process.cwd(),
+    resolve(dirname(fromFile)),
+    resolve(adapter.projectRoot),
+    resolve(dirname(adapter.sdkPackageJson)),
   ];
   const seen = new Set<string>();
   for (const startDir of startDirs) {
-    const normalized = resolve(startDir);
-    if (seen.has(normalized)) continue;
-    seen.add(normalized);
-    const packageJsonPath = findPackageJsonPathFrom(normalized, packageName);
+    if (seen.has(startDir)) continue;
+    seen.add(startDir);
+    const packageJsonPath = findPackageJsonPathFrom(startDir, packageName);
     if (packageJsonPath) return packageJsonPath;
   }
 
@@ -1139,7 +1140,10 @@ async function writeArtifactCache(
   );
 }
 
-function normalizeSourceMapForRuntime(sourceMapText: string): string {
+function normalizeSourceMapForRuntime(
+  sourceMapText: string,
+  projectRoot: string,
+): string {
   const parsed = JSON.parse(sourceMapText) as {
     sourceRoot?: string;
     sources?: string[];
@@ -1155,7 +1159,7 @@ function normalizeSourceMapForRuntime(sourceMapText: string): string {
       return sourcePath;
     }
 
-    return resolve(process.cwd(), sourcePath);
+    return join(projectRoot, sourcePath);
   });
   parsed.sourceRoot = undefined;
 
@@ -1524,7 +1528,10 @@ export async function bundlePlayFile(
     }
     const { bundledCode, sourceMapText, outputExtension } = buildOutcome;
 
-    const normalizedSourceMap = normalizeSourceMapForRuntime(sourceMapText);
+    const normalizedSourceMap = normalizeSourceMapForRuntime(
+      sourceMapText,
+      resolve(adapter.projectRoot),
+    );
     const virtualBaseName =
       exportName === 'default'
         ? basename(absolutePath).replace(/\.[^.]+$/, '')

package/dist/repo/shared_libs/plays/dataset.ts

@@ -74,6 +74,8 @@ export type PlayDatasetTransformOptions = {
  * small and bounded. `PlayDataset` intentionally does not expose `.rows`,
  * `.toArray()`, or other array aliases; those hide the runtime cost of loading
  * persisted rows into memory.
+ *
+ * @sdkReference runtime 190
  */
 export interface PlayDataset<T> extends AsyncIterable<T> {
   readonly [PLAY_DATASET_BRAND]: true;

package/dist/repo/shared_libs/plays/row-identity.ts

@@ -169,19 +169,25 @@ export function normalizePlayName(value: string): string {
   return validateIdentifierPart(value, 'Play name', PLAY_NAME_MAX_LENGTH);
 }
 
+/**
+ * Normalize a play name into the leading segment of a physical sheet table name.
+ *
+ * A qualified reference like "prebuilt/name-and-domain-to-email-waterfall" folds
+ * its namespace separator into a plain identifier
+ * ("prebuilt_name_and_domain_to_email_waterfall") so the physical table reads
+ * cleanly. `validatePlaySheetTableName` enforces the 63-char Postgres identifier
+ * limit on the play + namespace combination and fails loudly when a name is
+ * genuinely too long — no opaque content digest is mixed into the table name.
+ */
 export function normalizePlayNameForSheet(value: string): string {
   if (!value.includes('/')) {
     return normalizePlayName(value);
   }
-  const digest = sha256Hex(value).slice(0, 12);
-  const normalizedReference = sanitizeIdentifierPart(
-    value.replace(/\//g, '__'),
+  return validateIdentifierPart(
+    value.replace(/\//g, '_'),
+    'Play name',
+    PLAY_NAME_MAX_LENGTH,
   );
-  const prefixLength = Math.max(1, PLAY_NAME_MAX_LENGTH - digest.length - 1);
-  const prefix =
-    normalizedReference.slice(0, prefixLength).replace(/_+$/g, '') ||
-    'qualified_play';
-  return `${prefix}_${digest}`;
 }
 
 export function normalizeTableNamespace(value: string): string {

package/package.json

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