deepline 0.1.109 → 0.1.111

package/dist/index.mjs

@@ -196,10 +196,10 @@ var SDK_RELEASE = {
   // skill on the sdk sync surface, and the people-search-to-email prebuilt.
   // 0.1.108 ships explicit dataset column/tool recompute policy and removes
   // the SDK enrich generator's one-second stale policy.
-  version: "0.1.109",
+  version: "0.1.111",
   apiContract: "2026-06-dataset-column-cell-stale-hard-cutover",
   supportPolicy: {
-    latest: "0.1.109",
+    latest: "0.1.111",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -226,6 +226,7 @@ var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
 
 // src/http.ts
 var MAX_DIAGNOSTIC_HEADER_LENGTH = 120;
+var COWORK_NETWORK_HINT = "Claude Cowork appears to be running Deepline in a network-restricted sandbox. In Claude Desktop, open Settings > Capabilities, turn on Allow network egress, and set Domain allowlist to All domains for the Cowork session.";
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -261,6 +262,7 @@ var HttpClient = class {
       "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
       "X-Deepline-Client-Family": "sdk",
       "X-Deepline-CLI-Family": "sdk",
+      "X-Deepline-Agent-Runtime": detectAgentRuntime(),
       "X-Deepline-CLI-Version": SDK_VERSION,
       "X-Deepline-SDK-Version": SDK_VERSION,
       "X-Deepline-API-Contract": SDK_API_CONTRACT,
@@ -363,12 +365,13 @@ var HttpClient = class {
             parsed = body;
           }
           if (!response.ok) {
+            const retryableApiError = options?.retryApiErrors === true && isRetryableApiErrorResponse(response.status);
             const htmlError = detectHtmlErrorBody(
               body,
               response.headers.get("content-type")
             );
             if (htmlError) {
-              throw new DeeplineError(
+              lastError = new DeeplineError(
                 htmlError.message(response.status),
                 response.status,
                 "API_ERROR",
@@ -378,12 +381,23 @@ var HttpClient = class {
                   ...htmlError.workerThrewException ? { workerThrewException: true } : {}
                 }
               );
+              if (retryableApiError && attempt < this.config.maxRetries) {
+                retryAfterDelayMs = parseOptionalRetryAfter(response);
+                break;
+              }
+              throw lastError;
             }
             const errorValue = typeof parsed === "object" && parsed && "error" in parsed ? parsed.error : void 0;
             const msg = typeof errorValue === "string" ? errorValue : errorValue && typeof errorValue === "object" && "message" in errorValue && typeof errorValue.message === "string" ? errorValue.message : typeof parsed === "object" && parsed && "message" in parsed && typeof parsed.message === "string" ? parsed.message : `HTTP ${response.status}`;
-            throw new DeeplineError(msg, response.status, "API_ERROR", {
+            const apiErrorCode = errorValue && typeof errorValue === "object" && typeof errorValue.code === "string" ? errorValue.code : "API_ERROR";
+            lastError = new DeeplineError(msg, response.status, apiErrorCode, {
               response: parsed
             });
+            if (retryableApiError && attempt < this.config.maxRetries) {
+              retryAfterDelayMs = parseOptionalRetryAfter(response);
+              break;
+            }
+            throw lastError;
           }
           return parsed;
         } catch (error) {
@@ -404,7 +418,7 @@ var HttpClient = class {
       throw lastError;
     }
     const errorMessage = lastError?.message ? `Unable to connect to ${baseUrl}. ${lastError.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`;
-    throw new DeeplineError(errorMessage);
+    throw new DeeplineError(withCoworkNetworkHint(errorMessage));
   }
   /**
    * Send a GET request.
@@ -476,7 +490,9 @@ var HttpClient = class {
       }
     }
     throw new DeeplineError(
-      lastError?.message ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}` : `Unable to stream from ${this.config.baseUrl}.`
+      withCoworkNetworkHint(
+        lastError?.message ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}` : `Unable to stream from ${this.config.baseUrl}.`
+      )
     );
   }
   /**
@@ -486,11 +502,12 @@ var HttpClient = class {
    * @param path - API path
    * @param body - Request body (will be JSON-serialized)
    */
-  async post(path, body, headers) {
+  async post(path, body, headers, options) {
     return this.request(path, {
       method: "POST",
       body,
-      headers
+      headers,
+      ...options
     });
   }
   async postFormData(path, formData, headers) {
@@ -531,6 +548,9 @@ function parseResponseBody(body) {
     return body;
   }
 }
+function isRetryableApiErrorResponse(status) {
+  return status === 408 || status === 425 || status >= 500 && status < 600;
+}
 function detectHtmlErrorBody(body, contentType) {
   const trimmed = body.trim();
   const lower = trimmed.toLowerCase();
@@ -570,6 +590,9 @@ function apiErrorMessage(parsed, status) {
   return `HTTP ${status}`;
 }
 function parseRetryAfter(response) {
+  return parseOptionalRetryAfter(response) ?? 5e3;
+}
+function parseOptionalRetryAfter(response) {
   const header = response.headers.get("retry-after");
   if (header) {
     const seconds = Number(header);
@@ -577,7 +600,7 @@ function parseRetryAfter(response) {
       return seconds * 1e3;
     }
   }
-  return 5e3;
+  return null;
 }
 function buildCandidateUrls(url) {
   try {
@@ -634,6 +657,39 @@ function decodeSseFrame(frame) {
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+function isTruthyEnv(name) {
+  const normalized = process.env[name]?.trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(normalized ?? "");
+}
+function isCoworkLikeSandbox() {
+  const pluginMode = isTruthyEnv("DEEPLINE_PLUGIN_MODE");
+  const claudeRemote = isTruthyEnv("CLAUDE_CODE_REMOTE");
+  const projectDir = Boolean(process.env.CLAUDE_PROJECT_DIR?.trim());
+  const pluginRoot = Boolean(process.env.DEEPLINE_PLUGIN_ROOT?.trim());
+  const home = process.env.HOME?.trim() ?? "";
+  const sessionHome = home.startsWith("/sessions/");
+  return (pluginMode || pluginRoot) && (claudeRemote || projectDir || sessionHome);
+}
+function detectAgentRuntime() {
+  if (process.env.CODEX_THREAD_ID?.trim()) return "codex";
+  if (isCoworkLikeSandbox()) return "claude_cowork";
+  if (process.env.CLAUDECODE?.trim() === "1") return "claude_code";
+  if (process.env.CLINE_ACTIVE?.trim().toLowerCase() === "true") return "cline";
+  if (process.env.CURSOR_TRACE_ID?.trim() || process.env.CURSOR_AGENT?.trim()) {
+    return "cursor";
+  }
+  if (process.env.WINDSURF?.trim() || process.env.CASCADE?.trim()) {
+    return "windsurf";
+  }
+  return "unknown";
+}
+function withCoworkNetworkHint(message) {
+  if (!isCoworkLikeSandbox() || message.includes(COWORK_NETWORK_HINT)) {
+    return message;
+  }
+  return `${message}
+${COWORK_NETWORK_HINT}`;
+}
 
 // src/stream-reconnect.ts
 var STREAM_RECONNECT_BASE_DELAY_MS = 500;
@@ -1910,12 +1966,12 @@ var DeeplineClient = class {
    * Returns everything from {@link ToolDefinition} plus pricing info, sample
    * inputs/outputs, failure modes, and cost estimates.
    *
-   * @param toolId - Tool identifier (e.g. `"apollo_people_search"`)
+   * @param toolId - Tool identifier (e.g. `"dropleads_search_people"`)
    * @returns Full tool metadata
    *
    * @example
    * ```typescript
-   * const meta = await client.getTool('apollo_people_search');
+   * const meta = await client.getTool('dropleads_search_people');
    * console.log(`Cost: ${meta.estimatedCreditsRange} credits`);
    * console.log(`Input schema:`, meta.inputSchema);
    * ```
@@ -1947,7 +2003,8 @@ var DeeplineClient = class {
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
       { payload: input },
-      headers
+      headers,
+      { forbiddenAsApiError: true }
     );
   }
   /**
@@ -2029,7 +2086,7 @@ var DeeplineClient = class {
         ...request.force ? { force: true } : {},
         ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
         // Profile selection is the API's job, not the CLI's. The server
-        // hardcodes workers_edge as the default; tests that want a
+        // defaults to workers_edge; tests and runtime probes that want a
         // different profile pass `request.profile` explicitly.
         ...request.profile ? { profile: request.profile } : {}
       }
@@ -2094,10 +2151,15 @@ var DeeplineClient = class {
       sourceFiles: input.sourceFiles,
       artifact: input.artifact
     });
-    return this.http.post("/api/v2/plays/artifacts", {
-      ...input,
-      compilerManifest
-    });
+    return this.http.post(
+      "/api/v2/plays/artifacts",
+      {
+        ...input,
+        compilerManifest
+      },
+      void 0,
+      { forbiddenAsApiError: true, retryApiErrors: true }
+    );
   }
   /**
    * Register multiple bundled play artifacts in one request.
@@ -2107,7 +2169,12 @@ var DeeplineClient = class {
    */
   async registerPlayArtifacts(artifacts) {
     if (artifacts.length === 0) {
-      return this.http.post("/api/v2/plays/artifacts", { artifacts });
+      return this.http.post(
+        "/api/v2/plays/artifacts",
+        { artifacts },
+        void 0,
+        { forbiddenAsApiError: true, retryApiErrors: true }
+      );
     }
     const compiledArtifacts = await mapWithConcurrency(
       artifacts,
@@ -2125,9 +2192,14 @@ var DeeplineClient = class {
     const responses = [];
     for (const chunk of chunkRegisterPlayArtifacts(compiledArtifacts)) {
       responses.push(
-        await this.http.post("/api/v2/plays/artifacts", {
-          artifacts: chunk
-        })
+        await this.http.post(
+          "/api/v2/plays/artifacts",
+          {
+            artifacts: chunk
+          },
+          void 0,
+          { forbiddenAsApiError: true, retryApiErrors: true }
+        )
       );
     }
     return {
@@ -2932,7 +3004,9 @@ var DeeplineClient = class {
     const encodedName = encodeURIComponent(name);
     return this.http.post(
       `/api/v2/plays/${encodedName}/live`,
-      request
+      request,
+      void 0,
+      { forbiddenAsApiError: true }
     );
   }
   /**
@@ -4174,7 +4248,7 @@ var DeeplineContext = class {
    * @example
    * ```typescript
    * const tools = await deepline.tools.list();
-   * const meta = await deepline.tools.get('apollo_people_search');
+   * const meta = await deepline.tools.get('dropleads_search_people');
    * const companyLookup = await deepline.tools.execute('test_company_search', { domain: 'stripe.com' });
    * const company = companyLookup.toolResponse.raw;
    * ```

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

@@ -44,6 +44,7 @@ import type {
   PlayRuntimeManifest,
   PlayRuntimeManifestMap,
 } from '../../../shared_libs/plays/compiler-manifest';
+import { normalizePlayRunFailure } from '../../../shared_libs/play-runtime/run-failure';
 import type { PlayRunLedgerEvent } from '../../../shared_libs/play-runtime/run-ledger';
 import {
   COORDINATOR_INTERNAL_TOKEN_HEADER,
@@ -61,6 +62,7 @@ import {
   workflowRetryParamsStorageKey,
   type WorkflowRetryParamsRef,
 } from './workflow-retry-state';
+import { createOrAttachWorkflowInstance } from './workflow-instance-create';
 import { sanitizeLiveLogLines } from './runtime/live-progress';
 
 export { DynamicWorkflowBinding };
@@ -2896,136 +2898,181 @@ export class DynamicWorkflow extends WorkflowEntrypoint<
       },
     });
 
-    return dispatchWorkflow(
-      { env: this.env, ctx: this.ctx },
-      dispatchedEvent as Parameters<typeof dispatchWorkflow>[1],
-      step as Parameters<typeof dispatchWorkflow>[2],
-      async ({ metadata, env }) => {
-        const graphHash = readMetadataString(metadata, 'graphHash');
-        const artifactStorageKey = readMetadataString(
-          metadata,
-          'artifactStorageKey',
-        );
-        const runIdForTrace =
-          typeof (metadata as Record<string, unknown>).runId === 'string'
-            ? ((metadata as Record<string, unknown>).runId as string)
-            : graphHash;
-        const loaderStartedAt = Date.now();
-        trace({
-          runId: runIdForTrace,
-          phase: 'coordinator.loader_callback_entry',
-          ms: 0,
-          graphHash,
-          extra: { artifactStorageKey },
-        });
-        const stub = loadDynamicPlayWorkerSync(
-          env,
-          {
+    const dispatchWorkflowStartedAt = Date.now();
+    try {
+      return await dispatchWorkflow(
+        { env: this.env, ctx: this.ctx },
+        dispatchedEvent as Parameters<typeof dispatchWorkflow>[1],
+        step as Parameters<typeof dispatchWorkflow>[2],
+        async ({ metadata, env }) => {
+          const graphHash = readMetadataString(metadata, 'graphHash');
+          const artifactStorageKey = readMetadataString(
+            metadata,
+            'artifactStorageKey',
+          );
+          const runIdForTrace =
+            typeof (metadata as Record<string, unknown>).runId === 'string'
+              ? ((metadata as Record<string, unknown>).runId as string)
+              : graphHash;
+          const loaderStartedAt = Date.now();
+          trace({
             runId: runIdForTrace,
+            phase: 'coordinator.loader_callback_entry',
+            ms: 0,
             graphHash,
-            artifactStorageKey,
-            artifactHash:
-              typeof metadata.artifactHash === 'string'
-                ? metadata.artifactHash
-                : null,
-            dynamicWorkerCode:
-              typeof metadata.dynamicWorkerCode === 'string'
-                ? metadata.dynamicWorkerCode
-                : null,
-            packagedFiles: normalizePackagedFiles(metadata.packagedFiles),
-          },
-          trace,
-        );
-        const entrypoint = stub.getEntrypoint(
-          'TenantWorkflow',
-        ) as unknown as WorkflowRunner;
-        trace({
-          runId: runIdForTrace,
-          phase: 'coordinator.loader_compile',
-          ms: Date.now() - loaderStartedAt,
-          graphHash,
-        });
-        // Wrap the entrypoint so its run() failure surfaces here rather
-        // than disappearing into the framework's silent rpcMethod=run
-        // exception path.
-        return {
-          run: async (innerEvent: unknown, innerStep: unknown) => {
-            const innerStartedAt = Date.now();
-            trace({
+            extra: { artifactStorageKey },
+          });
+          const stub = loadDynamicPlayWorkerSync(
+            env,
+            {
               runId: runIdForTrace,
-              phase: 'coordinator.runner_run_start',
-              ms: 0,
               graphHash,
-            });
-            try {
-              const result = await (
-                entrypoint as unknown as {
-                  run(e: unknown, s: unknown): Promise<unknown>;
-                }
-              ).run(innerEvent, innerStep);
-              const output = isRecord(result) ? result : null;
-              await writeCoordinatorTerminalState(env, {
-                runId: runIdForTrace,
-                status: 'completed',
-                result: output?.result ?? result,
-                totalRows: output?.totalRows ?? output?.outputRows ?? null,
-                durationMs: output?.durationMs ?? null,
-                playName:
-                  typeof output?.playName === 'string' ? output.playName : null,
-                liveLogs: sanitizeLiveLogLines(output?.liveLogs),
-                liveNodeProgress: output?.liveNodeProgress ?? null,
-              });
+              artifactStorageKey,
+              artifactHash:
+                typeof metadata.artifactHash === 'string'
+                  ? metadata.artifactHash
+                  : null,
+              dynamicWorkerCode:
+                typeof metadata.dynamicWorkerCode === 'string'
+                  ? metadata.dynamicWorkerCode
+                  : null,
+              packagedFiles: normalizePackagedFiles(metadata.packagedFiles),
+            },
+            trace,
+          );
+          const entrypointStartedAt = Date.now();
+          const entrypoint = stub.getEntrypoint(
+            'TenantWorkflow',
+          ) as unknown as WorkflowRunner;
+          trace({
+            runId: runIdForTrace,
+            phase: 'coordinator.loader_get_entrypoint',
+            ms: Date.now() - entrypointStartedAt,
+            graphHash,
+          });
+          trace({
+            runId: runIdForTrace,
+            phase: 'coordinator.loader_compile',
+            ms: Date.now() - loaderStartedAt,
+            graphHash,
+          });
+          // Wrap the entrypoint so its run() failure surfaces here rather
+          // than disappearing into the framework's silent rpcMethod=run
+          // exception path.
+          return {
+            run: async (innerEvent: unknown, innerStep: unknown) => {
+              const innerStartedAt = Date.now();
               trace({
                 runId: runIdForTrace,
-                phase: 'coordinator.runner_run',
-                ms: Date.now() - innerStartedAt,
-                graphHash,
-              });
-              return result;
-            } catch (innerError) {
-              console.error('[coordinator] DynamicWorkflow runner.run threw', {
+                phase: 'coordinator.runner_run_start',
+                ms: 0,
                 graphHash,
-                message:
-                  innerError instanceof Error
-                    ? innerError.message
-                    : String(innerError),
-                name: innerError instanceof Error ? innerError.name : null,
-                stack:
-                  innerError instanceof Error &&
-                  typeof innerError.stack === 'string'
-                    ? innerError.stack.split('\n').slice(0, 12).join('\n')
-                    : null,
               });
-              await markWorkflowRuntimeFailure({
-                env,
-                event: innerEvent,
-                error: innerError,
-              }).catch((markError) => {
+              try {
+                const result = await (
+                  entrypoint as unknown as {
+                    run(e: unknown, s: unknown): Promise<unknown>;
+                  }
+                ).run(innerEvent, innerStep);
+                const output = isRecord(result) ? result : null;
+                const terminalStartedAt = Date.now();
+                try {
+                  await writeCoordinatorTerminalState(env, {
+                    runId: runIdForTrace,
+                    status: 'completed',
+                    result: output?.result ?? result,
+                    totalRows: output?.totalRows ?? output?.outputRows ?? null,
+                    durationMs: output?.durationMs ?? null,
+                    playName:
+                      typeof output?.playName === 'string'
+                        ? output.playName
+                        : null,
+                    liveLogs: sanitizeLiveLogLines(output?.liveLogs),
+                    liveNodeProgress: output?.liveNodeProgress ?? null,
+                  });
+                  trace({
+                    runId: runIdForTrace,
+                    phase: 'coordinator.terminal_state_write',
+                    ms: Date.now() - terminalStartedAt,
+                    graphHash,
+                    extra: { status: 'completed' },
+                  });
+                } catch (terminalError) {
+                  console.warn(
+                    '[coordinator] completed terminal cache write failed; preserving completed run',
+                    {
+                      graphHash,
+                      runId: runIdForTrace,
+                      message:
+                        terminalError instanceof Error
+                          ? terminalError.message
+                          : String(terminalError),
+                    },
+                  );
+                }
+                trace({
+                  runId: runIdForTrace,
+                  phase: 'coordinator.runner_run',
+                  ms: Date.now() - innerStartedAt,
+                  graphHash,
+                });
+                return result;
+              } catch (innerError) {
+                const failure = normalizePlayRunFailure(innerError);
                 console.error(
-                  '[coordinator] failed to forward DynamicWorkflow runner error',
+                  '[coordinator] DynamicWorkflow runner.run threw',
                   {
                     graphHash,
                     message:
-                      markError instanceof Error
-                        ? markError.message
-                        : String(markError),
+                      innerError instanceof Error
+                        ? innerError.message
+                        : String(innerError),
+                    name: innerError instanceof Error ? innerError.name : null,
+                    stack:
+                      innerError instanceof Error &&
+                      typeof innerError.stack === 'string'
+                        ? innerError.stack.split('\n').slice(0, 12).join('\n')
+                        : null,
                   },
                 );
-              });
-              await writeCoordinatorTerminalState(env, {
-                runId: runIdForTrace,
-                status: 'failed',
-                error:
-                  innerError instanceof Error
-                    ? innerError.message
-                    : String(innerError),
-              }).catch(() => undefined);
-              throw innerError;
-            }
-          },
-        };
-      },
-    );
+                await markWorkflowRuntimeFailure({
+                  env,
+                  event: innerEvent,
+                  error: innerError,
+                }).catch((markError) => {
+                  console.error(
+                    '[coordinator] failed to forward DynamicWorkflow runner error',
+                    {
+                      graphHash,
+                      message:
+                        markError instanceof Error
+                          ? markError.message
+                          : String(markError),
+                    },
+                  );
+                });
+                await writeCoordinatorTerminalState(env, {
+                  runId: runIdForTrace,
+                  status: 'failed',
+                  error: failure.message,
+                }).catch(() => undefined);
+                throw innerError;
+              }
+            },
+          };
+        },
+      );
+    } finally {
+      trace({
+        runId: dispatchTrace.runId,
+        phase: 'coordinator.dispatch_workflow_total',
+        ms: Date.now() - dispatchWorkflowStartedAt,
+        graphHash: dispatchTrace.graphHash,
+        extra: {
+          instanceId: dispatchTrace.instanceId,
+        },
+      });
+    }
   }
 }
 
@@ -3410,6 +3457,18 @@ async function handleWorkflowRoute(input: {
     const parseStartedAt = Date.now();
     const params = (await request.json()) as PlayWorkflowParams;
     submittedRunId = params.runId ?? runId;
+    recordSubmitTiming({
+      phase: 'coordinator.submit_received',
+      ms: Date.now() - submitStartedAt,
+      graphHash: params.graphHash ?? null,
+      extra: {
+        hasDynamicWorkerCode: Boolean(params.dynamicWorkerCode),
+        dynamicWorkerBytes:
+          typeof params.dynamicWorkerCode === 'string'
+            ? params.dynamicWorkerCode.length
+            : 0,
+      },
+    });
     recordSubmitTiming({
       phase: 'coordinator.submit_parse_body',
       ms: Date.now() - parseStartedAt,
@@ -3539,17 +3598,28 @@ async function handleWorkflowRoute(input: {
     try {
       const dispatchStartedAt = Date.now();
       const createStartedAt = Date.now();
-      instance = await createDynamicWorkflowInstance({
-        env,
-        id: defaultInstanceId,
-        params: workflowParams,
+      recordSubmitTiming({
+        phase: 'coordinator.workflow_create_start',
+        ms: 0,
+        graphHash: params.graphHash ?? null,
+        extra: { instanceId: defaultInstanceId },
+      });
+      const createResult = await createOrAttachWorkflowInstance({
+        create: () =>
+          createDynamicWorkflowInstance({
+            env,
+            id: defaultInstanceId,
+            params: workflowParams,
+          }),
+        getExisting: () => env.PLAY_WORKFLOW.get(defaultInstanceId),
       });
+      instance = createResult.instance;
       const workflowCreatedAt = Date.now();
       recordSubmitTiming({
         phase: 'coordinator.workflow_create',
         ms: workflowCreatedAt - createStartedAt,
         graphHash: params.graphHash ?? null,
-        extra: { instanceId: instance.id },
+        extra: { instanceId: instance.id, startMode: createResult.startMode },
       });
       const instanceIdRecord = recordWorkflowInstanceId({
         env,
@@ -3569,6 +3639,7 @@ async function handleWorkflowRoute(input: {
         graphHash: params.graphHash ?? null,
         extra: {
           startMode: 'direct_workflow_create',
+          workflowCreateMode: createResult.startMode,
           instanceIdRecord: 'waitUntil',
         },
       });