openpond 0.0.68 → 0.1.0

package/dist/chunks/{chunk-J2REM7LE.js → chunk-HFPUR4CQ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-SMNFI2FU.js";
 import {
   createOpenPondSandboxClient
-} from "./chunk-JGOP4GCK.js";
+} from "./chunk-JTHL5XJ2.js";
 import {
   DEFAULT_CACHE_TTL_MS,
   SANDBOX_RUNTIME_PROFILE_IDS,
@@ -15,13 +15,12 @@ import {
   getDeploymentLogs,
   getDeploymentStatus,
   listApps,
-  listConfiguredProfiles,
   listUserTools,
   loadConfig,
   saveGlobalConfig,
   setCachedApps,
   setCachedTools
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 import {
   DEFAULT_OPENPOND_API_BASE_URL,
   DEFAULT_OPENPOND_WEB_BASE_URL
@@ -291,71 +290,6 @@ async function promptForPath(defaultPath) {
   }
 }
 
-// src/cli/common/vercel-protection.ts
-import { spawnSync } from "node:child_process";
-import path from "node:path";
-function ensureStagingVercelProtectionBypass(requestUrl, options = {}) {
-  const env = options.env ?? process.env;
-  if (env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim()) return true;
-  if (!isOpenPondStagingUrl(requestUrl)) return false;
-  const cwd = path.resolve(options.cwd ?? process.cwd());
-  const projectDirectories = candidateProjectDirectories(cwd, env);
-  const run = options.run ?? runProtectionCommand;
-  const command = process.platform === "win32" ? "vercel.cmd" : "vercel";
-  for (const projectDirectory of projectDirectories) {
-    const result = run({
-      command,
-      args: ["project", "protection", "--format", "json"],
-      cwd: projectDirectory,
-      env
-    });
-    if (result.status !== 0 || !result.stdout.trim()) continue;
-    const secret = vercelProtectionBypassSecret(result.stdout);
-    if (!secret) continue;
-    env.VERCEL_AUTOMATION_BYPASS_SECRET = secret;
-    return true;
-  }
-  return false;
-}
-function vercelProtectionBypassSecret(rawProtectionJson) {
-  try {
-    const payload = JSON.parse(rawProtectionJson);
-    const entries = Object.entries(payload.protectionBypass ?? {});
-    const selected = entries.find(([, metadata]) => metadata?.isEnvVar === true) ?? entries[0];
-    return selected?.[0]?.trim() || null;
-  } catch {
-    return null;
-  }
-}
-function isOpenPondStagingUrl(requestUrl) {
-  try {
-    const hostname = new URL(requestUrl).hostname.toLowerCase();
-    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
-  } catch {
-    return false;
-  }
-}
-function candidateProjectDirectories(cwd, env) {
-  const configured = env.OPENPOND_VERCEL_PROJECT_DIR?.trim();
-  return [.../* @__PURE__ */ new Set([
-    ...configured ? [path.resolve(cwd, configured)] : [],
-    path.resolve(cwd, "../sandbox"),
-    cwd
-  ])];
-}
-function runProtectionCommand(input3) {
-  const result = spawnSync(input3.command, input3.args, {
-    cwd: input3.cwd,
-    env: input3.env,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  return {
-    status: result.status,
-    stdout: typeof result.stdout === "string" ? result.stdout : ""
-  };
-}
-
 // src/cli/common/sandbox-options.ts
 var SANDBOX_WORKFLOW_MODES = [
   "readonly",
@@ -374,13 +308,7 @@ var SANDBOX_RUNTIME_PROFILES = [
   ...SANDBOX_RUNTIME_PROFILE_IDS
 ];
 function resolveSandboxBaseUrl(config, options) {
-  const envName = typeof options.env === "string" ? options.env.trim().toLowerCase() : typeof options.environment === "string" ? options.environment.trim().toLowerCase() : "";
-  if (envName === "staging") {
-    return "https://api-new.staging-api.openpond.ai";
-  }
-  if (envName && envName !== "production") {
-    throw new Error("sandbox env must be staging or production");
-  }
+  void options;
   const base = process.env.OPENPOND_SANDBOX_BASE_URL || process.env.OPENPOND_API_URL || config.apiBaseUrl || mapUiBaseToApiBase(process.env.OPENPOND_BASE_URL || config.baseUrl) || DEFAULT_OPENPOND_API_BASE_URL;
   return base.replace(/\/$/, "");
 }
@@ -390,52 +318,13 @@ async function resolveSandboxClient(options) {
   const apiKey = await ensureApiKey(config, uiBase);
   const sandboxApiUrl = resolveSandboxApiUrlOption(options) || process.env.OPENPOND_SANDBOX_API_URL?.trim() || null;
   const baseUrl = resolveSandboxBaseUrl(config, options);
-  ensureStagingVercelProtectionBypass(sandboxApiUrl ?? baseUrl);
   return createOpenPondSandboxClient(
     sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl }
   );
 }
 async function loadSandboxConfig(options) {
-  const environment = sandboxEnvironmentOption(options);
-  if (!environment) return loadConfig();
-  const profiles = await listConfiguredProfiles();
-  const requestedAccount = typeof options.account === "string" ? options.account.trim().toLowerCase() : typeof options.profile === "string" ? options.profile.trim().toLowerCase() : "";
-  const matches = profiles.filter(
-    (profile) => profileMatchesEnvironment(profile, environment) && (!requestedAccount || profile.handle.toLowerCase() === requestedAccount)
-  );
-  const selected = matches.find((profile) => profile.isActive) ?? (matches.length === 1 ? matches[0] : null);
-  if (!selected) {
-    throw new Error(
-      matches.length === 0 ? `no saved ${environment} OpenPond account found; run openpond login for that environment first` : `multiple saved ${environment} OpenPond accounts found; pass --account and --base-url to select one`
-    );
-  }
-  return loadConfig({
-    account: selected.handle,
-    ...selected.baseUrl ? { baseUrl: selected.baseUrl } : {}
-  });
-}
-function sandboxEnvironmentOption(options) {
-  const value = typeof options.env === "string" ? options.env.trim().toLowerCase() : typeof options.environment === "string" ? options.environment.trim().toLowerCase() : "";
-  if (!value) return null;
-  if (value !== "production" && value !== "staging") {
-    throw new Error("sandbox env must be staging or production");
-  }
-  return value;
-}
-function profileMatchesEnvironment(profile, environment) {
-  const hosts = [profile.baseUrl, profile.apiBaseUrl].flatMap((value) => {
-    if (!value) return [];
-    try {
-      return [new URL(value).hostname.toLowerCase()];
-    } catch {
-      return [];
-    }
-  });
-  const isStaging = hosts.some(
-    (hostname) => hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai")
-  );
-  if (environment === "staging") return isStaging;
-  return !isStaging && profile.environment?.toLowerCase() === "production";
+  void options;
+  return loadConfig();
 }
 function parseSandboxWorkflowModeOption(value) {
   if (value === void 0) return void 0;

package/dist/chunks/{chunk-JIEUB6OS.js → chunk-J3YDKJFD.js}

@@ -1,7 +1,7 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   writePrivateJsonFile
-} from "./chunk-DBHSOTYZ.js";
+} from "./chunk-D7BO5Y5J.js";
 
 // ../../packages/cloud/src/profile/source-upload-cache.ts
 import { createHash } from "node:crypto";

package/dist/chunks/{training-5CPTZRVC.js → chunk-J7PYGDRY.js}

@@ -2,18 +2,17 @@ import { createRequire as __openpondCreateRequire } from "node:module"; var requ
 import {
   resolveApiBaseUrlOption
 } from "./chunk-SMNFI2FU.js";
-import "./chunk-KSRWKXRB.js";
 import {
   optionString,
   parseBooleanOption,
   parseIntegerOption,
   parseNumberOption
 } from "./chunk-MUMPWI4O.js";
-import "./chunk-UACZUFIA.js";
 
 // src/cli/training.ts
 import { readFile } from "node:fs/promises";
 import { request as requestHttp } from "node:http";
+import { randomUUID } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -35,12 +34,13 @@ async function runTrainingCommand(options, rest, dependencies = {}) {
     "cancel",
     "resume",
     "artifacts",
-    "benchmark"
+    "benchmark",
+    "create-project"
   ].includes(
     subcommand
   ) || !id) {
     throw new Error(
-      "usage: training <start|status|watch|logs|cancel|resume|artifacts|benchmark> <model-run-id|run-id|model-id>"
+      "usage: training <create-project|start|status|watch|logs|cancel|resume|artifacts|benchmark> <taskset-id|model-run-id|run-id|model-id>"
     );
   }
   if (rest.length > 2) {
@@ -52,6 +52,15 @@ async function runTrainingCommand(options, rest, dependencies = {}) {
     request: dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl)
   });
   const json = parseBooleanOption(options.json);
+  if (subcommand === "create-project") {
+    const project = await createManagedModelProject({
+      client,
+      options,
+      tasksetId: id
+    });
+    printResult(project, json);
+    return;
+  }
   if (subcommand === "benchmark") {
     await startHarnessRefinerBenchmark({
       client,
@@ -193,6 +202,20 @@ var TrainingApiClient = class {
       body
     );
   }
+  prepareModelProject(id, body) {
+    return this.json(
+      `/v1/training/model-projects/${encodeURIComponent(id)}/training/prepare`,
+      "POST",
+      body
+    );
+  }
+  startModelProject(id, body) {
+    return this.json(
+      `/v1/training/model-projects/${encodeURIComponent(id)}/training/start`,
+      "POST",
+      body
+    );
+  }
   trainingState() {
     return this.json("/v1/training", "GET");
   }
@@ -203,6 +226,28 @@ var TrainingApiClient = class {
       body
     );
   }
+  importTasksetDraftPackage(body) {
+    return this.json("/v1/training/taskset-drafts/import", "POST", body);
+  }
+  publishTasksetDraft(draftId, modelId) {
+    return this.json(
+      `/v1/training/taskset-drafts/${encodeURIComponent(draftId)}/publish`,
+      "POST",
+      modelId ? { modelId } : {}
+    );
+  }
+  tasksetReadiness(tasksetId) {
+    return this.json("/v1/training/readiness", "POST", { tasksetId });
+  }
+  deleteTasksetDraft(draftId) {
+    return this.json(
+      `/v1/training/taskset-drafts/${encodeURIComponent(draftId)}`,
+      "DELETE"
+    );
+  }
+  saveModelProject(project) {
+    return this.json("/v1/training/models", "PUT", project);
+  }
   async json(pathname, method, body) {
     const response = await this.request(`${this.baseUrl}${pathname}`, {
       method,
@@ -231,9 +276,9 @@ var TrainingApiClient = class {
 async function startHarnessRefinerBenchmark(input) {
   const state = await input.client.trainingState();
   const project = modelProject(state, input.modelId);
-  const providerId = optionString(input.options, "provider") ?? "openpond";
-  const modelId = optionString(input.options, "model") ?? "openpond-chat";
-  const effort = optionString(input.options, "reasoningEffort") ?? "high";
+  const providerId = optionString(input.options, "provider") || "openpond";
+  const modelId = optionString(input.options, "model") || "openpond-chat";
+  const effort = optionString(input.options, "reasoningEffort") || "high";
   const maximumSpendUsd = parseNumberOption(input.options.maxSpend, "max-spend") ?? 10;
   if (maximumSpendUsd <= 0) throw new Error("max-spend must be greater than zero");
   if (parseBooleanOption(input.options.detach)) {
@@ -273,6 +318,188 @@ function objectString(value, key) {
   const candidate = value[key];
   return typeof candidate === "string" && candidate ? candidate : null;
 }
+async function createManagedModelProject(input) {
+  const recipePath = optionString(input.options, "recipe");
+  if (!recipePath) {
+    throw new Error("training create-project requires --recipe <versioned-recipe.json>");
+  }
+  const recipe = await readJsonObject(recipePath, "Training recipe");
+  const state = await input.client.trainingState();
+  const taskset = trainingStateRecord(state, "tasksets", input.tasksetId, "Taskset");
+  const profileId = optionString(input.options, "profile") || objectString(taskset, "profileId");
+  if (!profileId) {
+    throw new Error(
+      `The Taskset has no Profile id (received ${typeof taskset.profileId}: ${String(taskset.profileId)}).`
+    );
+  }
+  const tasksetProfileId = objectString(taskset, "profileId");
+  if (tasksetProfileId !== profileId) {
+    throw new Error(
+      `Taskset ${input.tasksetId} belongs to Profile ${tasksetProfileId ?? "unknown"}, not ${profileId}.`
+    );
+  }
+  const projectId = optionString(input.options, "projectId") || `model_${randomUUID()}`;
+  const projects = trainingStateRecords(state, "modelProjects");
+  const existingProject = projects.find(
+    (project) => objectString(project, "id") === projectId
+  );
+  const rolloutPlacement = enumOption(
+    input.options,
+    "rolloutPlacement",
+    ["local", "remote"],
+    "local"
+  );
+  const gpuPlacementObjective = enumOption(
+    input.options,
+    "gpuPlacementObjective",
+    ["fast", "balanced", "economical"],
+    "balanced"
+  );
+  const runPreset = enumOption(
+    input.options,
+    "runPreset",
+    ["small", "standard", "custom", "small_experiment"],
+    "custom"
+  );
+  const maximumSpendUsd = parseNumberOption(input.options.maxSpend, "max-spend") ?? null;
+  if (maximumSpendUsd !== null && maximumSpendUsd < 0) {
+    throw new Error("max-spend must be non-negative");
+  }
+  const retentionDays = parseIntegerOption(
+    input.options.retentionDays,
+    "retention-days"
+  ) ?? null;
+  if (retentionDays !== null && retentionDays < 0) {
+    throw new Error("retention-days must be non-negative");
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const contentHash = objectString(taskset, "contentHash");
+  const revision = objectNumber(taskset, "revision");
+  if (!contentHash || !revision || revision < 1) {
+    throw new Error("The Taskset does not have an immutable published revision.");
+  }
+  const method = objectString(recipe, "method");
+  if (!method) throw new Error("Training recipe must declare its method.");
+  const baseModel = managedBasePreferenceFromRecipe(recipe);
+  if (existingProject) {
+    const existingSetup = objectRecord(existingProject, "trainingSetup");
+    const existingTasksetRef = objectRecord(existingSetup, "tasksetRef");
+    if (objectString(existingTasksetRef, "id") !== input.tasksetId || objectString(existingProject, "profileId") !== profileId) {
+      throw new Error(
+        `Model Project ${projectId} already exists for a different Profile or Taskset.`
+      );
+    }
+    if (objectRecord(existingSetup, "baseModel")) {
+      throw new Error(`Model Project ${projectId} already exists.`);
+    }
+    return input.client.saveModelProject({
+      ...existingProject,
+      revision: objectNumber(existingProject, "revision") ?? 1,
+      defaultBaseModel: baseModel,
+      trainingSetup: {
+        ...existingSetup,
+        baseModel,
+        recipe
+      },
+      updatedAt: timestamp
+    });
+  }
+  return input.client.saveModelProject({
+    schemaVersion: "openpond.modelProject.v2",
+    id: projectId,
+    profileId,
+    revision: 1,
+    name: optionString(input.options, "name") || objectString(taskset, "name") || "Managed Model",
+    objective: optionString(input.options, "objective") || objectString(taskset, "objective"),
+    defaultBaseModel: baseModel,
+    defaultDestinationId: optionString(input.options, "destination") || "openpond_managed",
+    trainingSetup: {
+      tasksetRef: { id: input.tasksetId, revision, contentHash },
+      tasksetRelease: null,
+      harnessRelease: null,
+      baseModel,
+      method,
+      destinationId: optionString(input.options, "destination") || "openpond_managed",
+      managedRolloutPlacement: rolloutPlacement,
+      managedGpuPlacementObjective: gpuPlacementObjective,
+      managedGpuRequirement: "any",
+      runPreset,
+      recipe,
+      preferredMaximumSpendUsd: maximumSpendUsd,
+      preferredRetentionDays: retentionDays
+    },
+    hosted: null,
+    tasksetSyncs: [],
+    createdAt: timestamp,
+    updatedAt: timestamp
+  });
+}
+function managedBasePreferenceFromRecipe(recipe) {
+  const recipeBase = objectRecord(recipe, "baseModel");
+  const modelId = objectString(recipeBase, "id");
+  const revision = objectString(recipeBase, "revision");
+  const tokenizerRevision = objectString(recipeBase, "tokenizerRevision");
+  const chatTemplateHash = objectString(recipeBase, "chatTemplateHash");
+  if (!modelId || !revision || !tokenizerRevision || !chatTemplateHash) {
+    throw new Error(
+      "Managed GRPO recipe must pin baseModel id, revision, tokenizerRevision, and chatTemplateHash."
+    );
+  }
+  return {
+    schemaVersion: "openpond.baseModelPreference.v1",
+    modelId,
+    revision,
+    tokenizerRevision,
+    chatTemplateHash,
+    modelAssetId: null,
+    source: "managed"
+  };
+}
+function trainingStateRecord(state, key, id, label) {
+  const match = trainingStateRecords(state, key).find(
+    (candidate) => objectString(candidate, "id") === id
+  );
+  if (!match) throw new Error(`${label} ${id} was not found.`);
+  return match;
+}
+function trainingStateRecords(state, key) {
+  if (!state || typeof state !== "object" || !(key in state)) return [];
+  const value = state[key];
+  return Array.isArray(value) ? value.filter(
+    (candidate) => Boolean(candidate) && typeof candidate === "object" && !Array.isArray(candidate)
+  ) : [];
+}
+function objectNumber(value, key) {
+  if (!value || typeof value !== "object" || !(key in value)) return null;
+  const candidate = value[key];
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : null;
+}
+function objectRecord(value, key) {
+  if (!value || typeof value !== "object" || !(key in value)) return null;
+  const candidate = value[key];
+  return candidate && typeof candidate === "object" && !Array.isArray(candidate) ? candidate : null;
+}
+function enumOption(options, key, values, fallback) {
+  const value = optionString(options, key) || fallback;
+  if (!values.includes(value)) {
+    throw new Error(`${key} must be one of ${values.join(", ")}`);
+  }
+  return value;
+}
+async function readJsonObject(file, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(file, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Could not read ${label} ${file}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${label} must be a JSON object.`);
+  }
+  return parsed;
+}
 async function startTraining(input) {
   const maximumSpendUsd = parseNumberOption(
     input.options.maxSpend,
@@ -287,11 +514,13 @@ async function startTraining(input) {
   }
   const manifestPath = optionString(input.options, "manifest");
   const manifest = manifestPath ? await readManifest(manifestPath) : void 0;
+  const comparisonSeriesEntryId = optionString(
+    input.options,
+    "comparisonSeriesEntry"
+  ) || null;
   const controls = { maximumSpendUsd, retentionDays };
-  const preparation = await input.client.modelRun(
+  const preparation = await input.client.prepareModelProject(
     input.modelRunId,
-    "prepare",
-    "POST",
     controls
   );
   if (!input.json) {
@@ -302,11 +531,14 @@ async function startTraining(input) {
   if (!confirmed) {
     throw new Error("Training start cancelled.");
   }
-  const result = await input.client.modelRun(
+  const result = await input.client.startModelProject(
     input.modelRunId,
-    "start",
-    "POST",
-    { ...controls, manifest }
+    {
+      ...controls,
+      exportApproved: parseBooleanOption(input.options.exportApproved),
+      manifest,
+      comparisonSeriesEntryId
+    }
   );
   printResult(result, input.json);
   if (parseBooleanOption(input.options.detach)) return;
@@ -393,7 +625,10 @@ function printResult(value, json) {
   }
   console.log(JSON.stringify(value, null, 2));
 }
+
 export {
-  TrainingApiClient,
-  runTrainingCommand
+  DEFAULT_LOCAL_TRAINING_API_URL,
+  runTrainingCommand,
+  createLocalAuthenticatedRequest,
+  TrainingApiClient
 };

package/dist/chunks/{chunk-JGOP4GCK.js → chunk-JTHL5XJ2.js}

@@ -1,24 +1,5 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 
-// ../../packages/cloud/dist/api/vercel-protection.js
-var VERCEL_PROTECTION_BYPASS_HEADER = "x-vercel-protection-bypass";
-function withVercelProtectionBypass(requestUrl, inputHeaders, env = typeof process === "undefined" ? {} : process.env) {
-  const headers = new Headers(inputHeaders);
-  const secret = env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();
-  if (!secret || !isOpenPondStagingUrl(requestUrl))
-    return headers;
-  headers.set(VERCEL_PROTECTION_BYPASS_HEADER, secret);
-  return headers;
-}
-function isOpenPondStagingUrl(requestUrl) {
-  try {
-    const hostname = new URL(requestUrl).hostname.toLowerCase();
-    return hostname === "staging.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.endsWith(".staging-api.openpond.ai");
-  } catch {
-    return false;
-  }
-}
-
 // ../../packages/cloud/dist/api/core.js
 var DEFAULT_API_TIMEOUT_MS = 3e4;
 var DEFAULT_API_RESPONSE_BYTES = 8 * 1024 * 1024;
@@ -61,7 +42,7 @@ var OpenPondApiError = class extends Error {
 async function apiFetch(baseUrl, token, requestPath, options = {}) {
   const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
   const requestUrl = `${baseUrl}${requestPath}`;
-  const headers = withVercelProtectionBypass(requestUrl, init.headers);
+  const headers = new Headers(init.headers);
   headers.set("Content-Type", "application/json");
   const apiKey = process.env.OPENPOND_API_KEY;
   const trimmedToken = token?.trim() || "";
@@ -203,7 +184,7 @@ function apiRootUrlFromSandboxApiUrl(sandboxApiUrl) {
   return sandboxApiUrl.slice(0, -suffix.length);
 }
 function isOpenPondHostedApiHost(hostname) {
-  return hostname === "api.openpond.ai" || hostname === "staging-api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
+  return hostname === "api.openpond.ai" || hostname.startsWith("api") && hostname.endsWith(".openpond.ai");
 }
 
 // ../../packages/cloud/dist/sandbox/client-handles.js
@@ -1781,14 +1762,14 @@ function requireToken(value) {
     throw new Error("OpenPond API key is required");
   return trimmed;
 }
-function hostedHeaders(requestUrl, token, accept, requestId) {
+function hostedHeaders(token, accept, requestId) {
   const headers = new Headers();
   headers.set("Authorization", `Bearer ${requireToken(token)}`);
   headers.set("Content-Type", "application/json");
   headers.set("Accept", accept);
   headers.set("x-openpond-client", "openpond-code");
   headers.set("x-openpond-request-id", requestId || randomUUID());
-  return withVercelProtectionBypass(requestUrl, headers);
+  return headers;
 }
 async function readError(response) {
   const text = await response.text().catch(() => "");
@@ -1834,7 +1815,7 @@ async function sendHostedChatTurn(options) {
   const requestUrl = `${apiBaseUrl}/chat/completions`;
   const response = await fetch(requestUrl, {
     method: "POST",
-    headers: hostedHeaders(requestUrl, options.token, "application/json", options.requestId),
+    headers: hostedHeaders(options.token, "application/json", options.requestId),
     body: JSON.stringify(buildHostedChatBody(options, false)),
     signal: options.signal
   });
@@ -1845,7 +1826,6 @@ async function sendHostedChatTurn(options) {
 }
 
 export {
-  withVercelProtectionBypass,
   OpenPondApiError,
   apiFetch,
   readApiJson,