deepline 0.1.178 → 0.1.180

package/dist/index.js

@@ -422,10 +422,10 @@ var 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.178",
+  version: "0.1.180",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.178",
+    latest: "0.1.180",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -586,6 +586,58 @@ 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 REQUEST_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestAbort");
+function normalizeRequestAbortError(error, input) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const tagged = normalized;
+  if (input.timedOut) {
+    tagged[REQUEST_TIMEOUT_MARKER] = input.timeoutMs;
+  } else if (isAbortLikeError(normalized)) {
+    tagged[REQUEST_ABORT_MARKER] = true;
+  }
+  return normalized;
+}
+function isAbortLikeError(error) {
+  const name = error.name.toLowerCase();
+  const message = error.message.toLowerCase();
+  return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
+}
+function mapNetworkError(baseUrl, error, targetLabel) {
+  const tagged = error;
+  const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
+  if (typeof timeoutMs === "number") {
+    return {
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      code: "NETWORK_TIMEOUT",
+      details: { timeoutMs, target: targetLabel }
+    };
+  }
+  if (tagged?.[REQUEST_ABORT_MARKER]) {
+    return {
+      message: `Request to ${targetLabel} was aborted before it completed.`,
+      code: "NETWORK_ABORTED"
+    };
+  }
+  return {
+    message: error?.message ? `Unable to connect to ${baseUrl}. ${error.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`,
+    code: "NETWORK_ERROR"
+  };
+}
+function describeRequestTarget(path) {
+  const toolExecuteMatch = path.match(
+    /^\/api\/v2\/integrations\/([^/?#]+)\/execute(?:[/?#]|$)/
+  );
+  if (toolExecuteMatch) {
+    return providerLabelFromToolId(decodeURIComponent(toolExecuteMatch[1]));
+  }
+  return "Deepline";
+}
+function providerLabelFromToolId(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  const provider = normalized.split(/[_:./-]+/)[0];
+  return provider || normalized || "provider";
+}
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -698,10 +750,12 @@ var HttpClient = class {
       }
       for (const candidateUrl of candidateUrls) {
         const controller = new AbortController();
-        const timeoutId = setTimeout(
-          () => controller.abort(),
-          options?.timeout ?? this.config.timeout
-        );
+        const timeoutMs = options?.timeout ?? this.config.timeout;
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
         try {
           const response = await fetch(candidateUrl, {
             method,
@@ -774,7 +828,10 @@ var HttpClient = class {
             lastError = error;
             break;
           }
-          lastError = error instanceof Error ? error : new Error(String(error));
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
         }
       }
       if (attempt < maxRetries) continue;
@@ -782,8 +839,17 @@ var HttpClient = class {
     if (lastError instanceof DeeplineError) {
       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(withCoworkNetworkHint(errorMessage));
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    throw new DeeplineError(
+      withCoworkNetworkHint(mappedNetworkError.message),
+      void 0,
+      mappedNetworkError.code,
+      mappedNetworkError.details
+    );
   }
   /**
    * Send a GET request.
@@ -2054,6 +2120,57 @@ function decodeBase64Bytes(value) {
   }
   return bytes;
 }
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof DeeplineError && error.statusCode === 404;
+}
+function formatMegabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function uploadStagedFileToPresignedUrl(input) {
+  const arrayBuffer = input.body.buffer.slice(
+    input.body.byteOffset,
+    input.body.byteOffset + input.body.byteLength
+  );
+  let lastError;
+  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetch(input.url, {
+        method: "PUT",
+        headers: input.headers,
+        body: new Blob([arrayBuffer])
+      });
+      if (response.ok) {
+        return;
+      }
+      const text = await response.text().catch(() => "");
+      lastError = new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
+        response.status,
+        "STAGED_FILE_UPLOAD_FAILED",
+        { logicalPath: input.logicalPath }
+      );
+      if (response.status < 500 && response.status !== 429) {
+        break;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
+      await sleep2(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new DeeplineError(
+    `Direct storage upload of ${input.logicalPath} failed.`,
+    void 0,
+    "STAGED_FILE_UPLOAD_FAILED",
+    { logicalPath: input.logicalPath }
+  );
+}
 function readStringArray(value) {
   return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
 }
@@ -2459,6 +2576,21 @@ var DeeplineClient = class {
       ...input.maxRows ? { max_rows: input.maxRows } : {}
     });
   }
+  /**
+   * Re-establish this workspace's tenant storage contract: role/DB connect
+   * grants plus materialized table grants. Org-admin only. Use when a run fails
+   * with WORKSPACE_STORAGE_NOT_READY.
+   */
+  async repairIngestionStorage(input) {
+    return this.http.post(
+      "/api/v2/ingestion/repair",
+      {
+        ...input?.provider ? { provider: input.provider } : {}
+      },
+      void 0,
+      { forbiddenAsApiError: true }
+    );
+  }
   // ——————————————————————————————————————————————————————————
   // Plays — submission and lifecycle
   // ——————————————————————————————————————————————————————————
@@ -2836,6 +2968,94 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
+    let uploads;
+    try {
+      uploads = await this.mintStagedPlayFileUploads(
+        files.map((file) => ({
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      );
+    } catch (error) {
+      if (isStagedUploadMintUnsupported(error)) {
+        return this.stagePlayFilesViaMultipart(files);
+      }
+      throw error;
+    }
+    const uploadByIdentity = /* @__PURE__ */ new Map();
+    for (const upload of uploads) {
+      uploadByIdentity.set(
+        stagedUploadIdentity(upload.logicalPath, upload.contentHash),
+        upload
+      );
+    }
+    await Promise.all(
+      files.map(async (file) => {
+        const upload = uploadByIdentity.get(
+          stagedUploadIdentity(file.logicalPath, file.contentHash)
+        );
+        if (!upload) {
+          throw new DeeplineError(
+            `The staging server did not return an upload target for ${file.logicalPath}.`,
+            void 0,
+            "STAGED_FILE_MINT_INCOMPLETE"
+          );
+        }
+        if (upload.alreadyStaged || !upload.uploadUrl) {
+          return;
+        }
+        await uploadStagedFileToPresignedUrl({
+          url: upload.uploadUrl,
+          headers: upload.uploadHeaders ?? {
+            "content-type": file.contentType
+          },
+          body: decodeBase64Bytes(file.contentBase64),
+          logicalPath: file.logicalPath
+        });
+      })
+    );
+    return files.map((file) => {
+      const upload = uploadByIdentity.get(
+        stagedUploadIdentity(file.logicalPath, file.contentHash)
+      );
+      if (!upload) {
+        throw new DeeplineError(
+          `The staging server did not return an upload target for ${file.logicalPath}.`,
+          void 0,
+          "STAGED_FILE_MINT_INCOMPLETE"
+        );
+      }
+      return upload.ref;
+    });
+  }
+  /**
+   * Mint short-lived presigned upload targets for staged play files.
+   *
+   * Internal primitive used by {@link stagePlayFiles}. The server returns an
+   * already-staged ref (no upload needed) for content-addressed files it
+   * already holds, or a presigned PUT URL the caller uploads the body to.
+   */
+  async mintStagedPlayFileUploads(files) {
+    const response = await this.http.post("/api/v2/plays/files/stage/mint", { files });
+    return response.uploads ?? [];
+  }
+  async stagePlayFilesViaMultipart(files) {
+    for (const file of files) {
+      if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+        throw new DeeplineError(
+          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): the connected Deepline server does not support direct-to-storage uploads, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to. Update the Deepline server (or target code.deepline.com) to stage files this large.`,
+          413,
+          "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
+          {
+            logicalPath: file.logicalPath,
+            bytes: file.bytes,
+            maxBytes: STAGE_LEGACY_MULTIPART_MAX_BYTES
+          }
+        );
+      }
+    }
     const buildFormData = () => {
       const formData = new FormData();
       formData.set(

package/dist/index.mjs

@@ -352,10 +352,10 @@ var 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.178",
+  version: "0.1.180",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.178",
+    latest: "0.1.180",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -516,6 +516,58 @@ 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 REQUEST_TIMEOUT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = /* @__PURE__ */ Symbol("deeplineRequestAbort");
+function normalizeRequestAbortError(error, input) {
+  const normalized = error instanceof Error ? error : new Error(String(error));
+  const tagged = normalized;
+  if (input.timedOut) {
+    tagged[REQUEST_TIMEOUT_MARKER] = input.timeoutMs;
+  } else if (isAbortLikeError(normalized)) {
+    tagged[REQUEST_ABORT_MARKER] = true;
+  }
+  return normalized;
+}
+function isAbortLikeError(error) {
+  const name = error.name.toLowerCase();
+  const message = error.message.toLowerCase();
+  return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
+}
+function mapNetworkError(baseUrl, error, targetLabel) {
+  const tagged = error;
+  const timeoutMs = tagged?.[REQUEST_TIMEOUT_MARKER];
+  if (typeof timeoutMs === "number") {
+    return {
+      message: `Request to ${targetLabel} timed out after ${timeoutMs}ms while waiting for a response.`,
+      code: "NETWORK_TIMEOUT",
+      details: { timeoutMs, target: targetLabel }
+    };
+  }
+  if (tagged?.[REQUEST_ABORT_MARKER]) {
+    return {
+      message: `Request to ${targetLabel} was aborted before it completed.`,
+      code: "NETWORK_ABORTED"
+    };
+  }
+  return {
+    message: error?.message ? `Unable to connect to ${baseUrl}. ${error.message}` : `Unable to connect to ${baseUrl}. Is the computer able to access the url?`,
+    code: "NETWORK_ERROR"
+  };
+}
+function describeRequestTarget(path) {
+  const toolExecuteMatch = path.match(
+    /^\/api\/v2\/integrations\/([^/?#]+)\/execute(?:[/?#]|$)/
+  );
+  if (toolExecuteMatch) {
+    return providerLabelFromToolId(decodeURIComponent(toolExecuteMatch[1]));
+  }
+  return "Deepline";
+}
+function providerLabelFromToolId(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  const provider = normalized.split(/[_:./-]+/)[0];
+  return provider || normalized || "provider";
+}
 var HttpClient = class {
   constructor(config) {
     this.config = config;
@@ -628,10 +680,12 @@ var HttpClient = class {
       }
       for (const candidateUrl of candidateUrls) {
         const controller = new AbortController();
-        const timeoutId = setTimeout(
-          () => controller.abort(),
-          options?.timeout ?? this.config.timeout
-        );
+        const timeoutMs = options?.timeout ?? this.config.timeout;
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
         try {
           const response = await fetch(candidateUrl, {
             method,
@@ -704,7 +758,10 @@ var HttpClient = class {
             lastError = error;
             break;
           }
-          lastError = error instanceof Error ? error : new Error(String(error));
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
         }
       }
       if (attempt < maxRetries) continue;
@@ -712,8 +769,17 @@ var HttpClient = class {
     if (lastError instanceof DeeplineError) {
       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(withCoworkNetworkHint(errorMessage));
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    throw new DeeplineError(
+      withCoworkNetworkHint(mappedNetworkError.message),
+      void 0,
+      mappedNetworkError.code,
+      mappedNetworkError.details
+    );
   }
   /**
    * Send a GET request.
@@ -1984,6 +2050,57 @@ function decodeBase64Bytes(value) {
   }
   return bytes;
 }
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof DeeplineError && error.statusCode === 404;
+}
+function formatMegabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+async function uploadStagedFileToPresignedUrl(input) {
+  const arrayBuffer = input.body.buffer.slice(
+    input.body.byteOffset,
+    input.body.byteOffset + input.body.byteLength
+  );
+  let lastError;
+  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetch(input.url, {
+        method: "PUT",
+        headers: input.headers,
+        body: new Blob([arrayBuffer])
+      });
+      if (response.ok) {
+        return;
+      }
+      const text = await response.text().catch(() => "");
+      lastError = new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
+        response.status,
+        "STAGED_FILE_UPLOAD_FAILED",
+        { logicalPath: input.logicalPath }
+      );
+      if (response.status < 500 && response.status !== 429) {
+        break;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
+      await sleep2(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new DeeplineError(
+    `Direct storage upload of ${input.logicalPath} failed.`,
+    void 0,
+    "STAGED_FILE_UPLOAD_FAILED",
+    { logicalPath: input.logicalPath }
+  );
+}
 function readStringArray(value) {
   return Array.isArray(value) ? value.filter((line) => typeof line === "string") : [];
 }
@@ -2389,6 +2506,21 @@ var DeeplineClient = class {
       ...input.maxRows ? { max_rows: input.maxRows } : {}
     });
   }
+  /**
+   * Re-establish this workspace's tenant storage contract: role/DB connect
+   * grants plus materialized table grants. Org-admin only. Use when a run fails
+   * with WORKSPACE_STORAGE_NOT_READY.
+   */
+  async repairIngestionStorage(input) {
+    return this.http.post(
+      "/api/v2/ingestion/repair",
+      {
+        ...input?.provider ? { provider: input.provider } : {}
+      },
+      void 0,
+      { forbiddenAsApiError: true }
+    );
+  }
   // ——————————————————————————————————————————————————————————
   // Plays — submission and lifecycle
   // ——————————————————————————————————————————————————————————
@@ -2766,6 +2898,94 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
+    let uploads;
+    try {
+      uploads = await this.mintStagedPlayFileUploads(
+        files.map((file) => ({
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      );
+    } catch (error) {
+      if (isStagedUploadMintUnsupported(error)) {
+        return this.stagePlayFilesViaMultipart(files);
+      }
+      throw error;
+    }
+    const uploadByIdentity = /* @__PURE__ */ new Map();
+    for (const upload of uploads) {
+      uploadByIdentity.set(
+        stagedUploadIdentity(upload.logicalPath, upload.contentHash),
+        upload
+      );
+    }
+    await Promise.all(
+      files.map(async (file) => {
+        const upload = uploadByIdentity.get(
+          stagedUploadIdentity(file.logicalPath, file.contentHash)
+        );
+        if (!upload) {
+          throw new DeeplineError(
+            `The staging server did not return an upload target for ${file.logicalPath}.`,
+            void 0,
+            "STAGED_FILE_MINT_INCOMPLETE"
+          );
+        }
+        if (upload.alreadyStaged || !upload.uploadUrl) {
+          return;
+        }
+        await uploadStagedFileToPresignedUrl({
+          url: upload.uploadUrl,
+          headers: upload.uploadHeaders ?? {
+            "content-type": file.contentType
+          },
+          body: decodeBase64Bytes(file.contentBase64),
+          logicalPath: file.logicalPath
+        });
+      })
+    );
+    return files.map((file) => {
+      const upload = uploadByIdentity.get(
+        stagedUploadIdentity(file.logicalPath, file.contentHash)
+      );
+      if (!upload) {
+        throw new DeeplineError(
+          `The staging server did not return an upload target for ${file.logicalPath}.`,
+          void 0,
+          "STAGED_FILE_MINT_INCOMPLETE"
+        );
+      }
+      return upload.ref;
+    });
+  }
+  /**
+   * Mint short-lived presigned upload targets for staged play files.
+   *
+   * Internal primitive used by {@link stagePlayFiles}. The server returns an
+   * already-staged ref (no upload needed) for content-addressed files it
+   * already holds, or a presigned PUT URL the caller uploads the body to.
+   */
+  async mintStagedPlayFileUploads(files) {
+    const response = await this.http.post("/api/v2/plays/files/stage/mint", { files });
+    return response.uploads ?? [];
+  }
+  async stagePlayFilesViaMultipart(files) {
+    for (const file of files) {
+      if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+        throw new DeeplineError(
+          `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): the connected Deepline server does not support direct-to-storage uploads, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to. Update the Deepline server (or target code.deepline.com) to stage files this large.`,
+          413,
+          "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
+          {
+            logicalPath: file.logicalPath,
+            bytes: file.bytes,
+            maxBytes: STAGE_LEGACY_MULTIPART_MAX_BYTES
+          }
+        );
+      }
+    }
     const buildFormData = () => {
       const formData = new FormData();
       formData.set(

package/package.json

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