openpond 0.0.37 → 0.0.39

package/dist/chunks/{chunk-ICLLW5QD.js → chunk-BQQZNGI6.js}

@@ -1,22 +1,23 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  DEFAULT_OPENPOND_API_BASE_URL,
   DEFAULT_OPENPOND_CHAT_MODEL,
-  DEFAULT_OPENPOND_WEB_BASE_URL,
   ProviderCatalogSchema,
   SandboxAppActionRegistrySchema,
-  checkOpenPondApiHealth,
   createRepo,
   getAppEnvironment,
   getOpenPondAccount,
-  getOpenPondAccountBalance,
   listApps,
   listConfiguredProfiles,
   loadGlobalConfig,
   saveConfig,
   saveProfileApiKey,
   setActiveProfile
-} from "./chunk-MHBQWGCL.js";
+} from "./chunk-2SF6HLT7.js";
+import {
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_WEB_BASE_URL,
+  withVercelProtectionBypass
+} from "./chunk-KHNHUA2H.js";
 
 // ../../packages/runtime/dist/chat.js
 import { randomUUID } from "node:crypto";
@@ -79,6 +80,9 @@ function normalizeOpChatApiBaseUrl(value) {
     return null;
   try {
     const url = new URL(normalized);
+    if (url.hostname.toLowerCase() === "api-new.staging-api.openpond.ai") {
+      url.hostname = "staging-api.openpond.ai";
+    }
     const segments = url.pathname.split("/").filter(Boolean);
     const opChatIndex = segments.findIndex((segment) => segment.toLowerCase() === "opchat");
     if (opChatIndex >= 0) {
@@ -253,9 +257,7 @@ function normalizeProfile(response) {
     isVerified: account.isVerified ?? null,
     dailyAgentAppId: account.dailyAgentAppId ?? null,
     dailyAgentDeploymentId: account.dailyAgentDeploymentId ?? null,
-    credits: account.credits ?? null,
-    turnkeyWalletAddress: account.turnkeyWalletAddress ?? null,
-    turnkeyOperatingWalletAddress: account.turnkeyOperatingWalletAddress ?? null
+    credits: account.credits ?? null
   };
 }
 function normalizeProducts(products) {
@@ -271,35 +273,13 @@ function normalizeProducts(products) {
     credits: product.credits ?? null
   }));
 }
