deepline 0.3.461 → 0.3.463

package/dist/cli/chunk-YGGIZ3VT.js

@@ -0,0 +1,920 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkALJJRZNJjs = require('./chunk-ALJJRZNJ.js');
+
+
+
+var _chunkXNYIZMNQjs = require('./chunk-XNYIZMNQ.js');
+
+
+
+
+
+
+var _chunkDIAWYWT5js = require('./chunk-DIAWYWT5.js');
+
+
+var _chunk3BOIOCNXjs = require('./chunk-3BOIOCNX.js');
+
+// src/version.ts
+var SDK_VERSION = _chunk3BOIOCNXjs.SDK_RELEASE.version;
+var SDK_API_MAJOR = _chunk3BOIOCNXjs.SDK_RELEASE.contracts.api.currentMajor;
+var SDK_API_CONTRACT = _nullishCoalesce(_chunk3BOIOCNXjs.SDK_RELEASE.contracts.api.legacyWireIds[0], () => ( `api-v${SDK_API_MAJOR}`));
+
+// src/agent-runtime.ts
+var _os = require('os');
+var EXPLICIT_AGENT_RUNTIMES = /* @__PURE__ */ new Set([
+  "claude_code",
+  "claude_cowork",
+  "codex",
+  "cline",
+  "cursor",
+  "gemini",
+  "antigravity",
+  "windsurf",
+  "unknown"
+]);
+function truthyEnv(name) {
+  return ["1", "true", "yes", "on"].includes(
+    String(_nullishCoalesce(process.env[name], () => ( ""))).trim().toLowerCase()
+  );
+}
+function normalizeAgentRuntime(value) {
+  const explicit = _optionalChain([value, 'optionalAccess', _ => _.trim, 'call', _2 => _2(), 'access', _3 => _3.toLowerCase, 'call', _4 => _4(), 'access', _5 => _5.replace, 'call', _6 => _6(/-/g, "_")]);
+  if (!explicit) return null;
+  if (explicit === "gemini_cli") return "gemini";
+  return EXPLICIT_AGENT_RUNTIMES.has(explicit) ? explicit : null;
+}
+var AGENT_SESSION_ID_VARIABLES = [
+  "CLAUDE_CODE_SESSION_ID",
+  "CODEX_SESSION_ID",
+  "CODEX_THREAD_ID"
+];
+function agentSessionIdFromEnvironment(env = process.env, agentRuntime) {
+  const detectedRuntime = normalizeAgentRuntime(
+    _nullishCoalesce(agentRuntime, () => ( env.DEEPLINE_AGENT_RUNTIME))
+  );
+  const runtime = _nullishCoalesce((detectedRuntime === "unknown" ? null : detectedRuntime), () => ( (_optionalChain([env, 'access', _7 => _7.CODEX_SESSION_ID, 'optionalAccess', _8 => _8.trim, 'call', _9 => _9()]) || _optionalChain([env, 'access', _10 => _10.CODEX_THREAD_ID, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]) ? "codex" : null)));
+  const variables = runtime === "codex" ? ["CODEX_SESSION_ID", "CODEX_THREAD_ID"] : runtime === "claude_code" || runtime === "claude_cowork" ? ["CLAUDE_CODE_SESSION_ID"] : runtime === null ? AGENT_SESSION_ID_VARIABLES : [];
+  for (const variable of variables) {
+    const sessionId = _optionalChain([env, 'access', _13 => _13[variable], 'optionalAccess', _14 => _14.trim, 'call', _15 => _15()]);
+    if (sessionId) return sessionId;
+  }
+  return null;
+}
+function isCoworkLikeSandbox() {
+  const pluginMode = truthyEnv("DEEPLINE_PLUGIN_MODE");
+  const claudeRemote = truthyEnv("CLAUDE_CODE_REMOTE");
+  const projectDir = Boolean(_optionalChain([process, 'access', _16 => _16.env, 'access', _17 => _17.CLAUDE_PROJECT_DIR, 'optionalAccess', _18 => _18.trim, 'call', _19 => _19()]));
+  const pluginRoot = Boolean(_optionalChain([process, 'access', _20 => _20.env, 'access', _21 => _21.DEEPLINE_PLUGIN_ROOT, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]));
+  const home = _optionalChain([process, 'access', _24 => _24.env, 'access', _25 => _25.HOME, 'optionalAccess', _26 => _26.trim, 'call', _27 => _27()]) || _os.homedir.call(void 0, );
+  const sessionHome = home === "/sessions" || home.startsWith("/sessions/");
+  return claudeRemote || sessionHome || (pluginMode || pluginRoot) && projectDir;
+}
+function detectAgentRuntime(options = {}) {
+  const env = _nullishCoalesce(options.env, () => ( process.env));
+  const explicit = normalizeAgentRuntime(env.DEEPLINE_AGENT_RUNTIME);
+  if (explicit) return explicit;
+  if (_optionalChain([env, 'access', _28 => _28.CODEX_THREAD_ID, 'optionalAccess', _29 => _29.trim, 'call', _30 => _30()])) return "codex";
+  if (options.detectCowork !== false && isCoworkLikeSandbox()) {
+    return "claude_cowork";
+  }
+  if (_optionalChain([env, 'access', _31 => _31.CLAUDECODE, 'optionalAccess', _32 => _32.trim, 'call', _33 => _33()]) === "1") return "claude_code";
+  if (_optionalChain([env, 'access', _34 => _34.CLINE_ACTIVE, 'optionalAccess', _35 => _35.trim, 'call', _36 => _36(), 'access', _37 => _37.toLowerCase, 'call', _38 => _38()]) === "true") return "cline";
+  if (_optionalChain([env, 'access', _39 => _39.CURSOR_TRACE_ID, 'optionalAccess', _40 => _40.trim, 'call', _41 => _41()]) || _optionalChain([env, 'access', _42 => _42.CURSOR_AGENT, 'optionalAccess', _43 => _43.trim, 'call', _44 => _44()])) {
+    return "cursor";
+  }
+  if (_optionalChain([env, 'access', _45 => _45.WINDSURF, 'optionalAccess', _46 => _46.trim, 'call', _47 => _47()]) || _optionalChain([env, 'access', _48 => _48.CASCADE, 'optionalAccess', _49 => _49.trim, 'call', _50 => _50()])) {
+    return "windsurf";
+  }
+  if (_optionalChain([env, 'access', _51 => _51.ANTIGRAVITY, 'optionalAccess', _52 => _52.trim, 'call', _53 => _53()]) || _optionalChain([env, 'access', _54 => _54.ANTIGRAVITY_CLI, 'optionalAccess', _55 => _55.trim, 'call', _56 => _56()]) || _optionalChain([env, 'access', _57 => _57.ANTIGRAVITY_AGENT, 'optionalAccess', _58 => _58.trim, 'call', _59 => _59()]) || _optionalChain([env, 'access', _60 => _60.ANTIGRAVITY_WORKSPACE, 'optionalAccess', _61 => _61.trim, 'call', _62 => _62()])) {
+    return "antigravity";
+  }
+  if (_optionalChain([env, 'access', _63 => _63.GEMINI_CLI, 'optionalAccess', _64 => _64.trim, 'call', _65 => _65()]) || _optionalChain([env, 'access', _66 => _66.GEMINI_CLI_VERSION, 'optionalAccess', _67 => _67.trim, 'call', _68 => _68()]) || _optionalChain([env, 'access', _69 => _69.GEMINI_SANDBOX, 'optionalAccess', _70 => _70.trim, 'call', _71 => _71()]) || _optionalChain([env, 'access', _72 => _72.GEMINI_CONFIG_DIR, 'optionalAccess', _73 => _73.trim, 'call', _74 => _74()])) {
+    return "gemini";
+  }
+  return _nullishCoalesce(options.defaultRuntime, () => ( "unknown"));
+}
+
+// src/deployment-protection.ts
+function deploymentProtectionHeaders(env = typeof process !== "undefined" ? process.env : {}) {
+  const token = env.VERCEL_PROTECTION_BYPASS_TOKEN;
+  return token ? { "x-vercel-protection-bypass": token } : {};
+}
+var fetchWithDeploymentProtection = (input, init) => {
+  const headers = new Headers(
+    input instanceof Request ? input.headers : void 0
+  );
+  new Headers(_optionalChain([init, 'optionalAccess', _75 => _75.headers])).forEach((value, name) => headers.set(name, value));
+  for (const [name, value] of Object.entries(deploymentProtectionHeaders())) {
+    headers.set(name, value);
+  }
+  return fetch(input, { ...init, headers });
+};
+
+// ../play-runtime/coordinator-headers.ts
+var COORDINATOR_INTERNAL_TOKEN_HEADER = "x-deepline-internal-token";
+var COORDINATOR_URL_OVERRIDE_HEADER = "x-deepline-coordinator-url";
+var WORKER_CALLBACK_URL_OVERRIDE_HEADER = "x-deepline-worker-callback-url";
+var RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER = "x-deepline-runtime-scheduler-schema";
+var RUNTIME_ENVIRONMENT_TOKEN_HEADER = "x-deepline-runtime-environment-token";
+var RETAINED_PIPELINE_RECEIVERS_HEADER = "x-deepline-retained-pipeline-receivers";
+var ABSURD_RELEASE_OVERRIDE_HEADER = "x-deepline-absurd-release";
+var PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER = "x-deepline-preferred-receipt-gateway-machine-id";
+var SYNTHETIC_RUN_HEADER = "x-deepline-synthetic-run";
+
+// ../play-runtime/test-runtime-seams.ts
+var PLAY_RUNTIME_TEST_FAULT_HEADER = "x-deepline-test-fault";
+var MAX_RUNTIME_TEST_POLICY_MS = 10 * 6e4;
+var MAX_RUNNER_HEARTBEAT_SILENCE_MS = 10 * 6e4;
+
+// ../integration-contracts/execute-retry-contract.ts
+var EXECUTE_RETRY_POLICY_HEADER = "x-deepline-execute-retry-policy";
+var EXECUTE_RETRY_POLICY_VERSION = 1;
+function parseExecuteRetryPolicy(value) {
+  if (value === `v${EXECUTE_RETRY_POLICY_VERSION}:transient-http-safe`) {
+    return "transient-http-safe";
+  }
+  if (value === `v${EXECUTE_RETRY_POLICY_VERSION}:transient-http-unsafe`) {
+    return "transient-http-unsafe";
+  }
+  return null;
+}
+var ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER = "x-deepline-atomic-tool-supported";
+
+// src/http-core.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 = Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = Symbol("deeplineRequestAbort");
+var MAX_AUTOMATIC_RETRY_WAIT_MS = 3e4;
+function requestCancelledError(signal) {
+  const error = withErrorCause(new Error("Request aborted"), signal.reason);
+  error[REQUEST_ABORT_MARKER] = true;
+  return error;
+}
+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 applyExplicitHeaders(headers, explicit) {
+  if (!explicit) return headers;
+  for (const [rawName, value] of Object.entries(explicit)) {
+    const name = rawName.trim().toLowerCase();
+    if (!name) continue;
+    for (const existing of Object.keys(headers)) {
+      if (existing.toLowerCase() === name) delete headers[existing];
+    }
+    headers[rawName.trim()] = value;
+  }
+  return headers;
+}
+function isAbortLikeError(error) {
+  const name = error.name.toLowerCase();
+  const message = error.message.toLowerCase();
+  return name === "aborterror" || message.includes("operation was aborted") || message === "aborted";
+}
+function withErrorCause(error, cause) {
+  if (cause !== null && cause !== void 0) {
+    Object.defineProperty(error, "cause", {
+      value: cause,
+      configurable: true,
+      writable: true
+    });
+  }
+  return error;
+}
+function mapNetworkError(baseUrl, error, targetLabel) {
+  const tagged = error;
+  const timeoutMs = _optionalChain([tagged, 'optionalAccess', _76 => _76[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 (_optionalChain([tagged, 'optionalAccess', _77 => _77[REQUEST_ABORT_MARKER]])) {
+    return {
+      message: `Request to ${targetLabel} was aborted before it completed.`,
+      code: "NETWORK_ABORTED"
+    };
+  }
+  return {
+    message: _optionalChain([error, 'optionalAccess', _78 => _78.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 networkDiagnosticUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+    return `${url.origin}${url.pathname}`;
+  } catch (e) {
+    return void 0;
+  }
+}
+function providerLabelFromToolId(toolId) {
+  const normalized = toolId.trim().toLowerCase();
+  const provider = normalized.split(/[_:./-]+/)[0];
+  return provider || normalized || "provider";
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var HttpClient = class {
+  constructor(config, readLocalSkillsVersion) {
+    this.config = config;
+    this.readLocalSkillsVersion = readLocalSkillsVersion;
+  }
+  cleanDiagnosticHeader(value) {
+    const normalized = String(_nullishCoalesce(value, () => ( ""))).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, MAX_DIAGNOSTIC_HEADER_LENGTH);
+    return normalized || null;
+  }
+  environment() {
+    return _nullishCoalesce(this.config.environment, () => ( (typeof process !== "undefined" ? process.env : {})));
+  }
+  readSkillsVersionHeader() {
+    const explicit = this.cleanDiagnosticHeader(
+      this.environment().DEEPLINE_SKILLS_VERSION
+    );
+    if (explicit) return explicit;
+    try {
+      return this.cleanDiagnosticHeader(
+        _optionalChain([this, 'access', _79 => _79.readLocalSkillsVersion, 'optionalCall', _80 => _80(this.config.baseUrl)])
+      );
+    } catch (e2) {
+      return null;
+    }
+  }
+  authHeaders(extra) {
+    const env = this.environment();
+    const transportHeaders = {
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+      "X-Deepline-Client-Family": "sdk",
+      "X-Deepline-CLI-Family": "sdk",
+      "X-Deepline-Agent-Runtime": detectAgentRuntime(
+        this.config.environment ? { env, detectCowork: false } : {}
+      ),
+      "X-Deepline-CLI-Version": SDK_VERSION,
+      "X-Deepline-SDK-Version": SDK_VERSION,
+      "X-Deepline-API-Contract": SDK_API_CONTRACT,
+      "X-Deepline-Run-Result-Shape": "canonical"
+    };
+    const headers = deploymentProtectionHeaders(env);
+    const skillsVersion = this.readSkillsVersionHeader();
+    if (skillsVersion) {
+      headers["X-Deepline-Skills-Version"] = skillsVersion;
+    }
+    const agentSessionId = agentSessionIdFromEnvironment(env);
+    if (agentSessionId) {
+      headers["X-Deepline-Agent-Session-Id"] = agentSessionId;
+    }
+    const playArtifactR2Prefix = env.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX;
+    if (playArtifactR2Prefix) {
+      headers["x-deepline-play-artifact-r2-prefix"] = playArtifactR2Prefix;
+    }
+    const coordinatorUrl = env.DEEPLINE_COORDINATOR_URL;
+    const coordinatorInternalToken = env.DEEPLINE_INTERNAL_TOKEN;
+    const absurdReleaseOverride = env.DEEPLINE_ABSURD_RELEASE;
+    const preferredReceiptGatewayMachineId = env.DEEPLINE_PREFERRED_RECEIPT_GATEWAY_MACHINE_ID;
+    if (_optionalChain([coordinatorUrl, 'optionalAccess', _81 => _81.trim, 'call', _82 => _82()])) {
+      headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
+    }
+    const workerCallbackUrl = env.DEEPLINE_WORKER_CALLBACK_URL;
+    if (_optionalChain([workerCallbackUrl, 'optionalAccess', _83 => _83.trim, 'call', _84 => _84()])) {
+      headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
+    }
+    const runtimeSchedulerSchema = env.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA;
+    if (_optionalChain([runtimeSchedulerSchema, 'optionalAccess', _85 => _85.trim, 'call', _86 => _86()])) {
+      headers[RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER] = runtimeSchedulerSchema.trim();
+    }
+    const syntheticRun = env.DEEPLINE_SYNTHETIC_RUN;
+    if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== "0") {
+      headers[SYNTHETIC_RUN_HEADER] = "1";
+    }
+    const runtimeTestFault = env.DEEPLINE_TEST_RUNTIME_FAULT;
+    if (_optionalChain([runtimeTestFault, 'optionalAccess', _87 => _87.trim, 'call', _88 => _88()])) {
+      headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
+    }
+    const retainedReceivers = _optionalChain([env, 'access', _89 => _89.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS, 'optionalAccess', _90 => _90.trim, 'call', _91 => _91()]);
+    if (retainedReceivers && _optionalChain([coordinatorInternalToken, 'optionalAccess', _92 => _92.trim, 'call', _93 => _93()])) {
+      headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
+    if (_optionalChain([absurdReleaseOverride, 'optionalAccess', _94 => _94.trim, 'call', _95 => _95()]) && _optionalChain([coordinatorInternalToken, 'optionalAccess', _96 => _96.trim, 'call', _97 => _97()])) {
+      headers[ABSURD_RELEASE_OVERRIDE_HEADER] = absurdReleaseOverride.trim();
+    }
+    if (_optionalChain([preferredReceiptGatewayMachineId, 'optionalAccess', _98 => _98.trim, 'call', _99 => _99()]) && _optionalChain([coordinatorInternalToken, 'optionalAccess', _100 => _100.trim, 'call', _101 => _101()])) {
+      headers[PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER] = preferredReceiptGatewayMachineId.trim();
+    }
+    if (_optionalChain([coordinatorInternalToken, 'optionalAccess', _102 => _102.trim, 'call', _103 => _103()]) && (_optionalChain([coordinatorUrl, 'optionalAccess', _104 => _104.trim, 'call', _105 => _105()]) || _optionalChain([workerCallbackUrl, 'optionalAccess', _106 => _106.trim, 'call', _107 => _107()]) || _optionalChain([runtimeTestFault, 'optionalAccess', _108 => _108.trim, 'call', _109 => _109()]) || _optionalChain([absurdReleaseOverride, 'optionalAccess', _110 => _110.trim, 'call', _111 => _111()]) || _optionalChain([preferredReceiptGatewayMachineId, 'optionalAccess', _112 => _112.trim, 'call', _113 => _113()]))) {
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
+    return applyExplicitHeaders(
+      applyExplicitHeaders(
+        applyExplicitHeaders(transportHeaders, extra),
+        headers
+      ),
+      this.config.headers
+    );
+  }
+  /**
+   * Send an HTTP request with automatic retries and error handling.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path (e.g. `"/api/v2/tools"`)
+   * @param options - HTTP method, body, headers, and timeout
+   * @returns Parsed JSON response body
+   * @throws {@link AuthError} on Deepline-auth HTTP 401/403 (immediate, no retry)
+   * @throws {@link RateLimitError} on HTTP 429 after all retries exhausted
+   * @throws {@link DeeplineError} on other API errors or connection failures
+   */
+  async request(path, options) {
+    const baseUrl = this.config.baseUrl;
+    const url = `${baseUrl}${path}`;
+    const method = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _114 => _114.method]), () => ( "GET"));
+    const requestStartedAt = Date.now();
+    let fetchAttempts = 0;
+    let lastRequestUrl = url;
+    let networkFailedAt;
+    let networkPhase = "before_request";
+    const headers = this.authHeaders(_optionalChain([options, 'optionalAccess', _115 => _115.headers]));
+    if (_optionalChain([options, 'optionalAccess', _116 => _116.body]) !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    const candidateUrls = _optionalChain([options, 'optionalAccess', _117 => _117.exactUrlOnly]) ? [url] : buildCandidateUrls(url);
+    let retryAfterDelayMs = null;
+    let totalRetryWaitMs = 0;
+    let maxRetries = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _118 => _118.maxRetries]), () => ( this.config.maxRetries));
+    requestAttempts: for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (_optionalChain([options, 'optionalAccess', _119 => _119.signal, 'optionalAccess', _120 => _120.aborted])) {
+        lastError = requestCancelledError(options.signal);
+        networkFailedAt = Date.now();
+        break;
+      }
+      if (attempt > 0) {
+        const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        const delayMs = retryAfterDelayMs === null ? backoffMs : Math.max(backoffMs, retryAfterDelayMs);
+        retryAfterDelayMs = null;
+        if (totalRetryWaitMs + delayMs > MAX_AUTOMATIC_RETRY_WAIT_MS) {
+          break requestAttempts;
+        }
+        totalRetryWaitMs += delayMs;
+        networkPhase = "retry_wait";
+        try {
+          await sleep(delayMs, _optionalChain([options, 'optionalAccess', _121 => _121.signal]));
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          networkFailedAt = Date.now();
+          break;
+        }
+      }
+      for (const candidateUrl of candidateUrls) {
+        if (_optionalChain([options, 'optionalAccess', _122 => _122.signal, 'optionalAccess', _123 => _123.aborted])) {
+          lastError = requestCancelledError(options.signal);
+          networkFailedAt = Date.now();
+          break requestAttempts;
+        }
+        const controller = new AbortController();
+        const timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _124 => _124.timeout]), () => ( this.config.timeout));
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
+        const abortRequest = () => controller.abort();
+        _optionalChain([options, 'optionalAccess', _125 => _125.signal, 'optionalAccess', _126 => _126.addEventListener, 'call', _127 => _127("abort", abortRequest, {
+          once: true
+        })]);
+        networkPhase = "before_request";
+        try {
+          const requestBody = _optionalChain([options, 'optionalAccess', _128 => _128.formData]) !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : _optionalChain([options, 'optionalAccess', _129 => _129.body]) !== void 0 ? JSON.stringify(options.body) : void 0;
+          fetchAttempts += 1;
+          lastRequestUrl = candidateUrl;
+          networkPhase = "awaiting_headers";
+          const response = await fetch(candidateUrl, {
+            method,
+            headers,
+            body: requestBody,
+            signal: controller.signal
+          });
+          networkPhase = "reading_body";
+          _optionalChain([options, 'optionalAccess', _130 => _130.onResponse, 'optionalCall', _131 => _131(response)]);
+          if (response.status === 404 && _optionalChain([options, 'optionalAccess', _132 => _132.allowNotFound])) {
+            clearTimeout(timeoutId);
+            return null;
+          }
+          const body = await response.text();
+          const receivedAtMs = Date.now();
+          clearTimeout(timeoutId);
+          const parsed = parseResponseBody(body);
+          _optionalChain([options, 'optionalAccess', _133 => _133.onResponseBody, 'optionalCall', _134 => _134({
+            receivedAtMs,
+            httpStatus: response.status,
+            body: parsed
+          })]);
+          const responseRetryAllowed = _optionalChain([options, 'optionalAccess', _135 => _135.retryFromExecutePolicy]) !== true || parseExecuteRetryPolicy(
+            response.headers.get(EXECUTE_RETRY_POLICY_HEADER)
+          ) === "transient-http-safe";
+          if (_optionalChain([options, 'optionalAccess', _136 => _136.retryFromExecutePolicy]) === true && responseRetryAllowed && options.executePolicyMaxRetries !== void 0) {
+            maxRetries = options.executePolicyMaxRetries;
+          }
+          const structuredToolError = _optionalChain([options, 'optionalAccess', _137 => _137.toolId]) && !response.ok ? _chunkDIAWYWT5js.deserializeToolExecutionFailure.call(void 0, 
+            _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+            isRecord(parsed) ? parsed.tool_error : null,
+            _chunkDIAWYWT5js.TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+          ) : null;
+          if (structuredToolError) {
+            if (response.status === 429) {
+              const retryAfter = parseRetryAfter(response);
+              const failure = _chunkDIAWYWT5js.serializeToolExecutionFailure.call(void 0, structuredToolError);
+              lastError = failure === null ? structuredToolError : new (0, _chunkALJJRZNJjs.ToolRateLimitError)(structuredToolError.message, {
+                ...failure,
+                retryAfterMs: _nullishCoalesce(failure.retryAfterMs, () => ( Math.max(0, retryAfter)))
+              });
+              if (responseRetryAllowed && attempt < maxRetries) {
+                retryAfterDelayMs = retryAfter;
+                break;
+              }
+              throw lastError;
+            }
+            throw structuredToolError;
+          }
+          if (response.status === 429) {
+            if (_optionalChain([options, 'optionalAccess', _138 => _138.preserveRateLimitResponse]) && isMonitorRateLimitEnvelope(parsed)) {
+              throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+                _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+                response.status,
+                _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed),
+                { response: parsed }
+              );
+            }
+            const retryAfter = parseRetryAfter(response);
+            lastError = new (0, _chunkALJJRZNJjs.RateLimitError)(retryAfter);
+            if (responseRetryAllowed && attempt < maxRetries) {
+              retryAfterDelayMs = retryAfter;
+              break;
+            }
+            throw lastError;
+          }
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new (0, _chunkALJJRZNJjs.AuthError)(_chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status));
+          }
+          if (!response.ok) {
+            const retryableApiError = _optionalChain([options, 'optionalAccess', _139 => _139.retryApiErrors]) === true && responseRetryAllowed && isRetryableApiErrorResponse(response.status);
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (htmlError) {
+              lastError = new (0, _chunkDIAWYWT5js.DeeplineError)(
+                htmlError.message(response.status),
+                response.status,
+                "API_ERROR",
+                {
+                  htmlErrorPage: true,
+                  ...htmlError.title ? { title: htmlError.title } : {},
+                  ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+                }
+              );
+              if (retryableApiError && attempt < 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}`;
+            const apiErrorCode = _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed);
+            lastError = new (0, _chunkDIAWYWT5js.DeeplineError)(msg, response.status, apiErrorCode, {
+              response: parsed
+            });
+            if (retryableApiError && attempt < maxRetries) {
+              retryAfterDelayMs = parseOptionalRetryAfter(response);
+              break;
+            }
+            throw lastError;
+          }
+          if (typeof parsed === "string") {
+            const interstitial = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (interstitial) {
+              throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+                `${this.config.baseUrl} returned a deployment-protection page instead of JSON. Set VERCEL_PROTECTION_BYPASS_TOKEN, or run \`vercel login\` if the CLI session expired.`,
+                response.status,
+                "DEPLOYMENT_PROTECTED",
+                { htmlErrorPage: true }
+              );
+            }
+          }
+          return parsed;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          networkFailedAt = Date.now();
+          if (_optionalChain([options, 'optionalAccess', _140 => _140.signal, 'optionalAccess', _141 => _141.aborted])) {
+            lastError = requestCancelledError(options.signal);
+            break requestAttempts;
+          }
+          if (error instanceof _chunkALJJRZNJjs.AuthError || error instanceof _chunkDIAWYWT5js.DeeplineError) {
+            throw error;
+          }
+          if (error instanceof _chunkALJJRZNJjs.RateLimitError) {
+            lastError = error;
+            break;
+          }
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
+          if (_optionalChain([options, 'optionalAccess', _142 => _142.retryFromExecutePolicy]) && options.retryAmbiguousDelivery !== true) {
+            break requestAttempts;
+          }
+        } finally {
+          clearTimeout(timeoutId);
+          _optionalChain([options, 'optionalAccess', _143 => _143.signal, 'optionalAccess', _144 => _144.removeEventListener, 'call', _145 => _145("abort", abortRequest)]);
+        }
+      }
+      if (attempt < maxRetries) continue;
+    }
+    if (lastError instanceof _chunkDIAWYWT5js.DeeplineError) {
+      throw lastError;
+    }
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    const failedAt = _nullishCoalesce(networkFailedAt, () => ( Date.now()));
+    const diagnosticUrl = networkDiagnosticUrl(lastRequestUrl);
+    const networkDetails = {
+      ...mappedNetworkError.details,
+      request: {
+        method,
+        ...diagnosticUrl === void 0 ? {} : { url: diagnosticUrl },
+        failedAtUtc: new Date(failedAt).toISOString(),
+        // Elapsed time covers the entire logical request, including retries.
+        elapsedMs: Math.max(0, failedAt - requestStartedAt),
+        attempts: fetchAttempts,
+        phase: networkPhase
+      }
+    };
+    if (_optionalChain([options, 'optionalAccess', _146 => _146.toolId])) {
+      const code = mappedNetworkError.code;
+      throw withErrorCause(
+        new (0, _chunkDIAWYWT5js.ToolExecutionError)(
+          withCoworkNetworkHint(mappedNetworkError.message),
+          {
+            toolId: options.toolId,
+            provider: providerLabelFromToolId(options.toolId),
+            operation: options.toolId,
+            code,
+            origin: "deepline",
+            category: "network",
+            // A direct client timeout has ambiguous delivery. Fail closed unless
+            // the server returns the authoritative action delivery contract.
+            retryable: options.retryAmbiguousDelivery === true,
+            statusCode: null,
+            requestId: null,
+            retryAfterMs: null,
+            networkKind: code === "NETWORK_TIMEOUT" ? "timeout" : code === "NETWORK_ABORTED" ? "unknown" : "unavailable",
+            networkScope: "client_to_deepline",
+            details: networkDetails,
+            publicDetails: options.idempotencyKey ? { idempotencyKey: options.idempotencyKey } : null
+          }
+        ),
+        lastError
+      );
+    }
+    throw withErrorCause(
+      new (0, _chunkDIAWYWT5js.DeeplineError)(
+        withCoworkNetworkHint(mappedNetworkError.message),
+        void 0,
+        mappedNetworkError.code,
+        networkDetails
+      ),
+      lastError
+    );
+  }
+  /**
+   * Send a GET request.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path (e.g. `"/api/v2/tools"`)
+   */
+  async get(path, options) {
+    return this.request(path, {
+      method: "GET",
+      retryApiErrors: true,
+      ...options
+    });
+  }
+  async *streamSse(path, options) {
+    const url = `${this.config.baseUrl}${path}`;
+    const method = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _147 => _147.method]), () => ( "GET"));
+    const headers = this.authHeaders({
+      Accept: "text/event-stream",
+      ..._optionalChain([options, 'optionalAccess', _148 => _148.headers])
+    });
+    if (_optionalChain([options, 'optionalAccess', _149 => _149.body]) !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    const candidateUrls = _optionalChain([options, 'optionalAccess', _150 => _150.exactUrlOnly]) ? [url] : buildCandidateUrls(url);
+    for (const candidateUrl of candidateUrls) {
+      try {
+        const response = await fetch(candidateUrl, {
+          method,
+          headers,
+          body: _optionalChain([options, 'optionalAccess', _151 => _151.body]) !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: _optionalChain([options, 'optionalAccess', _152 => _152.signal])
+        });
+        if (!response.ok) {
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new (0, _chunkALJJRZNJjs.AuthError)(_chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status));
+          }
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get("content-type")
+          );
+          if (htmlError) {
+            throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+              htmlError.message(response.status),
+              response.status,
+              "API_ERROR",
+              {
+                htmlErrorPage: true,
+                ...htmlError.title ? { title: htmlError.title } : {},
+                ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+              }
+            );
+          }
+          throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+            _chunkXNYIZMNQjs.apiErrorMessage.call(void 0, parsed, response.status),
+            response.status,
+            _chunkXNYIZMNQjs.apiErrorCodeFromResponse.call(void 0, parsed),
+            { response: parsed }
+          );
+        }
+        if (!response.body) {
+          throw new (0, _chunkDIAWYWT5js.DeeplineError)("SSE response did not include a body.");
+        }
+        yield* decodeSseStream(response.body);
+        return;
+      } catch (error) {
+        if (error instanceof _chunkALJJRZNJjs.AuthError || error instanceof _chunkDIAWYWT5js.DeeplineError) {
+          throw error;
+        }
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        if (isAbortLikeError(normalized) && _optionalChain([options, 'optionalAccess', _153 => _153.signal, 'optionalAccess', _154 => _154.aborted])) {
+          throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+            `Stream from ${this.config.baseUrl} was aborted by the caller.`,
+            void 0,
+            "ABORTED"
+          );
+        }
+        lastError = normalized;
+      }
+    }
+    if (lastError && isAbortLikeError(lastError)) {
+      throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+        withCoworkNetworkHint(
+          `Unable to stream from ${this.config.baseUrl}. The remote stream was interrupted.`
+        ),
+        void 0,
+        "PLAY_STREAM_NETWORK_ABORTED"
+      );
+    }
+    throw new (0, _chunkDIAWYWT5js.DeeplineError)(
+      withCoworkNetworkHint(
+        _optionalChain([lastError, 'optionalAccess', _155 => _155.message]) ? `Unable to stream from ${this.config.baseUrl}. ${lastError.message}` : `Unable to stream from ${this.config.baseUrl}.`
+      )
+    );
+  }
+  /**
+   * Send a POST request with a JSON body.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   * @param body - Request body (will be JSON-serialized)
+   */
+  async post(path, body, headers, options) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      headers,
+      ...options
+    });
+  }
+  async postFormData(path, formData, headers) {
+    return this.request(path, {
+      method: "POST",
+      formData,
+      headers
+    });
+  }
+  /**
+   * Send a PATCH request with a JSON body.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   * @param body - JSON-serializable request body
+   */
+  async patch(path, body, headers) {
+    return this.request(path, {
+      method: "PATCH",
+      body,
+      headers
+    });
+  }
+  async put(path, body, headers) {
+    return this.request(path, { method: "PUT", body, headers });
+  }
+  /**
+   * Send a DELETE request.
+   *
+   * @typeParam T - Expected response body type
+   * @param path - API path
+   */
+  async delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
+function parseResponseBody(body) {
+  try {
+    return JSON.parse(body);
+  } catch (e3) {
+    return body;
+  }
+}
+function isProviderOriginatedHttpError(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(_optionalChain([response, 'optionalAccess', _156 => _156.error]));
+  const failureOrigin = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _157 => _157.failure_origin]), () => ( _optionalChain([response, 'optionalAccess', _158 => _158.failure_origin])));
+  const code = _nullishCoalesce(_optionalChain([error, 'optionalAccess', _159 => _159.code]), () => ( _optionalChain([response, 'optionalAccess', _160 => _160.code])));
+  return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
+}
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(_optionalChain([response, 'optionalAccess', _161 => _161.error]));
+  return (_optionalChain([error, 'optionalAccess', _162 => _162.code]) === "monitor_upstream_rate_limited" || _optionalChain([error, 'optionalAccess', _163 => _163.code]) === "monitor_preview_rate_limited") && typeof error.message === "string";
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function isRetryableApiErrorResponse(status) {
+  return status === 408 || status === 425 || status >= 500 && status < 600;
+}
+function detectHtmlErrorBody(body, contentType) {
+  const trimmed = body.trim();
+  const lower = trimmed.toLowerCase();
+  const isHtml = (_nullishCoalesce(contentType, () => ( ""))).toLowerCase().includes("text/html") || lower.startsWith("<!doctype") || lower.startsWith("<html");
+  if (!isHtml) {
+    return null;
+  }
+  const titleMatch = trimmed.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = _optionalChain([titleMatch, 'optionalAccess', _164 => _164[1], 'optionalAccess', _165 => _165.replace, 'call', _166 => _166(/\s+/g, " "), 'access', _167 => _167.trim, 'call', _168 => _168()]) || void 0;
+  const workerThrewException = /worker threw exception/i.test(trimmed);
+  return {
+    title,
+    workerThrewException,
+    message: (status) => {
+      const segments = [`HTTP ${status}`];
+      if (workerThrewException) {
+        segments.push("Worker threw exception");
+      }
+      if (title) {
+        segments.push(title);
+      }
+      return `${segments.join(": ")} (Cloudflare HTML error page suppressed)`;
+    }
+  };
+}
+function parseRetryAfter(response) {
+  return _nullishCoalesce(parseOptionalRetryAfter(response), () => ( 5e3));
+}
+function parseOptionalRetryAfter(response) {
+  const header = response.headers.get("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return seconds * 1e3;
+    }
+  }
+  return null;
+}
+function buildCandidateUrls(url) {
+  try {
+    const parsed = new URL(url);
+    const candidates = [url];
+    if (parsed.hostname === "localhost") {
+      const loopback = new URL(url);
+      loopback.hostname = "127.0.0.1";
+      candidates.push(loopback.toString());
+    }
+    return [...new Set(candidates)];
+  } catch (e4) {
+    return [url];
+  }
+}
+async function* decodeSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffered = "";
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffered += decoder.decode(value, { stream: true });
+      const frames = buffered.split(/\r?\n\r?\n/);
+      buffered = _nullishCoalesce(frames.pop(), () => ( ""));
+      for (const frame of frames) {
+        const event2 = decodeSseFrame(frame);
+        if (event2) {
+          yield event2;
+        }
+      }
+    }
+    buffered += decoder.decode();
+    const event = decodeSseFrame(buffered);
+    if (event) {
+      yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function decodeSseFrame(frame) {
+  const data = frame.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice("data:".length).trimStart()).join("\n").trim();
+  if (!data) {
+    return null;
+  }
+  const parsed = JSON.parse(data);
+  if (!parsed || typeof parsed !== "object" || typeof parsed.cursor !== "string" || typeof parsed.streamId !== "string" || typeof parsed.scope !== "string" || typeof parsed.type !== "string" || typeof parsed.at !== "string") {
+    return null;
+  }
+  return parsed;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (_optionalChain([signal, 'optionalAccess', _169 => _169.aborted])) {
+      reject(requestCancelledError(signal));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      _optionalChain([signal, 'optionalAccess', _170 => _170.removeEventListener, 'call', _171 => _171("abort", abort)]);
+      resolve();
+    }, ms);
+    const abort = () => {
+      clearTimeout(timeoutId);
+      _optionalChain([signal, 'optionalAccess', _172 => _172.removeEventListener, 'call', _173 => _173("abort", abort)]);
+      reject(requestCancelledError(signal));
+    };
+    _optionalChain([signal, 'optionalAccess', _174 => _174.addEventListener, 'call', _175 => _175("abort", abort, { once: true })]);
+  });
+}
+function withCoworkNetworkHint(message) {
+  if (!isCoworkLikeSandbox() || message.includes(COWORK_NETWORK_HINT)) {
+    return message;
+  }
+  return `${message}
+${COWORK_NETWORK_HINT}`;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER = ATOMIC_TOOL_EXECUTE_SUPPORTED_HEADER; exports.SDK_VERSION = SDK_VERSION; exports.SDK_API_MAJOR = SDK_API_MAJOR; exports.SDK_API_CONTRACT = SDK_API_CONTRACT; exports.COORDINATOR_INTERNAL_TOKEN_HEADER = COORDINATOR_INTERNAL_TOKEN_HEADER; exports.RUNTIME_ENVIRONMENT_TOKEN_HEADER = RUNTIME_ENVIRONMENT_TOKEN_HEADER; exports.RETAINED_PIPELINE_RECEIVERS_HEADER = RETAINED_PIPELINE_RECEIVERS_HEADER; exports.agentSessionIdFromEnvironment = agentSessionIdFromEnvironment; exports.detectAgentRuntime = detectAgentRuntime; exports.deploymentProtectionHeaders = deploymentProtectionHeaders; exports.fetchWithDeploymentProtection = fetchWithDeploymentProtection; exports.HttpClient = HttpClient;