deepline 0.1.19 → 0.1.20

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

@@ -63,6 +63,7 @@ import {
 } from '../../../shared_libs/plays/row-identity';
 import {
   getCompiledPipelineSubsteps,
+  flattenStaticPipeline,
   resolveSheetContractForTableNamespace,
   sqlSafePlayColumnName,
   type PlayStaticPipeline,
@@ -365,8 +366,9 @@ function cachedVercelProtectionBypassToken(): string | null {
 
 const WORKER_PLAY_CALL_LIMITS = {
   maxPlayCallDepth: 6,
-  maxPlayCallCount: 32,
-  maxChildPlayCallsPerParent: 16,
+  maxPlayCallCount: 1_000,
+  maxChildPlayCallsPerParent: 1_000,
+  maxConcurrentPlayCalls: 16,
 };
 
 /**
@@ -637,6 +639,7 @@ async function postRuntimeApiBestEffort(
 async function submitChildPlayThroughCoordinator(input: {
   req: RunRequest;
   body: unknown;
+  allowInline?: boolean;
 }): Promise<{
   workflowId?: string;
   runId?: string;
@@ -648,7 +651,7 @@ async function submitChildPlayThroughCoordinator(input: {
   logs?: string[];
   timings?: Array<{ phase: string; ms: number }>;
 }> {
-  if (cachedCoordinatorBinding) {
+  if (cachedCoordinatorBinding && input.allowInline !== false) {
     if (!isRecord(input.body)) {
       throw new Error('ctx.runPlay child submit requires an object body.');
     }
@@ -2461,6 +2464,18 @@ function childPipelineUsesCtxMap(
   );
 }
 
+function childPipelineNeedsWorkflowScheduler(
+  pipeline: PlayStaticPipeline | null | undefined,
+): boolean {
+  if (!pipeline) return false;
+  return flattenStaticPipeline(pipeline).some(
+    (substep) =>
+      substep.type === 'tool' &&
+      (substep.isEventWait === true ||
+        substep.toolId === 'test_wait_for_event'),
+  );
+}
+
 function releaseChildPlayConcurrency(
   inFlightByPlayName: Record<string, number>,
   playName: string,
@@ -2483,6 +2498,41 @@ function createMinimalWorkerCtx(
   let playCallCount = 0;
   const parentChildCalls: Record<string, number> = {};
   const inFlightChildCallsByPlayName: Record<string, number> = {};
+  let inFlightChildPlayCalls = 0;
+  const childPlaySlotWaiters: Array<() => void> = [];
+
+  const acquireChildPlaySlot = async (): Promise<() => void> => {
+    while (
+      inFlightChildPlayCalls >= WORKER_PLAY_CALL_LIMITS.maxConcurrentPlayCalls
+    ) {
+      await new Promise<void>((resolve, reject) => {
+        const waiter = () => {
+          abortSignal?.removeEventListener('abort', onAbort);
+          resolve();
+        };
+        const onAbort = () => {
+          const index = childPlaySlotWaiters.indexOf(waiter);
+          if (index >= 0) childPlaySlotWaiters.splice(index, 1);
+          reject(
+            abortSignal?.reason instanceof Error
+              ? abortSignal.reason
+              : new WorkflowAbortError(),
+          );
+        };
+        childPlaySlotWaiters.push(waiter);
+        abortSignal?.addEventListener('abort', onAbort, { once: true });
+      });
+      assertNotAborted(abortSignal);
+    }
+    inFlightChildPlayCalls += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      inFlightChildPlayCalls = Math.max(0, inFlightChildPlayCalls - 1);
+      childPlaySlotWaiters.shift()?.();
+    };
+  };
   const rootGovernance = req.playCallGovernance;
   const rootRunId = rootGovernance?.rootRunId ?? req.runId;
   // Local ancestry chain that always ENDS with the currently-executing play
@@ -2579,6 +2629,7 @@ function createMinimalWorkerCtx(
           : JSON.stringify(normalizedParts);
       return keyValue;
     };
+    const mapLogicFingerprint = req.graphHash ?? null;
     const resolveRowKey = (
       row: Record<string, unknown>,
       index: number,
@@ -2586,8 +2637,12 @@ function createMinimalWorkerCtx(
       const inputRow = publicCsvInputRow(row);
       const explicitKeyValue = resolveExplicitKeyValue(row, index);
       return explicitKeyValue == null
-        ? derivePlayRowIdentity(inputRow, name)
-        : derivePlayRowIdentityFromKey(explicitKeyValue, name);
+        ? derivePlayRowIdentity(inputRow, name, mapLogicFingerprint)
+        : derivePlayRowIdentityFromKey(
+            explicitKeyValue,
+            name,
+            mapLogicFingerprint,
+          );
     };
     const assertUniqueExplicitRowKeys = (
       chunkRows: readonly Record<string, unknown>[],
@@ -2635,7 +2690,11 @@ function createMinimalWorkerCtx(
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : derivePlayRowIdentity(publicCsvInputRow(row), name);
+            : derivePlayRowIdentity(
+                publicCsvInputRow(row),
+                name,
+                mapLogicFingerprint,
+              );
         if (key) {
           pendingKeys.add(key);
           preparedKeys.add(key);
@@ -2645,7 +2704,11 @@ function createMinimalWorkerCtx(
         const key =
           typeof row.__deeplineRowKey === 'string'
             ? row.__deeplineRowKey
-            : derivePlayRowIdentity(publicCsvInputRow(row), name);
+            : derivePlayRowIdentity(
+                publicCsvInputRow(row),
+                name,
+                mapLogicFingerprint,
+              );
         if (key) {
           completedKeys.add(key);
           preparedKeys.add(key);
@@ -2852,7 +2915,11 @@ function createMinimalWorkerCtx(
         const key =
           typeof completedRow.__deeplineRowKey === 'string'
             ? completedRow.__deeplineRowKey
-            : derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
+            : derivePlayRowIdentity(
+                publicCsvInputRow(completedRow),
+                name,
+                mapLogicFingerprint,
+              );
         if (key) {
           const { __deeplineRowKey: _rowKey, ...cleanedRow } =
             publicCsvInputRow(completedRow);
@@ -3227,7 +3294,11 @@ function createMinimalWorkerCtx(
         const completedKeys = new Set<string>();
         const preparedKeys = new Set<string>();
         for (const row of prepared.pendingRows) {
-          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
+          const key = derivePlayRowIdentity(
+            publicCsvInputRow(row),
+            name,
+            mapLogicFingerprint,
+          );
           if (key) {
             pendingKeys.add(key);
             preparedKeys.add(key);
@@ -3237,18 +3308,30 @@ function createMinimalWorkerCtx(
           const key =
             typeof row.__deeplineRowKey === 'string'
               ? row.__deeplineRowKey
-              : derivePlayRowIdentity(publicCsvInputRow(row), name);
+              : derivePlayRowIdentity(
+                  publicCsvInputRow(row),
+                  name,
+                  mapLogicFingerprint,
+                );
           if (key) {
             completedKeys.add(key);
             preparedKeys.add(key);
           }
         }
         const missingPreparedRows = chunkRows.filter((row) => {
-          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
+          const key = derivePlayRowIdentity(
+            publicCsvInputRow(row),
+            name,
+            mapLogicFingerprint,
+          );
           return !key || !preparedKeys.has(key);
         });
         const rowsToExecute = chunkRows.filter((row) => {
-          const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
+          const key = derivePlayRowIdentity(
+            publicCsvInputRow(row),
+            name,
+            mapLogicFingerprint,
+          );
           return !key || pendingKeys.has(key) || !completedKeys.has(key);
         });
         const rowsInserted = prepared.inserted + missingPreparedRows.length;
@@ -3331,6 +3414,7 @@ function createMinimalWorkerCtx(
               __deeplineRowKey: derivePlayRowIdentity(
                 publicCsvInputRow(rowsToExecute[executedIndex]!),
                 name,
+                mapLogicFingerprint,
               ),
             })),
           });
@@ -3340,7 +3424,11 @@ function createMinimalWorkerCtx(
           const key =
             typeof completedRow.__deeplineRowKey === 'string'
               ? completedRow.__deeplineRowKey
-              : derivePlayRowIdentity(publicCsvInputRow(completedRow), name);
+              : derivePlayRowIdentity(
+                  publicCsvInputRow(completedRow),
+                  name,
+                  mapLogicFingerprint,
+                );
           if (key) {
             const { __deeplineRowKey: _rowKey, ...cleanedRow } =
               publicCsvInputRow(completedRow);
@@ -3357,12 +3445,17 @@ function createMinimalWorkerCtx(
           const key = derivePlayRowIdentity(
             publicCsvInputRow(rowsToExecute[executedIndex]!),
             name,
+            mapLogicFingerprint,
           );
           if (key) resultByKey.set(key, executedRow);
         }
         const out = chunkRows
           .map((row) => {
-            const key = derivePlayRowIdentity(publicCsvInputRow(row), name);
+            const key = derivePlayRowIdentity(
+              publicCsvInputRow(row),
+              name,
+              mapLogicFingerprint,
+            );
             return key ? resultByKey.get(key) : undefined;
           })
           .filter((row): row is T & Record<string, unknown> => Boolean(row));
@@ -3620,7 +3713,11 @@ function createMinimalWorkerCtx(
       const childIsMapBacked = childPipelineUsesCtxMap(
         childManifest.staticPipeline,
       );
+      const childNeedsWorkflowScheduler = childPipelineNeedsWorkflowScheduler(
+        childManifest.staticPipeline,
+      );
       let childConcurrencyAcquired = false;
+      let releaseChildPlaySlot: (() => void) | null = null;
       if (childIsMapBacked) {
         const nextInFlight =
           (inFlightChildCallsByPlayName[resolvedName] ?? 0) + 1;
@@ -3635,11 +3732,21 @@ function createMinimalWorkerCtx(
         childConcurrencyAcquired = true;
       }
       try {
+        releaseChildPlaySlot = await acquireChildPlaySlot();
         const childSubmitStartedAt = nowMs();
-        let started: { workflowId?: string; runId?: string; error?: unknown };
+        let started: {
+          workflowId?: string;
+          runId?: string;
+          status?: string;
+          output?: unknown;
+          result?: unknown;
+          error?: unknown;
+        };
         try {
           started = await submitChildPlayThroughCoordinator({
             req,
+            allowInline:
+              options?.timeoutMs == null && !childNeedsWorkflowScheduler,
             body: {
               name: resolvedName,
               input: isRecord(input) ? input : {},
@@ -3709,6 +3816,27 @@ function createMinimalWorkerCtx(
           ms: nowMs() - childSubmitStartedAt,
           status: 'ok',
         });
+        const startedStatus = String(started.status ?? '').toLowerCase();
+        if (startedStatus === 'completed') {
+          emitEvent({
+            type: 'log',
+            level: 'info',
+            message: `Completed child play ${resolvedName} (${normalizedKey})`,
+            ts: nowMs(),
+          });
+          return started.output ?? extractChildPlayOutput(started);
+        }
+        if (startedStatus === 'failed') {
+          const startedError = isRecord(started.error)
+            ? started.error
+            : { message: started.error };
+          const startedErrorMessage =
+            typeof startedError.message === 'string' &&
+            startedError.message.trim()
+              ? startedError.message.trim()
+              : `Child play ${resolvedName} (${workflowId}) failed.`;
+          throw new Error(startedErrorMessage);
+        }
         const childWaitStartedAt = nowMs();
         let result: unknown;
         try {
@@ -3761,6 +3889,7 @@ function createMinimalWorkerCtx(
         });
         return result;
       } finally {
+        releaseChildPlaySlot?.();
         if (childConcurrencyAcquired) {
           releaseChildPlayConcurrency(
             inFlightChildCallsByPlayName,

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

@@ -179,10 +179,26 @@ export class HttpClient {
           }
 
           if (!response.ok) {
-            const msg =
+            const errorValue =
               typeof parsed === 'object' && parsed && 'error' in parsed
-                ? String((parsed as Record<string, unknown>).error)
-                : `HTTP ${response.status}`;
+                ? (parsed as Record<string, unknown>).error
+                : undefined;
+            const msg =
+              typeof errorValue === 'string'
+                ? errorValue
+                : errorValue &&
+                    typeof errorValue === 'object' &&
+                    'message' in errorValue &&
+                    typeof (errorValue as Record<string, unknown>).message ===
+                      'string'
+                  ? (errorValue as Record<string, string>).message
+                  : typeof parsed === 'object' &&
+                      parsed &&
+                      'message' in parsed &&
+                      typeof (parsed as Record<string, unknown>).message ===
+                        'string'
+                    ? (parsed as Record<string, string>).message
+                    : `HTTP ${response.status}`;
             throw new DeeplineError(msg, response.status, 'API_ERROR', {
               response: parsed,
             });

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

@@ -1,2 +1,2 @@
-export const SDK_VERSION = "0.1.19";
+export const SDK_VERSION = "0.1.20";
 export const SDK_API_CONTRACT = "2026-05-runs-v2";

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

@@ -276,13 +276,64 @@ export function resolvePlayRunTableNamespace(
 export function derivePlayRowIdentity(
   row: Record<string, unknown>,
   tableNamespace: string,
+  logicFingerprint?: string | null,
 ): string {
-  const normalizedNamespace = normalizeTableNamespace(tableNamespace);
-  const canonicalRow = stableStringify(row);
-  const digest = sha256Hex(`${normalizedNamespace}\n${canonicalRow}`);
+  return deriveDerivedOutputIdentity({
+    inputItem: row,
+    operationNamespace: tableNamespace,
+    logicFingerprint,
+  });
+}
+
+export function deriveDerivedOutputIdentity(input: {
+  inputItem: Record<string, unknown>;
+  operationNamespace: string;
+  logicFingerprint?: string | null;
+}): string {
+  const normalizedNamespace = normalizeTableNamespace(
+    input.operationNamespace,
+  );
+  const canonicalRow = stableStringify(input.inputItem);
+  const fingerprint = input.logicFingerprint?.trim()
+    ? `\nlogic:${input.logicFingerprint.trim()}`
+    : '';
+  const digest = sha256Hex(
+    `${normalizedNamespace}${fingerprint}\n${canonicalRow}`,
+  );
   return `${normalizedNamespace}:${digest}`;
 }
 
+export function deriveToolRequestIdentity(input: {
+  toolId: string;
+  requestInput: Record<string, unknown>;
+  effectiveAccountContext?: string | null;
+  toolContractRevision?: string | number | null;
+  reuseSafetyPolicy?: string | null;
+}): string {
+  const toolId = input.toolId.trim();
+  if (!toolId) {
+    throw new Error('Tool request identity requires a non-empty tool id.');
+  }
+  const accountContext =
+    input.effectiveAccountContext?.trim() || 'default_account_context';
+  const contractRevision =
+    input.toolContractRevision == null
+      ? 'default_tool_contract'
+      : String(input.toolContractRevision).trim() || 'default_tool_contract';
+  const reuseSafetyPolicy =
+    input.reuseSafetyPolicy?.trim() || 'default_reuse_policy';
+  const digest = sha256Hex(
+    stableStringify({
+      accountContext,
+      requestInput: input.requestInput,
+      reuseSafetyPolicy,
+      toolContractRevision: contractRevision,
+      toolId,
+    }),
+  );
+  return `tool:${normalizeTableNamespace(toolId)}:${digest}`;
+}
+
 /**
  * Build a stable row identity from an explicit user-provided key string.
  *
@@ -293,9 +344,13 @@ export function derivePlayRowIdentity(
 export function derivePlayRowIdentityFromKey(
   key: string,
   tableNamespace: string,
+  logicFingerprint?: string | null,
 ): string {
   const normalizedNamespace = normalizeTableNamespace(tableNamespace);
-  const digest = sha256Hex(`${normalizedNamespace}\nkey:${key}`);
+  const fingerprint = logicFingerprint?.trim()
+    ? `\nlogic:${logicFingerprint.trim()}`
+    : '';
+  const digest = sha256Hex(`${normalizedNamespace}${fingerprint}\nkey:${key}`);
   return `${normalizedNamespace}:${digest}`;
 }
 

package/package.json

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