deepline 0.1.150 → 0.1.151

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -1,7 +1,15 @@
-export const TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS = 3;
+import {
+  isHardBillingToolHttpError,
+  normalizeToolHttpErrorMessage,
+  type ToolHttpError,
+} from './tool-http-errors';
+
+export const TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS = 2;
 export const TOOL_EXECUTE_RATE_LIMIT_MAX_ATTEMPTS = 8;
 export const TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS = 3;
 export const TOOL_EXECUTE_TRANSPORT_RETRY_DELAY_MS = 1_000;
+export const TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS = 1_000;
+export const TOOL_EXECUTE_RETRY_DELAY_MAX_MS = 5_000;
 
 export type ToolExecuteHttpRetryDecision = {
   retryable: boolean;
@@ -9,15 +17,33 @@ export type ToolExecuteHttpRetryDecision = {
   reason:
     | 'rate_limit'
     | 'retry_safe_transient_5xx'
-    | 'hard_billing_error'
     | 'unsafe_transient_5xx'
+    | 'hard_billing_error'
     | 'non_retryable_status';
 };
 
-export function decideToolExecuteHttpRetry(input: {
-  toolId: string;
+export type ToolExecuteHttpFailureOutcome = ToolExecuteHttpRetryDecision & {
+  error: ToolHttpError;
+  shouldRetry: boolean;
+  isRateLimit: boolean;
+  fate: 'retry' | 'settle_row_failure' | 'fail_run';
+  retryDelayMs: number;
+  backpressureDelayMs: number | null;
+  chargeRetryBudget: boolean;
+};
+
+export type ToolExecuteHttpFailureAttemptTracker = {
+  next(input: {
+    toolId: string;
+    status: number;
+    transientHttpRetrySafe?: boolean;
+  }): number;
+};
+
+function decideToolExecuteHttpRetry(input: {
   status: number;
   hardBillingFailure?: boolean;
+  transientHttpRetrySafe?: boolean;
 }): ToolExecuteHttpRetryDecision {
   if (input.status === 429) {
     if (input.hardBillingFailure) {
@@ -34,17 +60,17 @@ export function decideToolExecuteHttpRetry(input: {
     };
   }
   if (input.status >= 500 && input.status < 600) {
-    if (input.toolId === 'test_transient_500') {
+    if (!input.transientHttpRetrySafe) {
       return {
-        retryable: true,
-        attemptCap: TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS,
-        reason: 'retry_safe_transient_5xx',
+        retryable: false,
+        attemptCap: 1,
+        reason: 'unsafe_transient_5xx',
       };
     }
     return {
-      retryable: false,
-      attemptCap: 1,
-      reason: 'unsafe_transient_5xx',
+      retryable: true,
+      attemptCap: TOOL_EXECUTE_TRANSIENT_HTTP_MAX_ATTEMPTS,
+      reason: 'retry_safe_transient_5xx',
     };
   }
   return {
@@ -53,3 +79,108 @@ export function decideToolExecuteHttpRetry(input: {
     reason: 'non_retryable_status',
   };
 }
+
+export function createToolExecuteHttpFailureAttemptTracker(): ToolExecuteHttpFailureAttemptTracker {
+  const attemptsByReason: Record<
+    ToolExecuteHttpRetryDecision['reason'],
+    number
+  > = {
+    rate_limit: 0,
+    retry_safe_transient_5xx: 0,
+    unsafe_transient_5xx: 0,
+    hard_billing_error: 0,
+    non_retryable_status: 0,
+  };
+
+  return {
+    next(input) {
+      const decision = decideToolExecuteHttpRetry({
+        status: input.status,
+        transientHttpRetrySafe: input.transientHttpRetrySafe === true,
+      });
+      attemptsByReason[decision.reason] += 1;
+      return attemptsByReason[decision.reason];
+    },
+  };
+}
+
+export function parseToolExecuteRetryAfterMs(
+  header: string | null | undefined,
+  nowMs = Date.now(),
+): number {
+  if (!header) return TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds) && seconds > 0) {
+    return Math.ceil(seconds * 1000);
+  }
+  const retryAt = Date.parse(header);
+  if (Number.isFinite(retryAt)) {
+    return Math.max(1, retryAt - nowMs);
+  }
+  return TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+}
+
+export function classifyToolExecuteHttpFailure(input: {
+  toolId: string;
+  status: number;
+  attempt: number;
+  bodyText: string;
+  retryAfterHeader?: string | null;
+  transientHttpRetrySafe?: boolean;
+  nowMs?: number;
+}): ToolExecuteHttpFailureOutcome {
+  const transientHttpRetrySafe = input.transientHttpRetrySafe === true;
+  const initialRetryDecision = decideToolExecuteHttpRetry({
+    status: input.status,
+    transientHttpRetrySafe,
+  });
+  const error = normalizeToolHttpErrorMessage({
+    toolId: input.toolId,
+    status: input.status,
+    attempt: input.attempt,
+    maxAttempts: initialRetryDecision.attemptCap,
+    bodyText: input.bodyText,
+  });
+  const retryDecision = decideToolExecuteHttpRetry({
+    status: input.status,
+    hardBillingFailure: isHardBillingToolHttpError(error),
+    transientHttpRetrySafe,
+  });
+  const shouldRetry =
+    retryDecision.retryable && input.attempt < retryDecision.attemptCap;
+  const retryAfterMs = parseToolExecuteRetryAfterMs(
+    input.retryAfterHeader,
+    input.nowMs,
+  );
+  const retryDelayMs =
+    input.status === 429
+      ? Math.min(
+          TOOL_EXECUTE_RETRY_DELAY_MAX_MS,
+          Math.max(
+            retryAfterMs,
+            TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS * input.attempt,
+          ),
+        )
+      : retryAfterMs > 0
+        ? Math.min(TOOL_EXECUTE_RETRY_DELAY_MAX_MS, retryAfterMs)
+        : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+  return {
+    ...retryDecision,
+    error,
+    shouldRetry,
+    isRateLimit: input.status === 429,
+    fate: shouldRetry
+      ? 'retry'
+      : retryDecision.reason === 'hard_billing_error'
+        ? 'fail_run'
+        : 'settle_row_failure',
+    retryDelayMs,
+    backpressureDelayMs:
+      input.status === 429
+        ? retryAfterMs > 0
+          ? retryAfterMs
+          : TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS
+        : null,
+    chargeRetryBudget: shouldRetry,
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/tool-http-errors.ts

@@ -240,8 +240,9 @@ export function isHardBillingToolHttpError(error: unknown): boolean {
 
 /**
  * A tool call that ultimately failed with HTTP 429 — provider or
- * Deepline-internal rate-limit pushback that survived the in-process retry
- * budget. This is run-level throughput pressure, never a row-specific defect.
+ * Deepline-internal rate-limit pushback. While the local retry budget is
+ * active it feeds provider pacing; after exhaustion it becomes a row-scoped
+ * Map Row Outcome unless the payload is a hard Deepline billing failure.
  */
 export function isRateLimitToolHttpError(error: unknown): boolean {
   return error instanceof ToolHttpError && error.status === 429;

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -1513,18 +1513,28 @@ async function computeWorkersHarnessFingerprintWithAdapter(
       hash: sha256(contents),
     });
   };
-  const collectTopLevelTsFiles = async (
+  const collectTsFilesRecursive = async (
     rootDir: string,
     parts: Array<{ name: string; hash: string }>,
   ) => {
     if (!(await fileExists(rootDir))) return;
-    const entries = await readdir(rootDir, { withFileTypes: true });
-    const tsFiles = entries
-      .filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name))
-      .map((entry) => entry.name)
-      .sort();
-    for (const name of tsFiles) {
-      await addFilePart(parts, rootDir, join(rootDir, name));
+    const filePaths: string[] = [];
+    const visitDir = async (dir: string) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const childPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await visitDir(childPath);
+          continue;
+        }
+        if (entry.isFile() && /\.[cm]?ts$/.test(entry.name)) {
+          filePaths.push(childPath);
+        }
+      }
+    };
+    await visitDir(rootDir);
+    for (const filePath of filePaths.sort()) {
+      await addFilePart(parts, rootDir, filePath);
     }
   };
   const collectIntegrationBatchingFiles = async (
@@ -1554,26 +1564,13 @@ async function computeWorkersHarnessFingerprintWithAdapter(
     }
   };
 
-  const entries = await readdir(adapter.workersHarnessFilesDir, {
-    withFileTypes: true,
-  });
-  const tsFiles = entries
-    .filter((e) => e.isFile() && /\.[cm]?ts$/.test(e.name))
-    .map((e) => e.name)
-    .sort();
   const parts: Array<{ name: string; hash: string }> = [];
-  for (const name of tsFiles) {
-    await addFilePart(
-      parts,
-      adapter.workersHarnessFilesDir,
-      join(adapter.workersHarnessFilesDir, name),
-    );
-  }
+  await collectTsFilesRecursive(adapter.workersHarnessFilesDir, parts);
   for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
     if (basename(dir) === 'integrations') {
       await collectIntegrationBatchingFiles(dir, parts);
     } else {
-      await collectTopLevelTsFiles(dir, parts);
+      await collectTsFilesRecursive(dir, parts);
     }
   }
   return sha256(JSON.stringify(parts));

package/dist/cli/index.js

@@ -420,7 +420,7 @@ function loadProjectEnvCandidates(startDir = process.cwd()) {
   }));
 }
 function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
   if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
@@ -655,10 +655,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.150",
+  version: "0.1.151",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.150",
+    latest: "0.1.151",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -10790,6 +10790,23 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     },
     Math.max(1, input2.waitTimeoutMs)
   );
