openpond 0.0.38 → 0.0.39

package/dist/chunks/{chunk-AHPQTEIJ.js → chunk-4N6E3OVF.js}

@@ -15,7 +15,7 @@ import {
   resolveRepoUrl,
   runCommand,
   warnOnRepoHostMismatch
-} from "./chunk-275WCETC.js";
+} from "./chunk-FCVVOMIP.js";
 import {
   normalizeTemplateRepoUrl,
   resolveApiBaseUrlOption,
@@ -23,12 +23,12 @@ import {
   resolveBaseUrlOption,
   resolveChatApiBaseUrlOption,
   resolvePublicApiBaseUrl
-} from "./chunk-GDZYDLEL.js";
+} from "./chunk-SMNFI2FU.js";
 import {
   compareSemver,
   fetchLatestNpmVersion,
   getInstalledCliVersion
-} from "./chunk-XCATKTK3.js";
+} from "./chunk-3CDPPVLE.js";
 import {
   checkOpenPondApiHealth,
   createHeadlessApps,
@@ -45,7 +45,7 @@ import {
   saveProfileApiKey,
   setActiveProfile,
   submitBacktestRun
-} from "./chunk-ZI4GDAUB.js";
+} from "./chunk-DBHSOTYZ.js";
 import {
   parseBooleanOption,
   parseJsonOption,

package/dist/chunks/{chunk-YTJL6XPU.js → chunk-6V7MJVRO.js}

@@ -1,13 +1,16 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  DEFAULT_HOST,
-  DEFAULT_PORT,
-  parseListen
-} from "./chunk-HS2AGRDV.js";
+  runAppServerJsonl
+} from "./chunk-VCVQLECH.js";
 import {
   getBundledRuntimeVersion,
   openUrlWithSystemBrowser
-} from "./chunk-QRM7XMAO.js";
+} from "./chunk-BQQZNGI6.js";
+import {
+  DEFAULT_HOST,
+  DEFAULT_PORT,
+  parseListen
+} from "./chunk-JJPAMKXZ.js";
 
 // ../server/src/cli.ts
 import { existsSync } from "node:fs";