-function normalizeBalance(response, error) {
-  if (!response)
-    return null;
-  return {
-    balanceKind: response.balanceKind,
-    balanceUsd: response.balanceUsd ?? null,
-    balanceUsdCents: response.balanceUsdCents ?? null,
-    currency: response.currency,
-    asOf: response.asOf,
-    stale: response.stale ?? Boolean(error),
-    error: error ?? null,
-    breakdown: (response.breakdown ?? []).map((item) => ({
-      wallet: item.wallet,
-      chain: item.chain,
-      chainId: item.chainId ?? null,
-      asset: item.asset,
-      amount: item.amount ?? null,
-      usdValue: item.usdValue ?? null
-    }))
-  };
-}
 function isEmptyDefaultProfile(profile) {
   return profile.handle.trim().toLowerCase() === "default" && !normalizeBaseUrl(profile.baseUrl) && !profile.hasApiKey && !profile.hasSessionToken;
 }
 function toAccountState(input) {
-  const { config, profiles, account, token, apiBaseUrl, accountResponse, balanceResponse, accountProfiles, health, authFailed, error, balanceError } = input;
+  const { config, profiles, account, token, apiBaseUrl, accountResponse, accountProfiles, health, authFailed, error } = input;
   const chatApiBaseUrl = resolveHostedChatApiBaseUrl(account, config, apiBaseUrl);
   const profile = normalizeProfile(accountResponse ?? null);
-  const balance = normalizeBalance(balanceResponse, balanceError);
   const configActiveProfile = normalizeActiveProfile(config.activeProfile);
   const accountSelector = account ? selectorFromAccount(account) : null;
   const activeSelector = accountSelector ?? configActiveProfile;
@@ -335,8 +315,6 @@ function toAccountState(input) {
     baseUrl,
     apiBaseUrl,
     chatApiBaseUrl,
-    balanceLabel: balanceResponse?.balanceLabel ?? "$0.00",
-    balance,
     creditsLabel: profile?.credits ?? null,
     profile,
     products: normalizeProducts(accountResponse?.products),
@@ -433,7 +411,7 @@ function errorMessage(error) {
 }
 
 // ../../packages/runtime/dist/chat.js
-var PROVIDER_CATALOG_FETCH_TIMEOUT_MS = 2500;
+var PROVIDER_CATALOG_FETCH_TIMEOUT_MS = 15e3;
 async function loadOpenPondProviderCatalog() {
   const context = await loadOpenPondAccountContext();
   if (!context.token) {
@@ -478,13 +456,16 @@ async function* streamOpenPondHostedChatTurn(input) {
     tools: input.tools,
     toolChoice: input.toolChoice,
     requestId: input.requestId,
+    reasoningEffort: input.reasoningEffort,
+    maxTokens: input.maxTokens,
     signal: input.signal
   });
 }
 async function listOpChatProviderCatalog(options) {
-  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "provider-catalog"), {
+  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "provider-catalog");
+  const response = await fetch(requestUrl, {
     method: "GET",
-    headers: opChatHeaders(options.token, "application/json"),
+    headers: opChatHeaders(requestUrl, options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -493,56 +474,61 @@ async function listOpChatProviderCatalog(options) {
   return ProviderCatalogSchema.parse(await response.json());
 }
 async function* streamOpChatChatCompletion(options) {
-  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "chat/completions"), {
+  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "chat/completions");
+  const response = await fetch(requestUrl, {
     method: "POST",
-    headers: opChatHeaders(options.token, "text/event-stream", options.requestId),
-    body: JSON.stringify(buildOpChatBody(options)),
+    headers: opChatHeaders(requestUrl, options.token, "application/json", options.requestId),
+    // Hosted turns are published only after the provider finishes. Requesting
+    // the complete response also preserves whitespace that some upstream
+    // token streams omit at chunk boundaries.
+    body: JSON.stringify(buildOpChatBody(options, false)),
     signal: options.signal
   });
-  if (!response.ok || !response.body) {
-    throw new Error(`OpenPond OpChat stream failed: ${response.status} ${await readOpChatError(response)}`);
+  if (!response.ok) {
+    throw new Error(`OpenPond OpChat request failed: ${response.status} ${await readOpChatError(response)}`);
   }
-  let reasoningText = "";
-  let hasToolCalls = false;
-  let pendingFinish = null;
-  let latestRaw = null;
-  for await (const raw of parseOpChatSse(response.body, options.signal)) {
-    latestRaw = raw;
-    if (raw && typeof raw === "object" && "error" in raw) {
-      throw new Error(`OpenPond OpChat stream failed: ${errorMessageFromPayload(raw)}`);
-    }
-    const usage = parseUsage(raw);
-    if (usage)
-      yield { type: "usage", usage, raw };
-    for (const delta of streamDeltasFromChunk(raw)) {
-      if (delta.type === "reasoning_delta")
-        reasoningText += delta.text;
-      if (delta.type === "tool_call_delta")
-        hasToolCalls = true;
-      if (delta.type === "finish")
-        pendingFinish = delta;
-      else
-        yield delta;
-    }
+  const raw = await response.json();
+  if (raw && typeof raw === "object" && "error" in raw) {
+    throw new Error(`OpenPond OpChat request failed: ${errorMessageFromPayload(raw)}`);
+  }
+  const record = raw && typeof raw === "object" ? raw : {};
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  const choice = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+  const message = choice.message && typeof choice.message === "object" ? choice.message : {};
+  const reasoningText = streamTextValue(message.reasoning_content);
+  const content = streamTextValue(message.content);
+  const toolCalls = parseToolCalls(message.tool_calls);
+  const usage = parseUsage(raw);
+  if (reasoningText)
+    yield { type: "reasoning_delta", text: reasoningText, raw };
+  if (content)
+    yield { type: "text_delta", text: content, raw };
+  if (toolCalls.length > 0) {
+    yield { type: "tool_call_delta", toolCalls, raw };
   }
-  if (hasToolCalls && reasoningText) {
+  if (toolCalls.length > 0 && reasoningText) {
     yield {
       type: "continuation",
       continuation: {
         kind: "chat_completions_reasoning",
         reasoningContent: reasoningText
       },
-      raw: latestRaw
+      raw
     };
   }
-  if (pendingFinish)
-    yield pendingFinish;
+  if (usage)
+    yield { type: "usage", usage, raw };
+  yield {
+    type: "finish",
+    finishReason: stringValue(choice.finish_reason),
+    raw
+  };
 }
-function buildOpChatBody(options) {
+function buildOpChatBody(options, stream) {
   const body = {
     model: options.model,
     messages: options.messages.map(opChatMessage),
-    stream: true
+    stream
   };
   if (options.tools) {
     body.tools = options.tools;
@@ -550,8 +536,23 @@ function buildOpChatBody(options) {
   if (options.toolChoice !== void 0) {
     body.tool_choice = options.toolChoice;
   }
+  if (typeof options.maxTokens === "number") {
+    body.max_tokens = options.maxTokens;
+  }
+  Object.assign(body, opChatReasoningFields(options.reasoningEffort));
   return body;
 }
+function opChatReasoningFields(effort) {
+  if (!effort)
+    return {};
+  if (effort === "low") {
+    return { thinking: { type: "disabled" } };
+  }
+  return {
+    thinking: { type: "enabled" },
+    reasoning_effort: effort === "xhigh" ? "max" : "high"
+  };
+}
 function opChatMessage(message) {
   const { continuation, ...projected } = message;
   if (message.role === "assistant" && continuation?.kind === "chat_completions_reasoning") {
@@ -568,7 +569,7 @@ function opChatEndpointUrl(apiBaseUrl, path) {
     throw new Error("OpenPond OpChat API base URL is required.");
   return `${normalized}/${path}`;
 }
-function opChatHeaders(token, accept, requestId) {
+function opChatHeaders(requestUrl, token, accept, requestId) {
   const trimmed = token.trim();
   if (!trimmed)
     throw new Error("OpenPond API key is required for OpChat.");
@@ -578,7 +579,7 @@ function opChatHeaders(token, accept, requestId) {
   headers.set("Accept", accept);
   headers.set("x-openpond-client", "openpond-app");
   headers.set("x-openpond-request-id", requestId || randomUUID());
-  return headers;
+  return withVercelProtectionBypass(requestUrl, headers);
 }
 async function readOpChatError(response) {
   const text = await response.text().catch(() => "");
@@ -605,72 +606,6 @@ function errorMessageFromPayload(payload) {
   }
   return [stringValue(record.error), stringValue(record.message)].filter(Boolean).join(": ") || JSON.stringify(payload);
 }
-async function* parseOpChatSse(stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const abortError = () => signal?.reason instanceof Error ? signal.reason : new Error("openpond_opchat_aborted");
-  try {
-    while (true) {
-      if (signal?.aborted)
-        throw abortError();
-      const result = await reader.read();
-      if (result.done)
-        break;
-      buffer += decoder.decode(result.value, { stream: true });
-      const blocks = buffer.split(/\r?\n\r?\n/);
-      buffer = blocks.pop() ?? "";
-      for (const block of blocks) {
-        for (const payload of parseSseBlock(block))
-          yield payload;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  buffer += decoder.decode();
-  if (buffer.trim()) {
-    for (const payload of parseSseBlock(buffer))
-      yield payload;
-  }
-}
-function parseSseBlock(block) {
-  const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n").trim();
-  if (!data || data === "[DONE]")
-    return [];
-  return [JSON.parse(data)];
-}
-function streamDeltasFromChunk(raw) {
-  if (!raw || typeof raw !== "object")
-    return [];
-  const record = raw;
-  const choices = Array.isArray(record.choices) ? record.choices : [];
-  const deltas = [];
-  for (const choice of choices) {
-    if (!choice || typeof choice !== "object")
-      continue;
-    const choiceRecord = choice;
-    const delta = choiceRecord.delta && typeof choiceRecord.delta === "object" ? choiceRecord.delta : {};
-    for (const key of ["content", "reasoning_content"]) {
-      const value = stringValue(delta[key]);
-      if (!value)
-        continue;
-      deltas.push({
-        type: key === "content" ? "text_delta" : "reasoning_delta",
-        text: value,
-        raw
-      });
-    }
-    const toolCalls = parseToolCalls(delta.tool_calls);
-    if (toolCalls.length > 0) {
-      deltas.push({ type: "tool_call_delta", toolCalls, raw });
-    }
-    const finishReason = stringValue(choiceRecord.finish_reason);
-    if (finishReason)
-      deltas.push({ type: "finish", finishReason, raw });
-  }
-  return deltas;
-}
 function parseToolCalls(value) {
   return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object") : [];
 }
@@ -685,6 +620,9 @@ function parseUsage(raw) {
 function stringValue(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
+function streamTextValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
 
 // ../../packages/runtime/dist/version.js
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -864,75 +802,76 @@ async function loadAccountProfileLookups(context) {
     const key = profileKey(account.handle, account.baseUrl);
     const token = accountToken(account);
     if (!token) {
-      return [key, { response: null, authFailed: false }];
+      return [
+        key,
+        { response: null, authFailed: false, error: null }
+      ];
     }
     try {
       return [
         key,
         {
           response: await getOpenPondAccount(resolvePublicApiBaseUrl(account, context.config), token),
-          authFailed: false
+          authFailed: false,
+          error: null
+        }
+      ];
+    } catch (error) {
+      return [
+        key,
+        {
+          response: null,
+          authFailed: true,
+          error: errorMessage(error)
         }
       ];
-    } catch {
-      return [key, { response: null, authFailed: true }];
     }
   }));
   return Object.fromEntries(entries);
 }
+async function loadOpenPondAccountStateForContext(context) {
+  const accountProfiles = await loadAccountProfileLookups(context);
+  const activeLookup = context.account ? accountProfiles[profileKey(context.account.handle, context.account.baseUrl)] ?? null : null;
+  const accountResponse = activeLookup?.response ?? null;
+  const authError = context.token && activeLookup?.authFailed ? activeLookup.error || "OpenPond account authentication failed." : null;
+  return {
+    account: toAccountState({
+      ...context,
+      accountResponse,
+      accountProfiles,
+      authFailed: Boolean(authError),
+      error: authError
+    })
+  };
+}
+async function loadOpenPondAccountState() {
+  return loadOpenPondAccountStateForContext(await loadOpenPondAccountContext());
+}
 async function loadOpenPondApps(options = {}) {
   const context = await loadOpenPondAccountContext();
+  const accountPromise = loadOpenPondAccountStateForContext(context);
   if (!context.token) {
-    const accountProfiles2 = await loadAccountProfileLookups(context);
     return {
-      account: toAccountState({ ...context, accountProfiles: accountProfiles2 }),
+      ...await accountPromise,
       apps: [],
       error: "No OpenPond API key or session token is configured."
     };
   }
-  const [healthResult, accountResult, balanceResult, appsResult, accountProfilesResult] = await Promise.allSettled([
-    checkOpenPondApiHealth(context.apiBaseUrl, context.token),
-    getOpenPondAccount(context.apiBaseUrl, context.token),
-    getOpenPondAccountBalance(context.apiBaseUrl, context.token),
+  const [accountResult, appsResult] = await Promise.allSettled([
+    accountPromise,
     listApps(context.apiBaseUrl, context.token, {
       handle: context.account?.handle,
       limit: options.limit ?? 20,
       offset: options.offset ?? 0,
       includeScheduled: options.includeScheduled ?? true
-    }),
-    loadAccountProfileLookups(context)
+    })
   ]);
-  const health = healthResult.status === "fulfilled" ? healthResult.value : null;
-  const accountResponse = accountResult.status === "fulfilled" ? accountResult.value : null;
-  const balanceResponse = balanceResult.status === "fulfilled" ? balanceResult.value : null;
-  const accountProfiles = accountProfilesResult.status === "fulfilled" ? accountProfilesResult.value : {};
-  if (accountResult.status === "fulfilled" && context.account) {
-    accountProfiles[profileKey(context.account.handle, context.account.baseUrl)] = {
-      response: accountResult.value,
-      authFailed: false
-    };
-  }
-  const appsSucceeded = appsResult.status === "fulfilled";
-  const accountSucceeded = accountResult.status === "fulfilled";
-  const anyAuthenticatedCallSucceeded = appsSucceeded || accountSucceeded || health?.authenticated === true;
-  const allAuthenticatedCallsFailed = !appsSucceeded && !accountSucceeded && health?.authenticated !== true;
-  const authError = health?.authenticated === false && !anyAuthenticatedCallSucceeded ? health.error || "OpenPond account authentication failed." : allAuthenticatedCallsFailed ? appsResult.status === "rejected" ? errorMessage(appsResult.reason) : accountResult.status === "rejected" ? errorMessage(accountResult.reason) : null : null;
-  const profileError = accountResult.status === "rejected" && anyAuthenticatedCallSucceeded ? `Profile unavailable: ${errorMessage(accountResult.reason)}` : null;
-  const appsError = appsResult.status === "rejected" ? errorMessage(appsResult.reason) : null;
-  const effectiveHealth = health && anyAuthenticatedCallSucceeded ? { ...health, authenticated: true, error: void 0 } : health;
+  if (accountResult.status === "rejected")
+    throw accountResult.reason;
   return {
-    account: toAccountState({
-      ...context,
-      accountResponse,
-      balanceResponse,
-      accountProfiles,
-      health: effectiveHealth,
-      authFailed: Boolean(authError),
-      error: authError ?? profileError,
-      balanceError: balanceResult.status === "rejected" ? errorMessage(balanceResult.reason) : null
-    }),
+    account: accountResult.value.account,
     apps: appsResult.status === "fulfilled" ? appsResult.value.map(normalizeApp).filter((value) => Boolean(value)) : [],
-    error: appsError
+    error: appsResult.status === "rejected" ? errorMessage(appsResult.reason) : null
   };
 }
 async function createOpenPondRepoApp(input) {
@@ -970,20 +909,6 @@ async function deriveHandleForApiKey(input, apiBaseUrl) {
       return fromProfile;
   } catch {
   }
-  try {
-    const apps = await listApps(apiBaseUrl, input.apiKey);
-    const counts = /* @__PURE__ */ new Map();
-    for (const app of apps) {
-      const handle2 = normalizeDerivedHandle(app.handle);
-      if (!handle2)
-        continue;
-      counts.set(handle2, (counts.get(handle2) ?? 0) + 1);
-    }
-    const [handle] = Array.from(counts.entries()).sort((left, right) => right[1] - left[1])[0] ?? [];
-    if (handle)
-      return handle;
-  } catch {
-  }
   return fallbackHandleForApiKey(input.apiKey);
 }
 async function saveOpenPondAccount(input) {
@@ -1003,8 +928,41 @@ async function saveOpenPondAccount(input) {
   return loadOpenPondAccountContext(handle, baseUrl);
 }
 
+// ../../packages/runtime/dist/remove-account.js
+function findAccountIndex(accounts, handle, baseUrl) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const exactIndex = accounts.findIndex((account) => handleEquals(account.handle, handle) && baseUrlEquals(account.baseUrl, normalizedBaseUrl));
+  if (exactIndex !== -1)
+    return exactIndex;
+  const matchingIndexes = accounts.map((account, index) => ({ account, index })).filter(({ account }) => handleEquals(account.handle, handle));
+  if (matchingIndexes.length === 1)
+    return matchingIndexes[0].index;
+  if (matchingIndexes.length > 1) {
+    throw new Error(`Multiple OpenPond accounts match ${handle}; select one with its base URL.`);
+  }
+  return -1;
+}
+async function removeOpenPondAccount(input) {
+  const handle = input.handle.trim();
+  if (!handle)
+    throw new Error("OpenPond account handle is required.");
+  const config = await loadGlobalConfig();
+  const accounts = (config.accounts ?? []).map((account2) => ({ ...account2 }));
+  const index = findAccountIndex(accounts, handle, input.baseUrl);
+  if (index === -1)
+    throw new Error(`OpenPond account not found: ${handle}`);
+  const account = accounts[index];
+  const activeProfile = normalizeActiveProfile(config.activeProfile);
+  if (activeProfile && accountMatchesSelector(account, activeProfile)) {
+    throw new Error("Switch to another OpenPond account before removing the active account.");
+  }
+  accounts.splice(index, 1);
+  await saveConfig({ ...config, accounts });
+  return loadOpenPondAccountContext();
+}
+
 // ../../packages/runtime/dist/update-account-config.js
-function findAccountIndex(accounts, handle, currentBaseUrl) {
+function findAccountIndex2(accounts, handle, currentBaseUrl) {
   const normalizedCurrentBaseUrl = normalizeBaseUrl(currentBaseUrl);
   const exactIndex = accounts.findIndex((account) => handleEquals(account.handle, handle) && baseUrlEquals(account.baseUrl, normalizedCurrentBaseUrl));
   if (exactIndex !== -1)
@@ -1034,7 +992,7 @@ async function updateOpenPondAccountConfig(input) {
     throw new Error("OpenPond account handle is required.");
   const config = await loadGlobalConfig();
   const accounts = (config.accounts ?? []).map((account) => ({ ...account }));
-  const index = findAccountIndex(accounts, handle, input.currentBaseUrl);
+  const index = findAccountIndex2(accounts, handle, input.currentBaseUrl);
   if (index === -1)
     throw new Error(`OpenPond account not found: ${handle}`);
   const previousAccount = accounts[index];
@@ -1113,11 +1071,13 @@ function nextLineEnd(value) {
 export {
   loadOpenPondAccountContext,
   switchOpenPondAccount,
+  loadOpenPondAccountState,
   loadOpenPondApps,
   createOpenPondRepoApp,
   loadOpenPondProviderCatalog,
   streamOpenPondHostedChatTurn,
   saveOpenPondAccount,
+  removeOpenPondAccount,
   updateOpenPondAccountConfig,
   getOpenPondAppEnvironment,
   getBundledRuntimeVersion,