deepline 0.3.294 → 0.3.295

package/dist/cli/chunk-EACVZI6N.mjs

@@ -0,0 +1,1995 @@
+import {
+  apiErrorCodeFromResponse,
+  apiErrorMessage
+} from "./chunk-DLIRSHV6.mjs";
+import {
+  SDK_RELEASE
+} from "./chunk-LDWT7RJK.mjs";
+import {
+  DeeplineError,
+  TOOL_EXECUTION_ERROR_SCHEMA_VERSION,
+  ToolExecutionError,
+  brandAsProviderTransientError,
+  brandAsToolExecutionError,
+  deserializeToolExecutionFailure,
+  isProviderTransientFailure,
+  serializeToolExecutionFailure
+} from "./chunk-NXGCO4JB.mjs";
+
+// src/errors.ts
+var AuthError = class extends DeeplineError {
+  /** Constructed by the SDK when Deepline rejects the caller's credentials. */
+  constructor(message = "Authentication failed. Check your DEEPLINE_API_KEY.") {
+    super(message, 401, "AUTH_ERROR");
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends DeeplineError {
+  /** Milliseconds to wait before retrying, from the `Retry-After` response header. Defaults to 5000. */
+  retryAfterMs;
+  /** Constructed by the SDK after exhausting HTTP-level rate-limit retries. */
+  constructor(retryAfterMs = 5e3, message) {
+    super(
+      message ?? `Rate limited. Retry after ${retryAfterMs}ms.`,
+      429,
+      "RATE_LIMIT"
+    );
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var ToolRateLimitError = class extends RateLimitError {
+  /** Public tool id passed to `tools.execute`. */
+  toolId;
+  /** Provider responsible for the operation, or `null`. */
+  provider;
+  /** Provider operation name, or `null`. */
+  operation;
+  /** Stable machine-readable failure code when one exists. */
+  code;
+  /** Boundary responsible for the failure. */
+  origin;
+  /** Stable reason family for policy and diagnostics. */
+  category;
+  /** Whether repeating the same semantic call is delivery-safe. */
+  retryable;
+  /** Provider or Deepline request id, or `null`. */
+  requestId;
+  /** Network failure kind, or `null` for non-network failures. */
+  networkKind;
+  /** Network boundary that failed, or `null` for non-network failures. */
+  networkScope;
+  /** Explicitly allowlisted diagnostics safe for SDK callers. */
+  publicDetails;
+  /** Constructed by the SDK after a structured tool HTTP 429. */
+  constructor(message, options) {
+    super(options.retryAfterMs ?? 5e3, message);
+    this.name = "ToolRateLimitError";
+    this.statusCode = options.statusCode ?? 429;
+    this.code = options.code ?? void 0;
+    this.toolId = options.toolId;
+    this.provider = options.provider;
+    this.operation = options.operation;
+    this.origin = options.origin;
+    this.category = options.category;
+    this.retryable = options.retryable;
+    this.requestId = options.requestId;
+    this.networkKind = options.networkKind;
+    this.networkScope = options.networkScope;
+    this.publicDetails = options.publicDetails ?? null;
+    this.details = options.details;
+    brandAsToolExecutionError(this);
+    if (isProviderTransientFailure(this)) {
+      brandAsProviderTransientError(this);
+    }
+  }
+};
+var ConfigError = class extends DeeplineError {
+  /** Construct a local SDK configuration failure. */
+  constructor(message) {
+    super(message, void 0, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+
+// src/config.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  realpathSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, resolve } from "path";
+var HOST_URL_ENV = "DEEPLINE_HOST_URL";
+var API_KEY_ENV = "DEEPLINE_API_KEY";
+var ACTIVE_ORG_ID_ENV = "DEEPLINE_ACTIVE_ORG_ID";
+var ACTIVE_ORG_NAME_ENV = "DEEPLINE_ACTIVE_ORG_NAME";
+var FEATURES_ENV = "DEEPLINE_FEATURES";
+var PROD_URL = "https://code.deepline.com";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 3;
+var PROJECT_DEEPLINE_ENV_FILE = ".env.deepline";
+var COWORK_IGNORED_WORKSPACE_DIRS = /* @__PURE__ */ new Set([
+  ".auto-memory",
+  ".claude",
+  ".remote-plugins",
+  "outputs",
+  "plugins",
+  "uploads"
+]);
+var COWORK_PROJECT_MARKERS = [
+  ".deepline",
+  ".env.deepline",
+  ".git",
+  "AGENTS.md",
+  "package.json",
+  "pyproject.toml"
+];
+var CLI_ENV_ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  HOST_URL_ENV,
+  API_KEY_ENV,
+  ACTIVE_ORG_ID_ENV,
+  ACTIVE_ORG_NAME_ENV,
+  FEATURES_ENV
+]);
+function featureEnvValues(data) {
+  if (!Array.isArray(data.features)) return {};
+  return {
+    [FEATURES_ENV]: data.features.filter(
+      (key) => typeof key === "string" && key.trim() !== ""
+    ).map((key) => key.trim()).join(",")
+  };
+}
+function storedHostApiKey(baseUrl) {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV] ?? "";
+}
+function storedHostFeatures(baseUrl) {
+  return loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[FEATURES_ENV];
+}
+function baseUrlSlug(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    return "unknown";
+  }
+  const host = url.hostname || "unknown";
+  const port = url.port ? Number.parseInt(url.port, 10) : null;
+  let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
+  if (port && port !== 80 && port !== 443) {
+    slug = `${slug}-${port}`;
+  }
+  return slug.toLowerCase().replace(/^-+|-+$/g, "");
+}
+function parseEnvFile(filePath) {
+  if (!existsSync(filePath)) return {};
+  const env = {};
+  const content = readFileSync(filePath, "utf-8");
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex < 0) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        value = value.slice(1, -1);
+      }
+    } else if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key && value) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function findNearestEnvFile(name, startDir = process.cwd()) {
+  let current = resolve(startDir);
+  while (true) {
+    const filePath = join(current, name);
+    if (existsSync(filePath)) return filePath;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function isTruthy(value) {
+  return /^(1|true|yes|on)$/i.test(value?.trim() ?? "");
+}
+function sessionRootFromPath(path) {
+  const trimmed = path?.trim();
+  if (!trimmed) return null;
+  const match = /^\/sessions\/[^/]+(?=\/|$)/.exec(trimmed);
+  return match?.[0] ?? null;
+}
+function coworkSessionRoot() {
+  const home = process.env.HOME?.trim();
+  const homeSessionRoot = sessionRootFromPath(home);
+  if (homeSessionRoot && isDirectory(join(homeSessionRoot, "mnt"))) {
+    return homeSessionRoot;
+  }
+  const cwdSessionRoot = sessionRootFromPath(process.cwd());
+  if (cwdSessionRoot && isDirectory(join(cwdSessionRoot, "mnt"))) {
+    return cwdSessionRoot;
+  }
+  if (isTruthy(process.env.CLAUDE_CODE_REMOTE) && home) {
+    const mountedRoot = join(home, "mnt");
+    if (isDirectory(mountedRoot)) return resolve(home);
+  }
+  return null;
+}
+function isCoworkLikeSandbox() {
+  const home = process.env.HOME?.trim();
+  return isTruthy(process.env.CLAUDE_CODE_REMOTE) || sessionRootFromPath(home) !== null || sessionRootFromPath(process.cwd()) !== null;
+}
+function coworkProjectScore(path) {
+  let score = 0;
+  for (const marker of COWORK_PROJECT_MARKERS) {
+    if (existsSync(join(path, marker))) score += 1;
+  }
+  return score;
+}
+function listCoworkWorkspaceDirCandidates() {
+  if (!isCoworkLikeSandbox()) {
+    return [];
+  }
+  const explicitProjectDir = process.env.CLAUDE_PROJECT_DIR?.trim();
+  if (explicitProjectDir && isDirectory(explicitProjectDir)) {
+    return [resolve(explicitProjectDir)];
+  }
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return [];
+  const mountedRoot = join(sessionRoot, "mnt");
+  if (!isDirectory(mountedRoot)) return [];
+  let names;
+  try {
+    names = readdirSync(mountedRoot).sort();
+  } catch {
+    return [];
+  }
+  const candidates = [];
+  for (const name of names) {
+    if (name.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(name)) {
+      continue;
+    }
+    const candidate = join(mountedRoot, name);
+    if (isDirectory(candidate)) candidates.push(candidate);
+  }
+  if (candidates.length <= 1) return candidates;
+  const projectLike = candidates.filter(
+    (candidate) => coworkProjectScore(candidate) > 0
+  );
+  return projectLike.length > 0 ? projectLike : candidates;
+}
+function isInIgnoredCoworkMount(path) {
+  const sessionRoot = coworkSessionRoot();
+  if (!sessionRoot) return false;
+  const mountedRoot = canonicalPath(join(sessionRoot, "mnt"));
+  const resolvedPath = canonicalPath(path);
+  const prefix = `${mountedRoot}/`;
+  if (!resolvedPath.startsWith(prefix)) return false;
+  const relativePath = resolvedPath.slice(prefix.length);
+  const mountName = relativePath.split("/")[0];
+  return mountName.startsWith(".") || COWORK_IGNORED_WORKSPACE_DIRS.has(mountName);
+}
+function detectCoworkWorkspaceDir() {
+  const candidates = listCoworkWorkspaceDirCandidates();
+  return candidates.length === 1 ? candidates[0] : null;
+}
+function loadProjectEnvCandidates(startDir = process.cwd()) {
+  const filePaths = [];
+  const sources = /* @__PURE__ */ new Map();
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    filePaths.push(nearestFile);
+    sources.set(resolve(nearestFile), "nearest");
+  }
+  const coworkWorkspaceDir = detectCoworkWorkspaceDir();
+  if (coworkWorkspaceDir) {
+    const coworkFile = join(coworkWorkspaceDir, PROJECT_DEEPLINE_ENV_FILE);
+    if (existsSync(coworkFile) && !filePaths.some((filePath) => resolve(filePath) === resolve(coworkFile))) {
+      filePaths.push(coworkFile);
+      sources.set(resolve(coworkFile), "cowork");
+    }
+  }
+  return filePaths.map((filePath) => ({
+    filePath,
+    env: parseEnvFile(filePath),
+    source: sources.get(resolve(filePath)) ?? "nearest"
+  }));
+}
+function normalizeBaseUrl(baseUrl) {
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
+  if (!trimmed) return "";
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "";
+    }
+    return parsed.toString().replace(/\/+$/, "");
+  } catch {
+    return "";
+  }
+}
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+function formatEnvFileValue(value) {
+  return /^[a-zA-Z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function mergePersistedEnvValues(existing, values) {
+  const merged = { ...existing, ...values };
+  const nextApiKey = values[API_KEY_ENV];
+  if (nextApiKey !== void 0 && nextApiKey !== existing[API_KEY_ENV] && values[ACTIVE_ORG_ID_ENV] === void 0) {
+    delete merged[ACTIVE_ORG_ID_ENV];
+    delete merged[ACTIVE_ORG_NAME_ENV];
+    delete merged[FEATURES_ENV];
+  }
+  if (values[FEATURES_ENV] === "") {
+    delete merged[FEATURES_ENV];
+  }
+  return merged;
+}
+function persistedEnvLines(values) {
+  return Object.entries(values).filter(
+    ([key, value]) => CLI_ENV_ALLOWED_KEYS.has(key) && value.trim() !== ""
+  ).map(([key, value]) => `${key}=${formatEnvFileValue(value)}`);
+}
+function sdkCliConfigDir(baseUrl) {
+  const home = process.env.HOME?.trim() || homedir();
+  return join(home, ".local", "deepline", baseUrlSlug(baseUrl || PROD_URL));
+}
+function sdkCliStateDirPath(baseUrl, homeDir = process.env.HOME?.trim() || homedir()) {
+  return join(
+    homeDir,
+    ".local",
+    "deepline",
+    baseUrlSlug(baseUrl || PROD_URL),
+    "sdk-cli"
+  );
+}
+function sdkCliEnvFilePath(baseUrl) {
+  return join(sdkCliConfigDir(baseUrl), ".env");
+}
+function loadCliEnv(baseUrl = PROD_URL) {
+  return parseEnvFile(sdkCliEnvFilePath(baseUrl));
+}
+function hostConfigDirPath(baseUrl) {
+  return sdkCliConfigDir(baseUrl);
+}
+function hostEnvFilePath(baseUrl) {
+  return sdkCliEnvFilePath(baseUrl);
+}
+function saveHostEnvValues(baseUrl, values) {
+  const filePath = sdkCliEnvFilePath(baseUrl);
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const lines = persistedEnvLines(merged);
+  writeFileSync(filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function loadGlobalCliEnv() {
+  return loadCliEnv(PROD_URL);
+}
+function autoDetectBaseUrl() {
+  const projectEnvs = loadProjectEnvCandidates();
+  const globalEnv = loadGlobalCliEnv();
+  return normalizeBaseUrl(process.env[HOST_URL_ENV] ?? "") || firstNonEmpty(
+    ...projectEnvs.map(({ env }) => normalizeBaseUrl(env[HOST_URL_ENV]))
+  ) || normalizeBaseUrl(globalEnv[HOST_URL_ENV] ?? "") || PROD_URL;
+}
+function resolveApiKeyForBaseUrl(baseUrl, explicitApiKey) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const projectEnvs = loadProjectEnvCandidates();
+  const cliEnv = loadCliEnv(normalizedBaseUrl || baseUrl);
+  return firstNonEmpty(
+    explicitApiKey,
+    process.env[API_KEY_ENV],
+    ...projectEnvs.map(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
+      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
+    }),
+    cliEnv[API_KEY_ENV]
+  );
+}
+function resolveProjectApiKeyForBaseUrl(baseUrl, startDir = process.cwd()) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  return firstNonEmpty(
+    ...loadProjectEnvCandidates(startDir).map(({ env }) => {
+      const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
+      return projectBaseUrl === normalizedBaseUrl ? env[API_KEY_ENV] : "";
+    })
+  );
+}
+function resolveGlobalApiKeyForBaseUrl(baseUrl) {
+  return firstNonEmpty(
+    process.env[API_KEY_ENV],
+    loadCliEnv(normalizeBaseUrl(baseUrl) || baseUrl)[API_KEY_ENV]
+  );
+}
+function getResolvedProjectAuthSource(baseUrl, apiKey, startDir = process.cwd()) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const normalizedApiKey = apiKey.trim();
+  if (!normalizedBaseUrl || !normalizedApiKey) return null;
+  return loadProjectEnvCandidates(startDir).find(({ env }) => {
+    const projectBaseUrl = normalizeBaseUrl(env[HOST_URL_ENV] ?? "");
+    return projectBaseUrl === normalizedBaseUrl && (env[API_KEY_ENV] ?? "").trim() === normalizedApiKey;
+  }) ?? null;
+}
+function resolveBaseUrlOnly(options) {
+  const baseUrl = normalizeBaseUrl(
+    options?.baseUrl?.trim() || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  return baseUrl;
+}
+function resolveConfig(options) {
+  const baseUrl = normalizeBaseUrl(
+    options?.baseUrl?.trim() || autoDetectBaseUrl()
+  );
+  if (!baseUrl) {
+    throw new ConfigError(
+      `Invalid ${HOST_URL_ENV}. Expected an http(s) URL such as https://code.deepline.com.`
+    );
+  }
+  const apiKey = resolveApiKeyForBaseUrl(baseUrl, options?.apiKey);
+  if (!apiKey) {
+    throw new ConfigError(
+      `No API key found. Set ${API_KEY_ENV}, add it to .env.deepline, or run: deepline auth register`
+    );
+  }
+  return {
+    apiKey,
+    baseUrl,
+    timeout: options?.timeout ?? DEFAULT_TIMEOUT,
+    maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+    // Pass through untouched: the transport owns case-insensitive merging so
+    // there is exactly one place that decides which header wins.
+    ...options?.headers ? { headers: { ...options.headers } } : {}
+  };
+}
+function mergeProjectEnvFile(filePath, values) {
+  const existing = parseEnvFile(filePath);
+  const merged = mergePersistedEnvValues(existing, values);
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  ensureProjectEnvIsIgnored(dir);
+  const lines = persistedEnvLines(merged);
+  writeFileSync(filePath, `${lines.join("\n")}
+`, "utf-8");
+}
+function ensureProjectEnvIsIgnored(dir) {
+  ensureProjectPrivatePathsIgnored(dir, [
+    PROJECT_DEEPLINE_ENV_FILE,
+    ".deepline/"
+  ]);
+}
+function ensureProjectPrivatePathsIgnored(dir, entries) {
+  const gitDir = findNearestGitCommonDir(dir);
+  if (gitDir) {
+    const excludePath = join(gitDir, "info", "exclude");
+    const existing2 = existsSync(excludePath) ? readFileSync(excludePath, "utf-8") : "";
+    const existingEntries2 = new Set(
+      existing2.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+    );
+    const missing2 = entries.filter(
+      (entry) => !existingEntries2.has(entry) && !existingEntries2.has(`/${entry}`)
+    );
+    if (missing2.length === 0) return;
+    mkdirSync(dirname(excludePath), { recursive: true });
+    const prefix2 = existing2 && !existing2.endsWith("\n") ? "\n" : "";
+    writeFileSync(
+      excludePath,
+      `${existing2}${prefix2}${missing2.join("\n")}
+`,
+      "utf-8"
+    );
+    return;
+  }
+  const gitignorePath = join(dir, ".gitignore");
+  const existing = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  );
+  const missing = entries.filter(
+    (entry) => !existingEntries.has(entry) && !existingEntries.has(`/${entry}`)
+  );
+  if (missing.length === 0) return;
+  const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+  writeFileSync(
+    gitignorePath,
+    `${existing}${prefix}${missing.join("\n")}
+`,
+    "utf-8"
+  );
+}
+function findNearestGitCommonDir(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    const candidate = join(current, ".git");
+    if (existsSync(candidate)) {
+      try {
+        const stat = statSync(candidate);
+        if (stat.isDirectory()) return candidate;
+        if (stat.isFile()) {
+          const match = readFileSync(candidate, "utf8").match(
+            /^gitdir:\s*(.+)$/m
+          );
+          const rawGitDir = match?.[1]?.trim();
+          if (rawGitDir) {
+            const gitDir = isAbsolute(rawGitDir) ? rawGitDir : resolve(dirname(candidate), rawGitDir);
+            const commonDirPath = join(gitDir, "commondir");
+            if (!existsSync(commonDirPath)) return gitDir;
+            const rawCommonDir = readFileSync(commonDirPath, "utf8").trim();
+            return rawCommonDir ? isAbsolute(rawCommonDir) ? rawCommonDir : resolve(gitDir, rawCommonDir) : gitDir;
+          }
+        }
+      } catch {
+        return null;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function saveProjectDeeplineEnvValues(values, startDir = process.cwd()) {
+  const target = resolveProjectPinTarget(startDir);
+  if (!target.ok) {
+    throw new ConfigError(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder before running this command.`
+    );
+  }
+  const filePath = join(target.dir, PROJECT_DEEPLINE_ENV_FILE);
+  mergeProjectEnvFile(filePath, values);
+  return [filePath];
+}
+function resolveProjectPinTarget(startDir = process.cwd()) {
+  const nearestFile = findNearestEnvFile(PROJECT_DEEPLINE_ENV_FILE, startDir);
+  if (nearestFile && !isInIgnoredCoworkMount(nearestFile)) {
+    return { ok: true, dir: dirname(nearestFile), source: "nearest" };
+  }
+  const coworkCandidates = listCoworkWorkspaceDirCandidates();
+  if (coworkCandidates.length === 1) {
+    return { ok: true, dir: coworkCandidates[0], source: "cowork" };
+  }
+  if (coworkCandidates.length > 1) {
+    const resolvedStartDir = canonicalPath(startDir);
+    const cwdCandidate = coworkCandidates.find((candidate) => {
+      const resolvedCandidate = canonicalPath(candidate);
+      return resolvedStartDir === resolvedCandidate || resolvedStartDir.startsWith(`${resolvedCandidate}/`);
+    });
+    if (cwdCandidate) {
+      return { ok: true, dir: cwdCandidate, source: "cowork" };
+    }
+    return {
+      ok: false,
+      reason: "ambiguous_cowork_project",
+      candidates: coworkCandidates
+    };
+  }
+  return { ok: true, dir: resolve(startDir), source: "cwd" };
+}
+function getActiveProjectAuthSource(startDir = process.cwd()) {
+  return loadProjectEnvCandidates(startDir)[0] ?? null;
+}
+function findNearestProjectMarkerDir(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (COWORK_PROJECT_MARKERS.some((marker) => existsSync(join(current, marker)))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function resolveCliAuthProvenance(config, startDir = process.cwd()) {
+  const envApiKey = process.env[API_KEY_ENV]?.trim();
+  const folderAuth = getResolvedProjectAuthSource(
+    config.baseUrl,
+    config.apiKey,
+    startDir
+  );
+  const pinTarget = resolveProjectPinTarget(startDir);
+  const markerDir = findNearestProjectMarkerDir(startDir);
+  const project = !pinTarget.ok ? {
+    state: "ambiguous_cowork_project",
+    candidates: pinTarget.candidates
+  } : folderAuth ? {
+    state: "project",
+    dir: dirname(folderAuth.filePath),
+    pinPath: folderAuth.filePath,
+    source: "folder"
+  } : pinTarget.source === "cowork" ? {
+    state: "project",
+    dir: pinTarget.dir,
+    pinPath: join(pinTarget.dir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "cowork"
+  } : markerDir ? {
+    state: "project",
+    dir: markerDir,
+    pinPath: join(markerDir, PROJECT_DEEPLINE_ENV_FILE),
+    source: "marker"
+  } : { state: "not_project" };
+  return {
+    scope: envApiKey ? "env" : folderAuth ? "folder" : "global",
+    project,
+    folderAuthPath: folderAuth?.filePath ?? null
+  };
+}
+function activeOrganizationFromEnv(env) {
+  const orgId = env[ACTIVE_ORG_ID_ENV]?.trim();
+  if (!orgId) return null;
+  const orgName = env[ACTIVE_ORG_NAME_ENV]?.trim() || null;
+  return { org_id: orgId, org_name: orgName };
+}
+function resolveCliCommandContext(inputConfig, requestedScope) {
+  let config = inputConfig;
+  if (!config) {
+    try {
+      config = resolveConfig();
+    } catch {
+      return {
+        active_organization: null,
+        auth_scope: null,
+        metadata_source: null
+      };
+    }
+  }
+  const contextForScope = (scope) => {
+    if (scope === "env") {
+      const processApiKey = process.env[API_KEY_ENV]?.trim();
+      return processApiKey && processApiKey === config.apiKey ? {
+        active_organization: activeOrganizationFromEnv(process.env),
+        auth_scope: "env",
+        metadata_source: "process_env"
+      } : null;
+    }
+    if (scope === "folder") {
+      const projectAuth = getResolvedProjectAuthSource(
+        config.baseUrl,
+        config.apiKey
+      );
+      return projectAuth ? {
+        active_organization: activeOrganizationFromEnv(projectAuth.env),
+        auth_scope: "folder",
+        metadata_source: "folder_env"
+      } : null;
+    }
+    const hostEnv = loadCliEnv(config.baseUrl);
+    return (hostEnv[API_KEY_ENV] ?? "").trim() === config.apiKey ? {
+      active_organization: activeOrganizationFromEnv(hostEnv),
+      auth_scope: "global",
+      metadata_source: "host_env"
+    } : null;
+  };
+  const processContext = contextForScope("env");
+  if (processContext) return processContext;
+  if (requestedScope) {
+    return contextForScope(requestedScope) ?? {
+      active_organization: null,
+      auth_scope: requestedScope,
+      metadata_source: null
+    };
+  }
+  for (const scope of ["folder", "global"]) {
+    const context = contextForScope(scope);
+    if (context) return context;
+  }
+  return {
+    active_organization: null,
+    auth_scope: null,
+    metadata_source: null
+  };
+}
+
+// src/version.ts
+var SDK_VERSION = SDK_RELEASE.version;
+var SDK_API_MAJOR = SDK_RELEASE.contracts.api.currentMajor;
+var SDK_API_CONTRACT = SDK_RELEASE.contracts.api.legacyWireIds[0] ?? `api-v${SDK_API_MAJOR}`;
+
+// src/agent-runtime.ts
+import { homedir as homedir2 } from "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(process.env[name] ?? "").trim().toLowerCase()
+  );
+}
+function normalizeAgentRuntime(value) {
+  const explicit = value?.trim().toLowerCase().replace(/-/g, "_");
+  if (!explicit) return null;
+  if (explicit === "gemini_cli") return "gemini";
+  return EXPLICIT_AGENT_RUNTIMES.has(explicit) ? explicit : null;
+}
+function isCoworkLikeSandbox2() {
+  const pluginMode = truthyEnv("DEEPLINE_PLUGIN_MODE");
+  const claudeRemote = truthyEnv("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() || homedir2();
+  const sessionHome = home === "/sessions" || home.startsWith("/sessions/");
+  return claudeRemote || sessionHome || (pluginMode || pluginRoot) && projectDir;
+}
+function detectAgentRuntime(options = {}) {
+  const explicit = normalizeAgentRuntime(process.env.DEEPLINE_AGENT_RUNTIME);
+  if (explicit) return explicit;
+  if (process.env.CODEX_THREAD_ID?.trim()) return "codex";
+  if (options.detectCowork !== false && isCoworkLikeSandbox2()) {
+    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";
+  }
+  if (process.env.ANTIGRAVITY?.trim() || process.env.ANTIGRAVITY_CLI?.trim() || process.env.ANTIGRAVITY_AGENT?.trim() || process.env.ANTIGRAVITY_WORKSPACE?.trim()) {
+    return "antigravity";
+  }
+  if (process.env.GEMINI_CLI?.trim() || process.env.GEMINI_CLI_VERSION?.trim() || process.env.GEMINI_SANDBOX?.trim() || process.env.GEMINI_CONFIG_DIR?.trim()) {
+    return "gemini";
+  }
+  return options.defaultRuntime ?? "unknown";
+}
+
+// src/skills-version.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+function activePluginSkillsDir() {
+  const pluginMode = process.env.DEEPLINE_PLUGIN_MODE?.trim().toLowerCase();
+  if (pluginMode !== "true" && pluginMode !== "1" && pluginMode !== "yes" && pluginMode !== "on") {
+    return "";
+  }
+  const dir = process.env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim() ?? "";
+  return dir && existsSync2(dir) ? dir : "";
+}
+function hasActivePluginSkills() {
+  return Boolean(activePluginSkillsDir());
+}
+function readPluginSkillsVersion() {
+  const dir = activePluginSkillsDir();
+  if (!dir) return "";
+  try {
+    return readFileSync2(join2(dir, ".version"), "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+var KNOWN_SKILL_AGENTS = [
+  "antigravity",
+  "claude-code",
+  "cline",
+  "codex",
+  "cursor",
+  "gemini-cli",
+  "windsurf"
+];
+var DEFAULT_SKILL_AGENTS = [
+  "codex",
+  "claude-code",
+  "cursor",
+  "gemini-cli",
+  "antigravity"
+];
+function skillsAgentPathSegment(agent) {
+  if (agent === "*") return "all";
+  const slug = agent.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "");
+  return slug || "agent";
+}
+function sdkSkillsVersionPath(baseUrl, agents = []) {
+  const suffix = agents.length > 0 ? `-${agents.map(skillsAgentPathSegment).join("-")}` : "";
+  return join2(sdkCliStateDirPath(baseUrl), `skills${suffix}-version`);
+}
+function legacySdkSkillsVersionPath(baseUrl) {
+  return join2(dirname2(sdkCliStateDirPath(baseUrl)), "sdk-skills", ".version");
+}
+function readSkillsVersionFile(path) {
+  try {
+    return readFileSync2(path, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function resolveAutoSyncSkillAgents() {
+  switch (detectAgentRuntime()) {
+    case "codex":
+      return ["codex"];
+    case "claude_code":
+      return ["claude-code"];
+    case "cursor":
+      return ["cursor"];
+    case "gemini":
+      return ["gemini-cli"];
+    case "antigravity":
+      return ["antigravity"];
+    case "unknown":
+      return [...DEFAULT_SKILL_AGENTS];
+    default:
+      return [];
+  }
+}
+function readSdkSkillsLocalVersion(baseUrl) {
+  const pluginVersion = readPluginSkillsVersion();
+  if (pluginVersion) return pluginVersion;
+  const agents = resolveAutoSyncSkillAgents();
+  if (agents.length > 1) {
+    const versions = agents.map(
+      (agent) => readSkillsVersionFile(sdkSkillsVersionPath(baseUrl, [agent]))
+    );
+    const first = versions[0];
+    return first && versions.every((version) => version === first) ? first : "";
+  }
+  const scopedPath = sdkSkillsVersionPath(baseUrl, agents);
+  if (agents.length > 0 && existsSync2(scopedPath)) {
+    try {
+      return readFileSync2(scopedPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  }
+  if (agents.length > 0) {
+    const legacyPath = legacySdkSkillsVersionPath(baseUrl);
+    if (!existsSync2(legacyPath)) return "";
+    try {
+      return readFileSync2(legacyPath, "utf-8").trim();
+    } catch {
+      return "";
+    }
+  }
+  const path = existsSync2(sdkSkillsVersionPath(baseUrl)) ? sdkSkillsVersionPath(baseUrl) : legacySdkSkillsVersionPath(baseUrl);
+  if (!existsSync2(path)) return "";
+  try {
+    return readFileSync2(path, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function writeSdkSkillsLocalVersion(baseUrl, version, agents) {
+  const targets = agents.length > 1 ? agents.map((agent) => [agent]) : [agents];
+  let complete = true;
+  for (const target of targets) {
+    const path = sdkSkillsVersionPath(baseUrl, target);
+    try {
+      mkdirSync2(dirname2(path), { recursive: true });
+      writeFileSync2(path, `${version}
+`, "utf-8");
+    } catch {
+      complete = false;
+    }
+  }
+  return complete;
+}
+
+// ../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";
+
+// src/deployment-protection.ts
+function deploymentProtectionHeaders() {
+  const token = typeof process !== "undefined" ? process.env?.VERCEL_PROTECTION_BYPASS_TOKEN : void 0;
+  return token ? { "x-vercel-protection-bypass": token } : {};
+}
+var fetchWithDeploymentProtection = (input, init) => {
+  const headers = new Headers(
+    input instanceof Request ? input.headers : void 0
+  );
+  new Headers(init?.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/runtime-incident-drills.ts
+var RUNTIME_TEST_FAULT_IDS = [
+  "receipt_complete_write_fail",
+  "receipt_fail_write_fail",
+  "worker_receipt_complete_write_fail",
+  "invocation_response_delivery_abort",
+  "execution_upstream_response_loss",
+  "receipt_gateway_hold_ms",
+  "receipt_claim_query_hold_once_ms",
+  "receipt_claim_response_timeout",
+  "modal_sandbox_create_resource_exhausted",
+  "runtime_sheet_page_tail_hold_ms"
+];
+var LOCAL_TOPOLOGY = ["local_daytona"];
+var LOCAL_AND_PREVIEW_TOPOLOGIES = [
+  "local_daytona",
+  "preview_fly",
+  "preview_direct_modal"
+];
+var MODAL_PREVIEW_TOPOLOGY = ["preview_direct_modal"];
+var RUNTIME_INCIDENT_DRILL_CATALOG = [
+  {
+    id: "local_worker_process_outage",
+    description: "Interrupt the scheduler worker in the selected non-production runtime topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "process",
+      component: "worker",
+      modes: ["pause", "crash"]
+    },
+    expected: {
+      outcome: "The same logical run stays durable through the worker outage and completes after the selected topology recovers.",
+      safetyFacts: ["same_logical_run", "no_false_success"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "local_gateway_process_outage",
+    description: "Interrupt the receipt gateway in the selected non-production runtime topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "process",
+      component: "gateway",
+      modes: ["pause", "crash"]
+    },
+    expected: {
+      outcome: "In-flight work recovers only at a safe receipt boundary and the same logical run completes after the gateway recovers.",
+      safetyFacts: [
+        "same_logical_run",
+        "no_false_success",
+        "bounded_provider_execution"
+      ]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "local_runtime_process_outage",
+    description: "Interrupt both runtime components in the selected non-production topology.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: { kind: "process", component: "all", modes: ["pause", "crash"] },
+    expected: {
+      outcome: "Durable work waits through the combined outage; it never becomes a false success or creates a second logical run.",
+      safetyFacts: ["same_logical_run", "no_false_success"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "local-component-outage-recovery-e2e"
+    }
+  },
+  {
+    id: "receipt_complete_write_fail",
+    description: "Fail the next durable receipt-completion write.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The failed run is loud, and a later bounded recovery may repeat the affected provider operation if its prior completion was not durable.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-persist-failure-run-fatal-e2e"
+    }
+  },
+  {
+    id: "receipt_fail_write_fail",
+    description: "Fail the next durable receipt-failure write.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The failure is loud; recovery remains bounded and may repeat an operation whose prior outcome was not durably recorded.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "focused_regression",
+      target: "tests/lib/plays/runtime-test-fault-registry.test.ts"
+    }
+  },
+  {
+    id: "worker_receipt_complete_write_fail",
+    description: "Fail the worker-side receipt-completion write once.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The worker reports the persistence failure loudly; bounded recovery may repeat work whose completion was not durable.",
+      safetyFacts: ["retry_or_explicit_recovery", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "focused_regression",
+      target: "tests/lib/plays/runtime-test-fault-registry.test.ts"
+    }
+  },
+  {
+    id: "invocation_response_delivery_abort",
+    description: "Abort one receipt-gateway response after invocation delivery.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run completes through terminal-cache replay; any provider retry is governed by its separate operation policy.",
+      safetyFacts: ["same_logical_run", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "invocation-delivery-replay-e2e"
+    }
+  },
+  {
+    id: "execution_upstream_response_loss",
+    description: "Lose the first response of each keyed execution after the upstream app durably stores it.",
+    topologies: ["preview_fly"],
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same invocation recovers the stored response without repeating provider work or customer charges, and every row retains its usable result.",
+      safetyFacts: [
+        "same_logical_run",
+        "bounded_provider_execution",
+        "all_rows_settle_once",
+        "no_false_success"
+      ]
+    },
+    verification: {
+      kind: "preview_black_box",
+      target: "101-agent-heavy-gateway-load-e2e"
+    }
+  },
+  {
+    id: "receipt_gateway_hold_ms",
+    description: "Hold one checked-out receipt-gateway scheduler client.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "The request is delayed inside the real gateway pool and either completes within its deadline or follows bounded transport recovery.",
+      safetyFacts: ["bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "agent-heavy-gateway-load-e2e"
+    }
+  },
+  {
+    id: "receipt_claim_query_hold_once_ms",
+    description: "Hold one physical receipt-claim query.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "The checked-out claim either completes or times out through bounded recovery; an ambiguous outcome may be retried within its budget.",
+      safetyFacts: ["bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-claim-deadline-recovery-e2e"
+    }
+  },
+  {
+    id: "receipt_claim_response_timeout",
+    description: "Report one fully received receipt-claim response as timed out.",
+    topologies: LOCAL_AND_PREVIEW_TOPOLOGIES,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run completes by replaying the committed receipt response or uses bounded recovery if that response is unavailable.",
+      safetyFacts: ["same_logical_run", "bounded_provider_execution"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "receipt-ambiguous-response-recovery-e2e"
+    }
+  },
+  {
+    id: "modal_sandbox_create_resource_exhausted",
+    description: "Make Modal sandbox creation return RESOURCE_EXHAUSTED before user code.",
+    topologies: MODAL_PREVIEW_TOPOLOGY,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 1,
+      valueMeaning: "occurrence"
+    },
+    expected: {
+      outcome: "The same logical run enters bounded pre-code defer/recovery and later retries sandbox startup; no user code or provider call precedes the retry.",
+      safetyFacts: [
+        "same_logical_run",
+        "no_user_code_before_recovery",
+        "bounded_provider_execution"
+      ]
+    },
+    verification: {
+      kind: "preview_black_box",
+      target: "modal-sandbox-recovery-e2e"
+    }
+  },
+  {
+    id: "runtime_sheet_page_tail_hold_ms",
+    description: "Hold one runtime-sheet tail-page operation.",
+    topologies: LOCAL_TOPOLOGY,
+    control: {
+      kind: "runtime_test_fault",
+      defaultValue: 500,
+      valueMeaning: "milliseconds"
+    },
+    expected: {
+      outcome: "Page-tail work stays pending during the bounded hold, then completes without losing or duplicating rows.",
+      safetyFacts: ["all_rows_settle_once"]
+    },
+    verification: {
+      kind: "local_black_box",
+      target: "page-tail-sheet-write-hold-e2e"
+    }
+  }
+];
+function isRuntimeTestFaultDrill(drill) {
+  return drill.control.kind === "runtime_test_fault" && RUNTIME_TEST_FAULT_IDS.some((faultId) => faultId === drill.id);
+}
+function runtimeTestFaultDrills() {
+  return RUNTIME_INCIDENT_DRILL_CATALOG.filter(isRuntimeTestFaultDrill);
+}
+
+// ../play-runtime/test-runtime-seams.ts
+var PLAY_RUNTIME_TEST_FAULT_HEADER = "x-deepline-test-fault";
+var SUPPORTED_RUNTIME_TEST_FAULTS = new Set(
+  runtimeTestFaultDrills().map(({ id }) => id)
+);
+var MAX_RUNTIME_TEST_POLICY_MS = 10 * 6e4;
+
+// 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 = Symbol("deeplineRequestTimeout");
+var REQUEST_ABORT_MARKER = Symbol("deeplineRequestAbort");
+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 = 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 networkDiagnosticUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return void 0;
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    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) {
+    this.config = config;
+  }
+  cleanDiagnosticHeader(value) {
+    const normalized = String(value ?? "").replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, MAX_DIAGNOSTIC_HEADER_LENGTH);
+    return normalized || null;
+  }
+  readSkillsVersionHeader() {
+    const explicit = this.cleanDiagnosticHeader(
+      process.env.DEEPLINE_SKILLS_VERSION
+    );
+    if (explicit) return explicit;
+    try {
+      return this.cleanDiagnosticHeader(
+        readSdkSkillsLocalVersion(this.config.baseUrl)
+      );
+    } catch {
+      return null;
+    }
+  }
+  authHeaders(extra) {
+    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(),
+      "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();
+    const skillsVersion = this.readSkillsVersionHeader();
+    if (skillsVersion) {
+      headers["X-Deepline-Skills-Version"] = skillsVersion;
+    }
+    const playArtifactR2Prefix = typeof process !== "undefined" ? process.env?.DEEPLINE_PLAY_ARTIFACT_R2_PREFIX : void 0;
+    if (playArtifactR2Prefix) {
+      headers["x-deepline-play-artifact-r2-prefix"] = playArtifactR2Prefix;
+    }
+    const coordinatorUrl = typeof process !== "undefined" ? process.env?.DEEPLINE_COORDINATOR_URL : void 0;
+    const coordinatorInternalToken = typeof process !== "undefined" ? process.env?.DEEPLINE_INTERNAL_TOKEN : void 0;
+    const absurdReleaseOverride = typeof process !== "undefined" ? process.env?.DEEPLINE_ABSURD_RELEASE : void 0;
+    const preferredReceiptGatewayMachineId = typeof process !== "undefined" ? process.env?.DEEPLINE_PREFERRED_RECEIPT_GATEWAY_MACHINE_ID : void 0;
+    if (coordinatorUrl?.trim()) {
+      headers[COORDINATOR_URL_OVERRIDE_HEADER] = coordinatorUrl.trim();
+    }
+    const workerCallbackUrl = typeof process !== "undefined" ? process.env?.DEEPLINE_WORKER_CALLBACK_URL : void 0;
+    if (workerCallbackUrl?.trim()) {
+      headers[WORKER_CALLBACK_URL_OVERRIDE_HEADER] = workerCallbackUrl.trim();
+    }
+    const runtimeSchedulerSchema = typeof process !== "undefined" ? process.env?.DEEPLINE_RUNTIME_SCHEDULER_SCHEMA : void 0;
+    if (runtimeSchedulerSchema?.trim()) {
+      headers[RUNTIME_SCHEDULER_SCHEMA_OVERRIDE_HEADER] = runtimeSchedulerSchema.trim();
+    }
+    const syntheticRun = typeof process !== "undefined" ? process.env?.DEEPLINE_SYNTHETIC_RUN : void 0;
+    if (syntheticRun && syntheticRun.trim() && syntheticRun.trim() !== "0") {
+      headers[SYNTHETIC_RUN_HEADER] = "1";
+    }
+    const runtimeTestFault = typeof process !== "undefined" ? process.env?.DEEPLINE_TEST_RUNTIME_FAULT : void 0;
+    if (runtimeTestFault?.trim()) {
+      headers[PLAY_RUNTIME_TEST_FAULT_HEADER] = runtimeTestFault.trim();
+    }
+    const retainedReceivers = typeof process !== "undefined" ? process.env?.DEEPLINE_RUNTIME_RETAINED_PIPELINE_RECEIVERS?.trim() : void 0;
+    if (retainedReceivers && coordinatorInternalToken?.trim()) {
+      headers[RETAINED_PIPELINE_RECEIVERS_HEADER] = retainedReceivers;
+      headers[COORDINATOR_INTERNAL_TOKEN_HEADER] = coordinatorInternalToken.trim();
+    }
+    if (absurdReleaseOverride?.trim() && coordinatorInternalToken?.trim()) {
+      headers[ABSURD_RELEASE_OVERRIDE_HEADER] = absurdReleaseOverride.trim();
+    }
+    if (preferredReceiptGatewayMachineId?.trim() && coordinatorInternalToken?.trim()) {
+      headers[PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER] = preferredReceiptGatewayMachineId.trim();
+    }
+    if (coordinatorInternalToken?.trim() && (coordinatorUrl?.trim() || workerCallbackUrl?.trim() || runtimeTestFault?.trim() || absurdReleaseOverride?.trim() || preferredReceiptGatewayMachineId?.trim())) {
+      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 = options?.method ?? "GET";
+    const requestStartedAt = Date.now();
+    let fetchAttempts = 0;
+    let lastRequestUrl = url;
+    let networkFailedAt;
+    let networkPhase = "before_request";
+    const headers = this.authHeaders(options?.headers);
+    if (options?.body !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    const candidateUrls = options?.exactUrlOnly ? [url] : buildCandidateUrls(url);
+    let retryAfterDelayMs = null;
+    const maxRetries = options?.maxRetries ?? this.config.maxRetries;
+    requestAttempts: for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (options?.signal?.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;
+        networkPhase = "retry_wait";
+        try {
+          await sleep(delayMs, options?.signal);
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          networkFailedAt = Date.now();
+          break;
+        }
+      }
+      for (const candidateUrl of candidateUrls) {
+        if (options?.signal?.aborted) {
+          lastError = requestCancelledError(options.signal);
+          networkFailedAt = Date.now();
+          break requestAttempts;
+        }
+        const controller = new AbortController();
+        const timeoutMs = options?.timeout ?? this.config.timeout;
+        let requestTimedOut = false;
+        const timeoutId = setTimeout(() => {
+          requestTimedOut = true;
+          controller.abort();
+        }, timeoutMs);
+        const abortRequest = () => controller.abort();
+        options?.signal?.addEventListener("abort", abortRequest, {
+          once: true
+        });
+        networkPhase = "before_request";
+        try {
+          const requestBody = options?.formData !== void 0 ? typeof options.formData === "function" ? options.formData() : options.formData : options?.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";
+          options?.onResponse?.(response);
+          if (response.status === 404 && options?.allowNotFound) {
+            clearTimeout(timeoutId);
+            return null;
+          }
+          const body = await response.text();
+          clearTimeout(timeoutId);
+          const parsed = parseResponseBody(body);
+          const structuredToolError = options?.toolId && !response.ok ? deserializeToolExecutionFailure(
+            apiErrorMessage(parsed, response.status),
+            isRecord(parsed) ? parsed.tool_error : null,
+            TOOL_EXECUTION_ERROR_SCHEMA_VERSION
+          ) : null;
+          if (structuredToolError) {
+            if (response.status === 429) {
+              const retryAfter = parseRetryAfter(response);
+              const failure = serializeToolExecutionFailure(structuredToolError);
+              lastError = failure === null ? structuredToolError : new ToolRateLimitError(structuredToolError.message, {
+                ...failure,
+                retryAfterMs: failure.retryAfterMs ?? Math.max(0, retryAfter)
+              });
+              if (attempt < maxRetries) {
+                retryAfterDelayMs = retryAfter;
+                break;
+              }
+              throw lastError;
+            }
+            throw structuredToolError;
+          }
+          if (response.status === 429) {
+            if (options?.preserveRateLimitResponse && isMonitorRateLimitEnvelope(parsed)) {
+              throw new DeeplineError(
+                apiErrorMessage(parsed, response.status),
+                response.status,
+                apiErrorCodeFromResponse(parsed),
+                { response: parsed }
+              );
+            }
+            const retryAfter = parseRetryAfter(response);
+            lastError = new RateLimitError(retryAfter);
+            if (attempt < maxRetries) {
+              retryAfterDelayMs = retryAfter;
+              break;
+            }
+            throw lastError;
+          }
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new AuthError(apiErrorMessage(parsed, response.status));
+          }
+          if (!response.ok) {
+            const retryableApiError = options?.retryApiErrors === true && isRetryableApiErrorResponse(response.status);
+            const htmlError = detectHtmlErrorBody(
+              body,
+              response.headers.get("content-type")
+            );
+            if (htmlError) {
+              lastError = new 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 = apiErrorCodeFromResponse(parsed);
+            lastError = new 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 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 (options?.signal?.aborted) {
+            lastError = requestCancelledError(options.signal);
+            break requestAttempts;
+          }
+          if (error instanceof AuthError || error instanceof DeeplineError) {
+            throw error;
+          }
+          if (error instanceof RateLimitError) {
+            lastError = error;
+            break;
+          }
+          lastError = normalizeRequestAbortError(error, {
+            timeoutMs,
+            timedOut: requestTimedOut
+          });
+        } finally {
+          clearTimeout(timeoutId);
+          options?.signal?.removeEventListener("abort", abortRequest);
+        }
+      }
+      if (attempt < maxRetries) continue;
+    }
+    if (lastError instanceof DeeplineError) {
+      throw lastError;
+    }
+    const mappedNetworkError = mapNetworkError(
+      baseUrl,
+      lastError,
+      describeRequestTarget(path)
+    );
+    const failedAt = 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 (options?.toolId) {
+      const code = mappedNetworkError.code;
+      throw withErrorCause(
+        new 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: false,
+            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 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 = options?.method ?? "GET";
+    const headers = this.authHeaders({
+      Accept: "text/event-stream",
+      ...options?.headers
+    });
+    if (options?.body !== void 0) {
+      applyExplicitHeaders(headers, { "Content-Type": "application/json" });
+    }
+    let lastError = null;
+    for (const candidateUrl of buildCandidateUrls(url)) {
+      try {
+        const response = await fetch(candidateUrl, {
+          method,
+          headers,
+          body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: options?.signal
+        });
+        if (!response.ok) {
+          const body = await response.text();
+          const parsed = parseResponseBody(body);
+          if (response.status === 401 && !isProviderOriginatedHttpError(parsed)) {
+            throw new AuthError(apiErrorMessage(parsed, response.status));
+          }
+          const htmlError = detectHtmlErrorBody(
+            body,
+            response.headers.get("content-type")
+          );
+          if (htmlError) {
+            throw new DeeplineError(
+              htmlError.message(response.status),
+              response.status,
+              "API_ERROR",
+              {
+                htmlErrorPage: true,
+                ...htmlError.title ? { title: htmlError.title } : {},
+                ...htmlError.workerThrewException ? { workerThrewException: true } : {}
+              }
+            );
+          }
+          throw new DeeplineError(
+            apiErrorMessage(parsed, response.status),
+            response.status,
+            apiErrorCodeFromResponse(parsed),
+            { response: parsed }
+          );
+        }
+        if (!response.body) {
+          throw new DeeplineError("SSE response did not include a body.");
+        }
+        yield* decodeSseStream(response.body);
+        return;
+      } catch (error) {
+        if (error instanceof AuthError || error instanceof DeeplineError) {
+          throw error;
+        }
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        if (isAbortLikeError(normalized) && options?.signal?.aborted) {
+          throw new DeeplineError(
+            `Stream from ${this.config.baseUrl} was aborted by the caller.`,
+            void 0,
+            "ABORTED"
+          );
+        }
+        lastError = normalized;
+      }
+    }
+    if (lastError && isAbortLikeError(lastError)) {
+      throw new DeeplineError(
+        withCoworkNetworkHint(
+          `Unable to stream from ${this.config.baseUrl}. The remote stream was interrupted.`
+        ),
+        void 0,
+        "PLAY_STREAM_NETWORK_ABORTED"
+      );
+    }
+    throw new DeeplineError(
+      withCoworkNetworkHint(
+        lastError?.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 {
+    return body;
+  }
+}
+function isProviderOriginatedHttpError(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  const failureOrigin = error?.failure_origin ?? response?.failure_origin;
+  const code = error?.code ?? response?.code;
+  return failureOrigin === "provider" || code === "UPSTREAM_BLOCKED";
+}
+function isMonitorRateLimitEnvelope(parsed) {
+  const response = asRecord(parsed);
+  const error = asRecord(response?.error);
+  return error?.code === "monitor_upstream_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 = (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 = titleMatch?.[1]?.replace(/\s+/g, " ").trim() || 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 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 {
+    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 = 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((resolve2, reject) => {
+    if (signal?.aborted) {
+      reject(requestCancelledError(signal));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve2();
+    }, ms);
+    const abort = () => {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", abort);
+      reject(requestCancelledError(signal));
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+function withCoworkNetworkHint(message) {
+  if (!isCoworkLikeSandbox2() || message.includes(COWORK_NETWORK_HINT)) {
+    return message;
+  }
+  return `${message}
+${COWORK_NETWORK_HINT}`;
+}
+
+export {
+  AuthError,
+  RateLimitError,
+  ToolRateLimitError,
+  ConfigError,
+  HOST_URL_ENV,
+  API_KEY_ENV,
+  ACTIVE_ORG_ID_ENV,
+  ACTIVE_ORG_NAME_ENV,
+  FEATURES_ENV,
+  PROD_URL,
+  featureEnvValues,
+  storedHostApiKey,
+  storedHostFeatures,
+  baseUrlSlug,
+  sdkCliStateDirPath,
+  hostConfigDirPath,
+  hostEnvFilePath,
+  saveHostEnvValues,
+  autoDetectBaseUrl,
+  resolveApiKeyForBaseUrl,
+  resolveProjectApiKeyForBaseUrl,
+  resolveGlobalApiKeyForBaseUrl,
+  getResolvedProjectAuthSource,
+  resolveBaseUrlOnly,
+  resolveConfig,
+  ensureProjectPrivatePathsIgnored,
+  saveProjectDeeplineEnvValues,
+  resolveProjectPinTarget,
+  getActiveProjectAuthSource,
+  resolveCliAuthProvenance,
+  resolveCliCommandContext,
+  SDK_VERSION,
+  SDK_API_MAJOR,
+  SDK_API_CONTRACT,
+  detectAgentRuntime,
+  hasActivePluginSkills,
+  KNOWN_SKILL_AGENTS,
+  DEFAULT_SKILL_AGENTS,
+  skillsAgentPathSegment,
+  resolveAutoSyncSkillAgents,
+  readSdkSkillsLocalVersion,
+  writeSdkSkillsLocalVersion,
+  deploymentProtectionHeaders,
+  fetchWithDeploymentProtection,
+  COORDINATOR_INTERNAL_TOKEN_HEADER,
+  RUNTIME_ENVIRONMENT_TOKEN_HEADER,
+  RETAINED_PIPELINE_RECEIVERS_HEADER,
+  HttpClient
+};