@@ -31,20 +34,22 @@ function parseCliArgs(args) {
   let webRoot = null;
   let openBrowser = false;
   let printAccessUrl = false;
+  let storeDir = null;
   let index = 0;
   const command = args[0];
   if (command && !command.startsWith("-")) {
     if (command === "serve" || command === "server") mode = "serve";
+    else if (command === "app-server") mode = "app-server";
     else if (command === "web") mode = "web";
     else if (command === "help") {
-      return { mode, host, port, webRoot, openBrowser, printAccessUrl, help: true };
+      return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, help: true };
     } else throw new Error(`Unknown command: ${command}`);
     index = 1;
   }
   for (let i = index; i < args.length; i += 1) {
     const arg = args[i];
     if (arg === "--help" || arg === "-h") {
-      return { mode, host, port, webRoot, openBrowser, printAccessUrl, help: true };
+      return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, help: true };
     }
     if (arg === "--listen") {
       const listen = parseListen(requireValue(args, i, arg));
@@ -60,6 +65,9 @@ function parseCliArgs(args) {
     } else if (arg === "--web-root") {
       webRoot = path.resolve(requireValue(args, i, arg));
       i += 1;
+    } else if (arg === "--store-dir") {
+      storeDir = path.resolve(requireValue(args, i, arg));
+      i += 1;
     } else if (arg === "--open-browser") {
       openBrowser = true;
     } else if (arg === "--print-access-url") {
@@ -74,7 +82,7 @@ function parseCliArgs(args) {
   if (mode !== "web" && (openBrowser || printAccessUrl)) {
     throw new Error("Browser options are only available in web mode.");
   }
-  return { mode, host, port, webRoot, openBrowser, printAccessUrl, help: false };
+  return { mode, host, port, webRoot, openBrowser, printAccessUrl, storeDir, help: false };
 }
 function defaultWebRootCandidates() {
   return [
@@ -128,6 +136,7 @@ async function resolveWebLaunchMessages(input, handOffToBrowser = openUrlWithSys
 function printHelp() {
   console.log(`Usage:
   openpond-app-server serve [--hostname HOST] [--port PORT]
+  openpond-app-server app-server [--store-dir DIR]
   openpond-app-server web [--hostname HOST] [--port PORT] [--web-root DIR]
 
 Options:
@@ -135,11 +144,12 @@ Options:
   --hostname HOST        Bind host (default ${DEFAULT_HOST})
   --port PORT            Bind port, or 0 for any free port (default ${DEFAULT_PORT})
   --web-root DIR         Directory containing the built web UI for web mode
+  --store-dir DIR        Local app-server state directory
   --open-browser         Open the authenticated web URL in the system browser
   --print-access-url     Print the authenticated URL instead of opening it
 `);
 }
-async function runOpenPondServerCli(createOpenPondServer) {
+async function runOpenPondServerCli(factories) {
   const args = parseCliArgs(process.argv.slice(2));
   if (args.help) {
     printHelp();
@@ -149,7 +159,17 @@ async function runOpenPondServerCli(createOpenPondServer) {
   if (args.mode === "web" && !webRoot) {
     throw new Error("Could not find a built OpenPond web UI. Run `pnpm build:web` or pass --web-root.");
   }
-  const instance = await createOpenPondServer({ host: args.host, port: args.port, webRoot });
+  if (args.mode === "app-server") {
+    await runAgentServer(factories.createOpenPondAppServer, args.storeDir);
+    return;
+  }
+  const instance = await factories.createOpenPondServer({
+    host: args.host,
+    port: args.port,
+    webRoot,
+    ...args.storeDir ? { storeDir: args.storeDir } : {},
+    httpEnabled: true
+  });
   const webBaseUrl = args.mode === "web" ? browserBaseUrl(instance) : null;
   console.log(
     `OPENPOND_APP_SERVER_READY ${JSON.stringify({
@@ -186,8 +206,33 @@ async function runOpenPondServerCli(createOpenPondServer) {
   await new Promise(() => {
   });
 }
+async function runOpenPondAppServerCli(createOpenPondAppServer) {
+  const rawArgs = process.argv.slice(2);
+  const args = parseCliArgs(
+    !rawArgs[0] || rawArgs[0].startsWith("-") ? ["app-server", ...rawArgs] : rawArgs
+  );
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.mode !== "app-server") {
+    throw new Error("The app-server entrypoint only accepts the app-server command.");
+  }
+  await runAgentServer(createOpenPondAppServer, args.storeDir);
+}
+async function runAgentServer(createOpenPondAppServer, storeDir) {
+  const appServer = await createOpenPondAppServer({
+    ...storeDir ? { storeDir } : {}
+  });
+  await runAppServerJsonl({
+    appServer,
+    readable: process.stdin,
+    writable: process.stdout
+  });
+}
 
 export {
   resolveWebLaunchMessages,
-  runOpenPondServerCli
+  runOpenPondServerCli,
+  runOpenPondAppServerCli
 };

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

@@ -1,11 +1,8 @@
 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,
@@ -15,7 +12,12 @@ import {
   saveConfig,
   saveProfileApiKey,
   setActiveProfile
-} from "./chunk-LZZM3IHS.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";
@@ -78,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) {
@@ -406,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) {
@@ -451,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) {
@@ -466,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;
@@ -523,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") {
@@ -541,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.");
@@ -551,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(() => "");
@@ -578,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") : [];
 }
@@ -658,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";
@@ -837,71 +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, appsResult, accountProfilesResult] = await Promise.allSettled([
-    checkOpenPondApiHealth(context.apiBaseUrl, context.token),
-    getOpenPondAccount(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 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,
-      accountProfiles,
-      health: effectiveHealth,
-      authFailed: Boolean(authError),
-      error: authError ?? profileError
-    }),
+    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) {
@@ -939,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) {
@@ -972,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)
@@ -1003,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];
@@ -1082,11 +1071,13 @@ function nextLineEnd(value) {
 export {
   loadOpenPondAccountContext,
   switchOpenPondAccount,
+  loadOpenPondAccountState,
   loadOpenPondApps,
   createOpenPondRepoApp,
   loadOpenPondProviderCatalog,
   streamOpenPondHostedChatTurn,
   saveOpenPondAccount,
+  removeOpenPondAccount,
   updateOpenPondAccountConfig,
   getOpenPondAppEnvironment,
   getBundledRuntimeVersion,