openpond 0.0.36 → 0.0.38

package/dist/chunks/chunk-275WCETC.js

@@ -0,0 +1,668 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  mapUiBaseToApiBase,
+  resolveBaseUrl,
+  resolveSandboxApiUrlOption
+} from "./chunk-GDZYDLEL.js";
+import {
+  DEFAULT_CACHE_TTL_MS,
+  SANDBOX_RUNTIME_PROFILE_IDS,
+  createOpenPondSandboxClient,
+  getCachedApps,
+  getCachedTools,
+  getDeploymentLogs,
+  getDeploymentStatus,
+  listApps,
+  listUserTools,
+  loadConfig,
+  saveGlobalConfig,
+  setCachedApps,
+  setCachedTools
+} from "./chunk-ZI4GDAUB.js";
+import {
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_WEB_BASE_URL
+} from "./chunk-KSRWKXRB.js";
+import {
+  parseBooleanOption
+} from "./chunk-MUMPWI4O.js";
+
+// src/cli/common/auth.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+var UI_API_KEY_URL = `${DEFAULT_OPENPOND_WEB_BASE_URL}/settings/api-keys`;
+function resolveApiKey(config) {
+  const envKey = process.env.OPENPOND_API_KEY?.trim();
+  if (envKey) return envKey;
+  const stored = config.apiKey?.trim();
+  if (stored) return stored;
+  const legacy = config.token?.trim();
+  if (legacy && legacy.startsWith("opk_")) return legacy;
+  return null;
+}
+async function promptForApiKey() {
+  if (!input.isTTY || !output.isTTY) {
+    throw new Error(
+      "OpenPond API key is required in non-interactive mode. Set OPENPOND_API_KEY or run `openpond login` in a terminal."
+    );
+  }
+  console.log("Open the OpenPond UI to create an API key:");
+  console.log(UI_API_KEY_URL);
+  const rl = createInterface({ input, output });
+  try {
+    const value = (await rl.question("Paste your OpenPond API key: ")).trim();
+    if (!value) {
+      throw new Error("API key is required");
+    }
+    if (!value.startsWith("opk_")) {
+      console.log("warning: API keys usually start with opk_.");
+    }
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+async function ensureApiKey(config, baseUrl) {
+  const existing = resolveApiKey(config);
+  if (existing) return existing;
+  const apiKey = await promptForApiKey();
+  await saveGlobalConfig({
+    apiKey,
+    baseUrl,
+    activeProfile: config.activeProfile
+  });
+  console.log("saved api key to ~/.openpond/config.json");
+  return apiKey;
+}
+
+// src/cli/common/repo-format.ts
+function resolveRepoUrl(response) {
+  if (response.repoUrl) return response.repoUrl;
+  if (response.gitHost && response.gitOwner && response.gitRepo) {
+    return `https://${response.gitHost}/${response.gitOwner}/${response.gitRepo}.git`;
+  }
+  throw new Error("repoUrl missing from API response");
+}
+function formatTokenizedRepoUrl(repoUrl, token) {
+  const url = new URL(repoUrl);
+  const encodedToken = encodeURIComponent(token);
+  return `${url.protocol}//x-access-token:${encodedToken}@${url.host}${url.pathname}`;
+}
+function formatTokenizedRepoUrlForPrint(repoUrl) {
+  const url = new URL(repoUrl);
+  return `${url.protocol}//x-access-token:$OPENPOND_API_KEY@${url.host}${url.pathname}`;
+}
+function redactToken(value) {
+  return value.replace(/x-access-token:[^@]+@/g, "x-access-token:***@");
+}
+function warnOnRepoHostMismatch(repoUrl) {
+  const envBase = process.env.OPENPOND_BASE_URL;
+  if (!envBase) return;
+  try {
+    const baseHost = new URL(envBase).hostname;
+    const repoHost = new URL(repoUrl).hostname;
+    if (baseHost && repoHost && baseHost !== repoHost) {
+      console.warn(
+        `warning: repo host (${repoHost}) does not match OPENPOND_BASE_URL (${baseHost})`
+      );
+      console.warn(
+        "warning: verify your git host configuration matches OPENPOND_BASE_URL."
+      );
+    }
+  } catch {
+  }
+}
+function parseHandleRepo(value) {
+  const parts = value.split("/").filter(Boolean);
+  if (parts.length !== 2) {
+    throw new Error("expected <handle>/<repo>");
+  }
+  return { handle: parts[0], repo: parts[1] };
+}
+function normalizeRepoName(value) {
+  return (value || "").trim().toLowerCase();
+}
+
+// src/cli/common/cache.ts
+async function fetchAppsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedApps({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const apps = await listApps(params.apiBase, params.apiKey);
+  await setCachedApps({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    apps
+  });
+  return apps;
+}
+async function fetchToolsWithCache(params) {
+  if (!params.forceRefresh) {
+    const cached = await getCachedTools({
+      apiBase: params.apiBase,
+      apiKey: params.apiKey,
+      ttlMs: DEFAULT_CACHE_TTL_MS
+    });
+    if (cached) {
+      return cached;
+    }
+  }
+  const result = await listUserTools(params.apiBase, params.apiKey);
+  const tools = Array.isArray(result.tools) ? result.tools : [];
+  await setCachedTools({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    tools
+  });
+  return tools;
+}
+async function resolveAppTarget(apiBase, apiKey, target) {
+  const { handle, repo } = parseHandleRepo(target);
+  const apps = await fetchAppsWithCache({ apiBase, apiKey });
+  const normalizedRepo = normalizeRepoName(repo);
+  const match = apps.find((app) => {
+    if (app.handle && app.handle !== handle) {
+      return false;
+    }
+    const candidates = [app.repo, app.gitRepo, app.id].map(normalizeRepoName);
+    return candidates.includes(normalizedRepo);
+  });
+  if (!match) {
+    throw new Error(`app not found for ${handle}/${repo}`);
+  }
+  return { app: match, handle, repo };
+}
+async function pollDeploymentLogs(params) {
+  const intervalMs = params.intervalMs ?? 5e3;
+  const timeoutMs = params.timeoutMs ?? 4 * 60 * 1e3;
+  const seen = /* @__PURE__ */ new Set();
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const logs = await getDeploymentLogs(
+      params.baseUrl,
+      params.apiKey,
+      params.deploymentId
+    );
+    const newLogs = logs.filter((log) => !seen.has(log.id));
+    for (const log of newLogs) {
+      seen.add(log.id);
+    }
+    for (const log of newLogs) {
+      console.log(`${params.prefix}${log.message}`);
+    }
+    const status = await getDeploymentStatus(
+      params.baseUrl,
+      params.apiKey,
+      params.deploymentId
+    );
+    if (status.status === "failed") {
+      console.log(`${params.prefix}deployment failed`);
+      return;
+    }
+    if (status.status === "running" || status.status === "deployed") {
+      console.log(`${params.prefix}deployment complete`);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+  console.log(`${params.prefix}deployment still in progress`);
+}
+
+// src/cli/common/prompts.ts
+import { stdin as input2, stdout as output2 } from "node:process";
+import { createInterface as createInterface2 } from "node:readline/promises";
+async function readAllStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+}
+function readMaskedLine(prompt) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stderr = process.stderr;
+    let value = "";
+    const wasRaw = stdin.isRaw;
+    function cleanup() {
+      stdin.off("data", onData);
+      if (stdin.setRawMode) stdin.setRawMode(wasRaw);
+      stdin.pause();
+      stderr.write("\n");
+    }
+    function onData(chunk) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      for (const byte of buffer) {
+        if (byte === 3) {
+          cleanup();
+          reject(new Error("secret prompt cancelled"));
+          return;
+        }
+        if (byte === 13 || byte === 10) {
+          cleanup();
+          resolve(value);
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          if (value.length > 0) {
+            value = value.slice(0, -1);
+            stderr.write("\b \b");
+          }
+          continue;
+        }
+        value += Buffer.from([byte]).toString("utf8");
+        stderr.write("*");
+      }
+    }
+    stderr.write(prompt);
+    stdin.resume();
+    if (stdin.setRawMode) stdin.setRawMode(true);
+    stdin.on("data", onData);
+  });
+}
+async function promptConfirm(question, defaultValue = false) {
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+    const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+    if (!answer) return defaultValue;
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function promptForPath(defaultPath) {
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    const answer = (await rl.question(`Local path (default: ${defaultPath}): `)).trim();
+    return answer || defaultPath;
+  } finally {
+    rl.close();
+  }
+}
+
+// src/cli/common/sandbox-options.ts
+var SANDBOX_WORKFLOW_MODES = [
+  "readonly",
+  "attempt",
+  "feature",
+  "rollout",
+  "replay",
+  "template_build",
+  "scheduled_run",
+  "patch_only",
+  "hotfix",
+  "multi_feature_batch"
+];
+var SANDBOX_RUNTIME_PROMOTION_POLICIES = ["none", "manual", "auto_after_checks"];
+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");
+  }
+  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(/\/$/, "");
+}
+async function resolveSandboxClient(options) {
+  const config = await loadConfig();
+  const uiBase = resolveBaseUrl(config);
+  const apiKey = await ensureApiKey(config, uiBase);
+  const sandboxApiUrl = resolveSandboxApiUrlOption(options) || process.env.OPENPOND_SANDBOX_API_URL?.trim() || null;
+  return createOpenPondSandboxClient(
+    sandboxApiUrl ? { apiKey, sandboxApiUrl } : { apiKey, baseUrl: resolveSandboxBaseUrl(config, options) }
+  );
+}
+function parseSandboxWorkflowModeOption(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("workflow-mode must be a non-empty value");
+  }
+  const mode = value.trim();
+  if (!SANDBOX_WORKFLOW_MODES.includes(mode)) {
+    throw new Error(
+      `workflow-mode must be one of ${SANDBOX_WORKFLOW_MODES.join(", ")}`
+    );
+  }
+  return mode;
+}
+function parseSandboxRuntimePromotionPolicyOption(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("runtime-promotion-policy must be a non-empty value");
+  }
+  const policy = value.trim();
+  if (!SANDBOX_RUNTIME_PROMOTION_POLICIES.includes(policy)) {
+    throw new Error(
+      `runtime-promotion-policy must be one of ${SANDBOX_RUNTIME_PROMOTION_POLICIES.join(
+        ", "
+      )}`
+    );
+  }
+  return policy;
+}
+function parseSandboxRuntimeProfileIdOption(value) {
+  if (typeof value !== "string" || !value.trim()) return void 0;
+  const runtimeProfileId = value.trim();
+  if (!SANDBOX_RUNTIME_PROFILES.includes(runtimeProfileId)) {
+    throw new Error(
+      `runtime-profile-id must be one of ${SANDBOX_RUNTIME_PROFILES.join(
+        ", "
+      )}`
+    );
+  }
+  return runtimeProfileId;
+}
+function parseSandboxEnvOptions(options) {
+  const refs = parseSandboxEnvAssignments(options.envRef, "env-ref").map(
+    ({ name, value }) => ({ name, secretRef: value })
+  );
+  const literals = parseSandboxEnvAssignments(
+    options.envLiteral,
+    "env-literal"
+  ).map(({ name, value }) => {
+    if (isSecretLikeEnvName(name) && !parseBooleanOption(options.allowPlainSecretEnv)) {
+      throw new Error(
+        `refusing plaintext value for secret-like env ${name}; create a sandbox secret and pass --env-ref ${name}=openpond://secret/...`
+      );
+    }
+    return { name, value };
+  });
+  const env = [...refs, ...literals];
+  const names = /* @__PURE__ */ new Set();
+  for (const item of env) {
+    if (names.has(item.name)) {
+      throw new Error(`duplicate sandbox env var: ${item.name}`);
+    }
+    names.add(item.name);
+  }
+  return env;
+}
+function parseSandboxTemplateEnvOptions(manifest, options) {
+  const env = parseSandboxEnvOptions(options);
+  const provided = new Set(env.map((item) => item.name));
+  const providedByName = new Map(env.map((item) => [item.name, item]));
+  for (const requirement of manifest.inputs.env) {
+    const value = providedByName.get(requirement.name);
+    if (value?.value !== void 0 && requirement.secret !== false) {
+      throw new Error(
+        `sandbox template env ${requirement.name} requires a secret ref. Pass --env-ref ${requirement.name}=openpond://secret/...`
+      );
+    }
+  }
+  const missing = manifest.inputs.env.filter((item) => item.required && !provided.has(item.name)).map((item) => item.name);
+  if (missing.length > 0) {
+    throw new Error(
+      `missing required sandbox template env refs: ${missing.join(
+        ", "
+      )}. Pass --env-ref NAME=openpond://secret/...`
+    );
+  }
+  return env;
+}
+function parseSandboxEnvAssignments(value, label) {
+  if (typeof value !== "string") return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    const separator = item.indexOf("=");
+    if (separator <= 0) {
+      throw new Error(`${label} entries must use NAME=value`);
+    }
+    const name = item.slice(0, separator).trim();
+    const entryValue = item.slice(separator + 1).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+      throw new Error(`${label} has invalid env name: ${name}`);
+    }
+    if (!entryValue) {
+      throw new Error(`${label} value is required for ${name}`);
+    }
+    return { name, value: entryValue };
+  });
+}
+function isSecretLikeEnvName(name) {
+  return /(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD|PRIVATE|CREDENTIAL|DATABASE_URL|DSN)/i.test(
+    name
+  );
+}
+async function readSandboxSecretValue(options, label) {
+  if (typeof options.value === "string" || typeof options.secretValue === "string") {
+    throw new Error(
+      "sandbox secret values must be provided with --stdin or the masked prompt"
+    );
+  }
+  const useStdin = parseBooleanOption(options.stdin);
+  if (useStdin) {
+    const value2 = await readAllStdin();
+    if (!value2) throw new Error(`${label} read no secret value from stdin`);
+    return value2;
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error(`${label} requires --stdin when not running in a TTY`);
+  }
+  const value = await readMaskedLine(`${label}: `);
+  if (!value) throw new Error(`${label} cannot be empty`);
+  return value;
+}
+function summarizeSandboxSecret(secret) {
+  return {
+    id: secret.id,
+    teamId: secret.teamId,
+    name: secret.name,
+    scope: secret.scope,
+    status: secret.status,
+    secretRef: secret.secretRef,
+    currentVersion: secret.currentVersion,
+    updatedAt: secret.updatedAt,
+    lastUsedAt: secret.lastUsedAt,
+    attachedDestinations: secret.attachments?.length ?? 0
+  };
+}
+
+// ../../packages/cloud/src/process-runner.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { spawn } from "node:child_process";
+var DEFAULT_PROCESS_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_PROCESS_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+function runProcessCommand(command, args = [], options = {}) {
+  if (options.inherit && options.terminateWhenStdoutIncludes !== void 0) {
+    return Promise.reject(new Error("terminateWhenStdoutIncludes requires captured stdout"));
+  }
+  if (options.terminateWhenStdoutIncludes === "") {
+    return Promise.reject(new Error("terminateWhenStdoutIncludes must not be empty"));
+  }
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ? { ...process.env, ...options.env } : void 0,
+      shell: options.shell,
+      detached: options.detached ?? process.platform !== "win32",
+      stdio: options.inherit ? "inherit" : [options.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    const stdout = new BoundedOutput(maxOutputBytes(options));
+    const stderr = new BoundedOutput(maxOutputBytes(options));
+    let timedOut = false;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_PROCESS_TIMEOUT_MS;
+    let timeout;
+    let forceKill;
+    let requestedTermination = null;
+    let settled = false;
+    const clearTimers = () => {
+      if (timeout) clearTimeout(timeout);
+      if (forceKill) clearTimeout(forceKill);
+    };
+    const requestTermination = (reason) => {
+      if (requestedTermination !== null || settled) return;
+      requestedTermination = reason;
+      timedOut = reason === "timeout";
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+      terminateProcessTree(proc.pid, "SIGTERM");
+      forceKill = setTimeout(() => {
+        if (proc.exitCode === null && proc.signalCode === null) terminateProcessTree(proc.pid, "SIGKILL");
+      }, 5e3);
+    };
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        requestTermination("timeout");
+      }, timeoutMs);
+    }
+    if (!options.inherit) {
+      proc.stdout?.on("data", (chunk) => {
+        stdout.append(chunk);
+        const marker = options.terminateWhenStdoutIncludes;
+        if (marker !== void 0 && stdout.text().includes(marker)) {
+          requestTermination("output");
+        }
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderr.append(chunk);
+      });
+    }
+    proc.on("error", (error) => {
+      clearTimers();
+      settled = true;
+      reject(error);
+    });
+    proc.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve({
+        code,
+        signal,
+        terminationReason: requestedTermination ?? (signal ? "signal" : "exit"),
+        stdout: stdout.text(),
+        stderr: stderr.text(),
+        timedOut,
+        stdoutTruncated: stdout.truncated,
+        stderrTruncated: stderr.truncated
+      });
+    });
+    if (options.stdin !== void 0) {
+      proc.stdin?.end(options.stdin);
+    }
+  });
+}
+var BoundedOutput = class {
+  #chunks = [];
+  #maxBytes;
+  #bytes = 0;
+  truncated = false;
+  constructor(maxBytes) {
+    this.#maxBytes = maxBytes;
+  }
+  append(value) {
+    const chunk = Buffer2.isBuffer(value) ? value : Buffer2.from(value);
+    const remaining = this.#maxBytes - this.#bytes;
+    if (remaining <= 0) {
+      if (chunk.byteLength > 0) this.truncated = true;
+      return;
+    }
+    if (chunk.byteLength <= remaining) {
+      this.#chunks.push(chunk);
+      this.#bytes += chunk.byteLength;
+      return;
+    }
+    this.#chunks.push(chunk.subarray(0, remaining));
+    this.#bytes += remaining;
+    this.truncated = true;
+  }
+  text() {
+    const value = Buffer2.concat(this.#chunks, this.#bytes).toString("utf8");
+    return this.truncated ? `${value}
+[truncated after ${this.#maxBytes} bytes]
+` : value;
+  }
+};
+function maxOutputBytes(options) {
+  const value = options.maxOutputBytes ?? DEFAULT_PROCESS_MAX_OUTPUT_BYTES;
+  return Math.max(0, Math.floor(value));
+}
+function terminateProcessTree(pid, signal) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    const args = ["/PID", String(pid), "/T"];
+    if (signal === "SIGKILL") args.push("/F");
+    const killer = spawn("taskkill", args, { stdio: "ignore", windowsHide: true });
+    killer.unref();
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (error.code !== "ESRCH") throw error;
+  }
+}
+
+// src/cli/common/shell.ts
+async function runCommand(command, args, options = {}) {
+  return runProcessCommand(command, args, {
+    cwd: options.cwd,
+    inherit: options.inherit,
+    timeoutMs: options.timeoutMs,
+    maxOutputBytes: options.maxOutputBytes,
+    terminateWhenStdoutIncludes: options.terminateWhenStdoutIncludes
+  });
+}
+async function runShellCommand(command, options = {}) {
+  const timeoutMs = options.timeoutSeconds === void 0 ? void 0 : options.timeoutSeconds * 1e3;
+  return runProcessCommand(command, [], {
+    cwd: options.cwd,
+    env: options.env,
+    shell: true,
+    inherit: options.inherit,
+    timeoutMs,
+    maxOutputBytes: options.maxOutputBytes
+  });
+}
+async function getGitRemoteUrl(cwd, remoteName) {
+  const result = await runCommand("git", ["remote", "get-url", remoteName], {
+    cwd
+  });
+  if (result.code !== 0) return null;
+  const url = result.stdout.trim();
+  return url.length > 0 ? url : null;
+}
+
+export {
+  resolveApiKey,
+  promptForApiKey,
+  ensureApiKey,
+  resolveRepoUrl,
+  formatTokenizedRepoUrl,
+  formatTokenizedRepoUrlForPrint,
+  redactToken,
+  warnOnRepoHostMismatch,
+  normalizeRepoName,
+  fetchAppsWithCache,
+  fetchToolsWithCache,
+  resolveAppTarget,
+  pollDeploymentLogs,
+  promptConfirm,
+  promptForPath,
+  resolveSandboxClient,
+  parseSandboxWorkflowModeOption,
+  parseSandboxRuntimePromotionPolicyOption,
+  parseSandboxRuntimeProfileIdOption,
+  parseSandboxEnvOptions,
+  parseSandboxTemplateEnvOptions,
+  readSandboxSecretValue,
+  summarizeSandboxSecret,
+  runProcessCommand,
+  runCommand,
+  runShellCommand,
+  getGitRemoteUrl
+};

package/dist/chunks/{chunk-3DOOLZZM.js → chunk-43YI36NA.js}

@@ -4,7 +4,7 @@ import {
   listOpChatModels,
   sendHostedChatTurn,
   streamHostedChatTurn
-} from "./chunk-G6WW2656.js";
+} from "./chunk-HLCTINEP.js";
 
 // ../../packages/cloud/src/opchat-smoke.ts
 var DEFAULT_MODEL = "openpond-chat";