+  const fetchKnownTerminalStatus = async () => {
+    if (!lastKnownWorkflowId) {
+      return null;
+    }
+    let refreshed;
+    try {
+      refreshed = await input2.client.getPlayStatus(lastKnownWorkflowId, {
+        billing: false
+      });
+    } catch (error) {
+      if (isTransientPlayStreamError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? { ...refreshed, dashboardUrl } : null;
+  };
   try {
     for await (const event of input2.client.startPlayRunStream(input2.request, {
       signal: controller.signal
@@ -10885,6 +10902,21 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     }
   } catch (error) {
     if (timedOut) {
+      const terminal = await fetchKnownTerminalStatus();
+      if (terminal) {
+        recordCliTrace({
+          phase: "cli.play_start_stream_timeout_status_reconcile",
+          ms: Date.now() - startedAt,
+          ok: true,
+          playName: input2.playName,
+          workflowId: lastKnownWorkflowId,
+          eventCount,
+          firstRunIdMs,
+          lastPhase,
+          status: terminal.status
+        });
+        return terminal;
+      }
       assertPlayWaitNotTimedOut({
         workflowId: lastKnownWorkflowId,
         startedAt,

package/dist/cli/index.mjs

@@ -405,7 +405,7 @@ function loadProjectEnvCandidates(startDir = process.cwd()) {
   }));
 }
 function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
   if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
@@ -640,10 +640,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.150",
+  version: "0.1.151",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.150",
+    latest: "0.1.151",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -10807,6 +10807,23 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     },
     Math.max(1, input2.waitTimeoutMs)
   );
+  const fetchKnownTerminalStatus = async () => {
+    if (!lastKnownWorkflowId) {
+      return null;
+    }
+    let refreshed;
+    try {
+      refreshed = await input2.client.getPlayStatus(lastKnownWorkflowId, {
+        billing: false
+      });
+    } catch (error) {
+      if (isTransientPlayStreamError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? { ...refreshed, dashboardUrl } : null;
+  };
   try {
     for await (const event of input2.client.startPlayRunStream(input2.request, {
       signal: controller.signal
@@ -10902,6 +10919,21 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     }
   } catch (error) {
     if (timedOut) {
+      const terminal = await fetchKnownTerminalStatus();
+      if (terminal) {
+        recordCliTrace({
+          phase: "cli.play_start_stream_timeout_status_reconcile",
+          ms: Date.now() - startedAt,
+          ok: true,
+          playName: input2.playName,
+          workflowId: lastKnownWorkflowId,
+          eventCount,
+          firstRunIdMs,
+          lastPhase,
+          status: terminal.status
+        });
+        return terminal;
+      }
       assertPlayWaitNotTimedOut({
         workflowId: lastKnownWorkflowId,
         startedAt,

package/dist/index.js

@@ -308,7 +308,7 @@ function loadProjectEnvCandidates(startDir = process.cwd()) {
   }));
 }
 function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
   if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
@@ -419,10 +419,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.150",
+  version: "0.1.151",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.150",
+    latest: "0.1.151",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/index.mjs

@@ -238,7 +238,7 @@ function loadProjectEnvCandidates(startDir = process.cwd()) {
   }));
 }
 function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
   if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
@@ -349,10 +349,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.150",
+  version: "0.1.151",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.150",
+    latest: "0.1.151",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [

package/dist/plays/bundle-play-file.mjs

@@ -1120,19 +1120,32 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
       hash: sha256(contents)
     });
   };
-  const collectTopLevelTsFiles = async (rootDir, parts2) => {
+  const collectTsFilesRecursive = async (rootDir, parts2) => {
     if (!await fileExists(rootDir)) return;
-    const entries2 = await readdir(rootDir, { withFileTypes: true });
-    const tsFiles2 = entries2.filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name)).map((entry) => entry.name).sort();
-    for (const name of tsFiles2) {
-      await addFilePart(parts2, rootDir, join(rootDir, name));
+    const filePaths = [];
+    const visitDir = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const childPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await visitDir(childPath);
+          continue;
+        }
+        if (entry.isFile() && /\.[cm]?ts$/.test(entry.name)) {
+          filePaths.push(childPath);
+        }
+      }
+    };
+    await visitDir(rootDir);
+    for (const filePath of filePaths.sort()) {
+      await addFilePart(parts2, rootDir, filePath);
     }
   };
   const collectIntegrationBatchingFiles = async (rootDir, parts2) => {
     if (!await fileExists(rootDir)) return;
-    const entries2 = await readdir(rootDir, { withFileTypes: true });
+    const entries = await readdir(rootDir, { withFileTypes: true });
     const filePaths = [];
-    for (const entry of entries2) {
+    for (const entry of entries) {
       if (entry.isFile() && (entry.name === "play-runtime-batching-registry.ts" || /^batching.*\.ts$/.test(entry.name))) {
         filePaths.push(join(rootDir, entry.name));
       }
@@ -1147,23 +1160,13 @@ async function computeWorkersHarnessFingerprintWithAdapter(adapter) {
       await addFilePart(parts2, rootDir, filePath);
     }
   };
-  const entries = await readdir(adapter.workersHarnessFilesDir, {
-    withFileTypes: true
-  });
-  const tsFiles = entries.filter((e) => e.isFile() && /\.[cm]?ts$/.test(e.name)).map((e) => e.name).sort();
   const parts = [];
-  for (const name of tsFiles) {
-    await addFilePart(
-      parts,
-      adapter.workersHarnessFilesDir,
-      join(adapter.workersHarnessFilesDir, name)
-    );
-  }
+  await collectTsFilesRecursive(adapter.workersHarnessFilesDir, parts);
   for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
     if (basename(dir) === "integrations") {
       await collectIntegrationBatchingFiles(dir, parts);
     } else {
-      await collectTopLevelTsFiles(dir, parts);
+      await collectTsFilesRecursive(dir, parts);
     }
   }
   return sha256(JSON.stringify(parts));

package/package.json

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