deepline 0.1.213 → 0.1.214

package/dist/bundling-sources/sdk/src/client.ts

@@ -1563,8 +1563,8 @@ export class DeeplineClient {
           ? { waitForCompletionMs: request.waitForCompletionMs }
           : {}),
         // Profile selection is the API's job, not the CLI's. The server
-        // defaults to workers_edge; tests and runtime probes that want a
-        // different profile pass `request.profile` explicitly.
+        // defaults to absurd; callers that need workers_edge pass
+        // `request.profile` explicitly.
         ...(request.profile ? { profile: request.profile } : {}),
         ...(integrationMode ? { integrationMode } : {}),
         ...(testPolicyOverrides ? { testPolicyOverrides } : {}),

package/dist/bundling-sources/sdk/src/release.ts

@@ -106,10 +106,10 @@ export const SDK_RELEASE = {
   // 0.1.154 removes the short-lived generated enrich StepOptions recompute
   // fields shipped in 0.1.153.
   // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
-  version: '0.1.213',
+  version: '0.1.214',
   apiContract: '2026-06-dataset-handle-results-hard-cutover',
   supportPolicy: {
-    latest: '0.1.213',
+    latest: '0.1.214',
     minimumSupported: '0.1.53',
     deprecatedBelow: '0.1.53',
     commandMinimumSupported: [

package/dist/bundling-sources/sdk/src/types.ts

@@ -1138,9 +1138,9 @@ export interface StartPlayRunRequest {
   /** Optionally let the start request wait briefly and return a terminal result. */
   waitForCompletionMs?: number;
   /**
-   * Per-run execution profile override. The server defaults to workers_edge;
-   * tests and runtime probes can pass a different profile here. Most callers
-   * should leave this unset.
+   * Per-run execution profile override. The server defaults to absurd;
+   * callers that need workers_edge can pass it here. Most callers should leave
+   * this unset.
    */
   profile?: string;
   /** Optional per-run provider execution mode for eval/smoke runs. */

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -284,6 +284,11 @@ const TOOL_RETRY_HEARTBEAT_INTERVAL_MS = 30_000;
 const DEEPLINEAGENT_TOOL_RUNTIME_TIMEOUT_MS = 15 * 60 * 1000;
 const FETCH_TRANSPORT_MAX_ATTEMPTS = 3;
 const FETCH_TRANSPORT_RETRY_DELAY_MS = 100;
+// cloudflared returns this branded HTML when its connection to the local app
+// resets. It is a transport failure before the app can reach a provider, not a
+// provider 502; require both the branded page and our development tunnel host.
+const DEEPLINE_DEVELOPER_TUNNEL_ORIGIN_502_PATTERN =
+  /\bdeeplinedeveloper\.com\s*\|\s*502\s*:\s*bad gateway\b/i;
 const CHILD_PLAY_LAUNCH_WRITE_CONFLICT_RETRY_DELAYS_MS = [
   50, 100, 200, 400, 800,
 ] as const;
@@ -518,6 +523,28 @@ export function resolveToolRuntimeTimeoutMs(
     : undefined;
 }
 
+function isDeeplineDeveloperTunnelOrigin502(input: {
+  url: string;
+  status: number;
+  bodyText: string;
+}): boolean {
+  if (
+    input.status !== 502 ||
+    !DEEPLINE_DEVELOPER_TUNNEL_ORIGIN_502_PATTERN.test(input.bodyText)
+  ) {
+    return false;
+  }
+  try {
+    const hostname = new URL(input.url).hostname.toLowerCase();
+    return (
+      hostname === 'deeplinedeveloper.com' ||
+      hostname.endsWith('.deeplinedeveloper.com')
+    );
+  } catch {
+    return false;
+  }
+}
+
 function loadSafeFetch(): Promise<SafeFetchModule> {
   safeFetchModule ??= import('@shared_libs/security/safe-fetch');
   return safeFetchModule;
@@ -8529,6 +8556,32 @@ export class PlayContextImpl {
           const retrySafeTransientHttp =
             retryPolicy?.retrySafeTransientHttp === true;
           let transportAttempt = 0;
+          const retryToolTransportFailure = async (
+            message: string,
+          ): Promise<void> => {
+            transportAttempt += 1;
+            if (transportAttempt < TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS) {
+              await this.governor.chargeBudget('retry');
+              const retryAfterMs =
+                TOOL_RETRY_AFTER_FALLBACK_MS * transportAttempt;
+              span.setAttribute(
+                'plays.transport_retry_attempt',
+                transportAttempt,
+              );
+              this.log(
+                `Tool ${toolId} transport failed calling ${url} on attempt ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS}; retrying after ${retryAfterMs}ms: ${message}`,
+              );
+              await options?.parkProviderCall?.();
+              await this.sleepWithCheckpointHeartbeat(retryAfterMs);
+              return;
+            }
+            throw new ToolHttpError(
+              `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${message}`,
+              null,
+              0,
+              'repairable',
+            );
+          };
 
           while (true) {
             let response: Response;
@@ -8696,32 +8749,12 @@ export class PlayContextImpl {
                       `Tool ${toolId} runtime API call timed out after ${timeoutMs}ms.`,
                     )
                 : error;
-              transportAttempt += 1;
               const message =
                 transportError instanceof Error
                   ? transportError.message
                   : String(transportError);
-              if (transportAttempt < TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS) {
-                await this.governor.chargeBudget('retry');
-                const retryAfterMs =
-                  TOOL_RETRY_AFTER_FALLBACK_MS * transportAttempt;
-                span.setAttribute(
-                  'plays.transport_retry_attempt',
-                  transportAttempt,
-                );
-                this.log(
-                  `Tool ${toolId} transport failed calling ${url} on attempt ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS}; retrying after ${retryAfterMs}ms: ${message}`,
-                );
-                await options?.parkProviderCall?.();
-                await this.sleepWithCheckpointHeartbeat(retryAfterMs);
-                continue;
-              }
-              throw new ToolHttpError(
-                `Tool ${toolId} transport failed calling ${url} after ${transportAttempt}/${TOOL_EXECUTE_TRANSPORT_MAX_ATTEMPTS} attempts: ${message}`,
-                null,
-                0,
-                'repairable',
-              );
+              await retryToolTransportFailure(message);
+              continue;
             } finally {
               if (timeoutHandle) {
                 clearTimeout(timeoutHandle);
@@ -8732,6 +8765,18 @@ export class PlayContextImpl {
 
             if (!response.ok) {
               const text = await response.text();
+              if (
+                isDeeplineDeveloperTunnelOrigin502({
+                  url,
+                  status: response.status,
+                  bodyText: text,
+                })
+              ) {
+                await retryToolTransportFailure(
+                  'the Deepline development tunnel returned a branded 502 before reaching the app origin',
+                );
+                continue;
+              }
               const authScopeChanged = parseToolExecuteAuthScopeChangedError({
                 status: response.status,
                 bodyText: text,

package/dist/bundling-sources/shared_libs/play-runtime/providers.ts

@@ -54,7 +54,7 @@ export const PLAY_RUNTIME_PROVIDERS: Record<
 };
 
 export function defaultPlayRuntimeProvider(): PlayRuntimeProviderDescriptor {
-  return PLAY_RUNTIME_PROVIDERS.workers_edge;
+  return PLAY_RUNTIME_PROVIDERS.absurd;
 }
 
 export function resolvePlayRuntimeProvider(

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backend.ts

@@ -4,8 +4,8 @@
  * One of three pluggable axes (alongside runner-backends and dedup-backends).
  * Selected per-run via PlayExecutionProfile.
  *
- * Cloudflare Workflows is the default production scheduler through the
- * workers_edge profile. Absurd is the durable Daytona-backed scheduler.
+ * Absurd is the default production scheduler through the absurd profile.
+ * Cloudflare Workflows remains available through the workers_edge profile.
  *
  * Customer plays are unaffected — this is purely the orchestration layer.
  */