openpond 0.0.30-bootstrap.0 → 0.0.30

package/dist/chunks/chunk-IUTUUNAX.js

@@ -0,0 +1,1126 @@
+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-BX4XSB2J.js";
+
+// ../../packages/runtime/dist/chat.js
+import { randomUUID } from "node:crypto";
+
+// ../../packages/runtime/dist/urls.js
+var DEFAULT_OPENPOND_API_HOST = new URL(DEFAULT_OPENPOND_API_BASE_URL).hostname;
+var DEFAULT_OPENPOND_WEB_HOST = new URL(DEFAULT_OPENPOND_WEB_BASE_URL).hostname;
+var DEFAULT_OPENPOND_OPCHAT_API_BASE_URL = `${DEFAULT_OPENPOND_API_BASE_URL}/opchat/v1`;
+function normalizeBaseUrl(value) {
+  if (!value)
+    return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed.replace(/\/+$/, "") : null;
+}
+function mapUiBaseToApiBase(baseUrl) {
+  const trimmed = normalizeBaseUrl(baseUrl);
+  if (!trimmed)
+    return null;
+  try {
+    const url = new URL(trimmed);
+    const host = url.hostname.toLowerCase();
+    if (host === DEFAULT_OPENPOND_API_HOST)
+      return DEFAULT_OPENPOND_API_BASE_URL;
+    if (host === DEFAULT_OPENPOND_WEB_HOST || host === "openpond.live" || host === "www.openpond.live") {
+      return DEFAULT_OPENPOND_API_BASE_URL;
+    }
+    if (host.startsWith("api."))
+      return trimmed;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePublicApiBaseUrl(account, config) {
+  const envBase = normalizeBaseUrl(process.env.OPENPOND_API_URL);
+  if (envBase)
+    return envBase;
+  const accountApiBase = normalizeBaseUrl(account?.apiBaseUrl);
+  if (accountApiBase)
+    return accountApiBase;
+  const configApiBase = normalizeBaseUrl(config.apiBaseUrl);
+  if (configApiBase)
+    return configApiBase;
+  const mappedEnvBase = mapUiBaseToApiBase(process.env.OPENPOND_BASE_URL);
+  if (mappedEnvBase)
+    return mappedEnvBase;
+  const mappedConfigBase = mapUiBaseToApiBase(account?.baseUrl || config.baseUrl);
+  return mappedConfigBase ?? DEFAULT_OPENPOND_API_BASE_URL;
+}
+function resolveHostedChatApiBaseUrl(account, config, publicApiBaseUrl) {
+  return resolveOpChatApiBaseUrl(account, config, publicApiBaseUrl);
+}
+function resolveOpChatApiBaseUrl(account, config, publicApiBaseUrl) {
+  const runtimeEnv = typeof process !== "undefined" ? process.env : {};
+  return normalizeOpChatApiBaseUrl(runtimeEnv.OPENPOND_OPCHAT_API_URL) ?? normalizeOpChatApiBaseUrl(account?.chatApiBaseUrl ?? config.chatApiBaseUrl) ?? normalizeOpChatApiBaseUrl(runtimeEnv.OPENPOND_CHAT_API_URL) ?? opChatBaseFromPublicApiBase(publicApiBaseUrl);
+}
+function normalizeOpChatApiBaseUrl(value) {
+  const normalized = normalizeBaseUrl(value);
+  if (!normalized)
+    return null;
+  try {
+    const url = new URL(normalized);
+    const segments = url.pathname.split("/").filter(Boolean);
+    const opChatIndex = segments.findIndex((segment) => segment.toLowerCase() === "opchat");
+    if (opChatIndex >= 0) {
+      url.pathname = `/${[...segments.slice(0, opChatIndex + 1), "v1"].join("/")}`;
+      url.search = "";
+      url.hash = "";
+      return normalizeBaseUrl(url.toString()) ?? null;
+    }
+    const v1Index = segments.findIndex((segment) => segment.toLowerCase() === "v1");
+    if (v1Index >= 0) {
+      url.pathname = "/opchat/v1";
+      url.search = "";
+      url.hash = "";
+      return normalizeBaseUrl(url.toString()) ?? null;
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/opchat/v1`.replace(/\/{2,}/g, "/");
+    url.search = "";
+    url.hash = "";
+    return normalizeBaseUrl(url.toString()) ?? null;
+  } catch {
+    return null;
+  }
+}
+function opChatBaseFromPublicApiBase(publicApiBaseUrl) {
+  return normalizeOpChatApiBaseUrl(publicApiBaseUrl) ?? DEFAULT_OPENPOND_OPCHAT_API_BASE_URL;
+}
+function deriveEnvironment(fallback) {
+  if (fallback?.trim())
+    return fallback.trim();
+  return "production";
+}
+
+// ../../packages/runtime/dist/selectors.js
+function accountToken(account) {
+  const candidates = [
+    account?.apiKey,
+    account?.session?.token,
+    account?.token
+  ];
+  for (const value of candidates) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed)
+      return trimmed;
+  }
+  return null;
+}
+function handleEquals(left, right) {
+  return Boolean(left && right && left.toLowerCase() === right.toLowerCase());
+}
+function baseUrlEquals(left, right) {
+  return normalizeBaseUrl(left) === normalizeBaseUrl(right);
+}
+function profileKey(handle, baseUrl) {
+  const normalizedHandle = handle?.trim().toLowerCase() || "";
+  return `${normalizedHandle}|${normalizeBaseUrl(baseUrl) ?? "default"}`;
+}
+function selectorBaseUrl(selector) {
+  return normalizeBaseUrl(selector?.baseUrl);
+}
+function selectorFromAccount(account) {
+  const baseUrl = normalizeBaseUrl(account.baseUrl);
+  return baseUrl ? { handle: account.handle, baseUrl } : { handle: account.handle };
+}
+function normalizeActiveProfile(value) {
+  const handle = typeof value?.handle === "string" ? value.handle.trim() : "";
+  if (!handle)
+    return null;
+  const baseUrl = normalizeBaseUrl(value?.baseUrl);
+  return baseUrl ? { handle, baseUrl } : { handle };
+}
+function accountMatchesSelector(account, selector) {
+  if (!handleEquals(account.handle, selector.handle))
+    return false;
+  const baseUrl = selectorBaseUrl(selector);
+  if (baseUrl)
+    return baseUrlEquals(account.baseUrl, baseUrl);
+  return !normalizeBaseUrl(account.baseUrl);
+}
+function profileMatchesSelector(profile, selector) {
+  if (!handleEquals(profile.handle, selector.handle))
+    return false;
+  const baseUrl = selectorBaseUrl(selector);
+  if (baseUrl)
+    return baseUrlEquals(profile.baseUrl, baseUrl);
+  return !normalizeBaseUrl(profile.baseUrl);
+}
+function findActiveAccount(config, requestedHandle, requestedBaseUrl) {
+  const accounts = Array.isArray(config.accounts) ? config.accounts : [];
+  const requestedProfile = requestedHandle || process.env.OPENPOND_ACCOUNT ? normalizeActiveProfile({
+    handle: requestedHandle || process.env.OPENPOND_ACCOUNT || "",
+    baseUrl: requestedBaseUrl ?? process.env.OPENPOND_BASE_URL ?? null
+  }) : normalizeActiveProfile(config.activeProfile);
+  if (requestedProfile) {
+    const exact = accounts.find((account) => accountMatchesSelector(account, requestedProfile));
+    if (exact)
+      return exact;
+    const sameHandle = accounts.filter((account) => handleEquals(account.handle, requestedProfile.handle));
+    if (!selectorBaseUrl(requestedProfile) && sameHandle.length === 1)
+      return sameHandle[0] ?? null;
+  }
+  if (accounts[0])
+    return accounts[0];
+  return null;
+}
+function fallbackProfilesFromConfig(config) {
+  const accounts = Array.isArray(config.accounts) ? config.accounts : [];
+  const activeProfile = normalizeActiveProfile(config.activeProfile) ?? (accounts[0] ? selectorFromAccount(accounts[0]) : null);
+  return normalizeProfiles(accounts.map((account) => ({
+    handle: account.handle,
+    baseUrl: normalizeBaseUrl(account.baseUrl),
+    apiBaseUrl: normalizeBaseUrl(account.apiBaseUrl),
+    chatApiBaseUrl: normalizeBaseUrl(account.chatApiBaseUrl),
+    environment: deriveEnvironment(account.environment),
+    isActive: activeProfile ? accountMatchesSelector(account, activeProfile) : false,
+    hasApiKey: Boolean(account.apiKey?.trim()),
+    hasSessionToken: Boolean(account.session?.token?.trim() || account.token?.trim()),
+    sessionAppId: account.session?.appId ?? null,
+    sessionConversationId: account.session?.conversationId ?? null
+  })));
+}
+function normalizeProfiles(profiles) {
+  const result = /* @__PURE__ */ new Map();
+  for (const profile of profiles) {
+    const normalizedBaseUrl = normalizeBaseUrl(profile.baseUrl);
+    const key = `${profile.handle.toLowerCase()}|${normalizedBaseUrl ?? "default"}`;
+    const normalized = {
+      ...profile,
+      baseUrl: normalizedBaseUrl,
+      apiBaseUrl: normalizeBaseUrl(profile.apiBaseUrl),
+      chatApiBaseUrl: normalizeBaseUrl(profile.chatApiBaseUrl),
+      environment: deriveEnvironment(profile.environment),
+      isActive: profile.isActive
+    };
+    const current = result.get(key);
+    if (!current || normalized.isActive && !current.isActive || normalized.hasApiKey && !current.hasApiKey) {
+      result.set(key, normalized);
+    }
+  }
+  return Array.from(result.values());
+}
+function profileAuthHealth(profile) {
+  return profile.hasApiKey || profile.hasSessionToken ? "signed_in" : "signed_out";
+}
+
+// ../../packages/runtime/dist/account-state.js
+function normalizeHealth(health, apiBaseUrl) {
+  if (!health)
+    return null;
+  return {
+    reachable: health.reachable,
+    authenticated: health.authenticated,
+    apiBase: health.apiBase || apiBaseUrl,
+    latencyMs: health.latencyMs,
+    status: health.status,
+    service: health.service,
+    checkedAt: health.checkedAt,
+    error: health.error ?? null
+  };
+}
+function normalizeProfile(response) {
+  const account = response?.account;
+  if (!account)
+    return null;
+  return {
+    id: account.id ?? null,
+    email: account.email ?? null,
+    name: account.name ?? null,
+    handle: account.handle ?? null,
+    image: account.image ?? null,
+    timezone: account.timezone ?? null,
+    isAdmin: account.isAdmin ?? null,
+    isVerified: account.isVerified ?? null,
+    dailyAgentAppId: account.dailyAgentAppId ?? null,
+    dailyAgentDeploymentId: account.dailyAgentDeploymentId ?? null,
+    credits: account.credits ?? null,
+    turnkeyWalletAddress: account.turnkeyWalletAddress ?? null,
+    turnkeyOperatingWalletAddress: account.turnkeyOperatingWalletAddress ?? null
+  };
+}
+function normalizeProducts(products) {
+  return (products ?? []).map((product) => ({
+    ...product,
+    id: product.id || product.userProductId || product.openPondProductId || product.name,
+    name: product.name,
+    type: product.type,
+    status: product.status,
+    isActive: product.isActive ?? null,
+    price: product.price ?? null,
+    currency: product.currency ?? null,
+    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 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;
+  const displayHandle = profile?.handle || account?.handle || activeSelector?.handle || null;
+  const activeProfileRow = (activeSelector ? profiles.find((candidate) => profileMatchesSelector(candidate, activeSelector)) : null) ?? profiles.find((candidate) => candidate.isActive) ?? null;
+  const healthState = authFailed ? "auth_error" : token ? "signed_in" : "signed_out";
+  const label = profile?.name || profile?.handle || profile?.email || displayHandle || "Signed out";
+  const baseUrl = normalizeBaseUrl(activeProfileRow?.baseUrl || account?.baseUrl || DEFAULT_OPENPOND_WEB_BASE_URL);
+  const environment = deriveEnvironment(activeProfileRow?.environment || account?.environment);
+  const activeProfile = normalizeActiveProfile(activeSelector) ?? (displayHandle ? normalizeActiveProfile({ handle: displayHandle, baseUrl: activeProfileRow?.baseUrl ?? account?.baseUrl }) : null);
+  const profileRows = profiles.length > 0 ? profiles : displayHandle ? [
+    {
+      handle: displayHandle,
+      baseUrl: selectorBaseUrl(activeProfile) ?? normalizeBaseUrl(account?.baseUrl),
+      apiBaseUrl,
+      chatApiBaseUrl,
+      environment,
+      isActive: true,
+      hasApiKey: Boolean(token),
+      hasSessionToken: false,
+      sessionAppId: null,
+      sessionConversationId: null
+    }
+  ] : [];
+  const visibleProfileRows = profileRows.filter((candidate) => !isEmptyDefaultProfile(candidate));
+  return {
+    state: healthState,
+    activeProfile,
+    label,
+    email: profile?.email ?? null,
+    avatarUrl: profile?.image ?? null,
+    environment,
+    baseUrl,
+    apiBaseUrl,
+    chatApiBaseUrl,
+    balanceLabel: balanceResponse?.balanceLabel ?? "$0.00",
+    balance,
+    creditsLabel: profile?.credits ?? null,
+    profile,
+    products: normalizeProducts(accountResponse?.products),
+    apiHealth: normalizeHealth(health ?? null, apiBaseUrl),
+    accounts: visibleProfileRows.map((candidate) => {
+      const candidateBaseUrl = normalizeBaseUrl(candidate.baseUrl);
+      const profileLookup = accountProfiles?.[profileKey(candidate.handle, candidateBaseUrl)] ?? null;
+      const candidateProfile = normalizeProfile(profileLookup?.response ?? null);
+      return {
+        handle: candidate.handle,
+        baseUrl: candidateBaseUrl,
+        apiBaseUrl: normalizeBaseUrl(candidate.apiBaseUrl),
+        chatApiBaseUrl: normalizeBaseUrl(candidate.chatApiBaseUrl),
+        environment: deriveEnvironment(candidate.environment),
+        isActive: activeProfile ? profileMatchesSelector(candidate, activeProfile) : false,
+        authHealth: profileLookup?.authFailed ? "auth_error" : profileAuthHealth(candidate),
+        displayLabel: candidateProfile?.name || candidateProfile?.handle || candidateProfile?.email || candidate.handle,
+        email: candidateProfile?.email ?? null,
+        avatarUrl: candidateProfile?.image ?? null
+      };
+    }),
+    error: error ?? health?.error ?? null
+  };
+}
+
+// ../../packages/runtime/dist/config.js
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function readRawOpenPondConfig() {
+  try {
+    const raw = JSON.parse(readFileSync(join(homedir(), ".openpond", "config.json"), "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function mergeRawApiBaseConfig(config) {
+  const raw = readRawOpenPondConfig();
+  const rawAccounts = Array.isArray(raw.accounts) ? raw.accounts : [];
+  const accounts = Array.isArray(config.accounts) ? config.accounts : [];
+  return {
+    ...config,
+    activeProfile: config.activeProfile ?? raw.activeProfile,
+    apiBaseUrl: config.apiBaseUrl ?? raw.apiBaseUrl,
+    chatApiBaseUrl: config.chatApiBaseUrl ?? raw.chatApiBaseUrl,
+    accounts: accounts.map((account) => {
+      const rawAccount = rawAccounts.find((candidate) => handleEquals(candidate.handle, account.handle) && baseUrlEquals(candidate.baseUrl, account.baseUrl)) ?? rawAccounts.find((candidate) => handleEquals(candidate.handle, account.handle));
+      return {
+        ...account,
+        ...typeof rawAccount?.apiBaseUrl === "string" && rawAccount.apiBaseUrl.trim() ? { apiBaseUrl: rawAccount.apiBaseUrl } : {},
+        ...typeof rawAccount?.chatApiBaseUrl === "string" && rawAccount.chatApiBaseUrl.trim() ? { chatApiBaseUrl: rawAccount.chatApiBaseUrl } : {}
+      };
+    })
+  };
+}
+
+// ../../packages/runtime/dist/account-context.js
+async function loadProfiles(config) {
+  try {
+    return normalizeProfiles(await listConfiguredProfiles());
+  } catch {
+    return fallbackProfilesFromConfig(config);
+  }
+}
+async function loadOpenPondAccountContext(requestedHandle, requestedBaseUrl) {
+  const config = mergeRawApiBaseConfig(await loadGlobalConfig().catch(() => ({})));
+  const profiles = await loadProfiles(config);
+  const account = findActiveAccount(config, requestedHandle, requestedBaseUrl);
+  const token = accountToken(account);
+  const apiBaseUrl = resolvePublicApiBaseUrl(account, config);
+  const chatApiBaseUrl = resolveHostedChatApiBaseUrl(account, config, apiBaseUrl);
+  return {
+    config,
+    profiles,
+    account,
+    token,
+    apiBaseUrl,
+    chatApiBaseUrl,
+    accountState: toAccountState({ config, profiles, account, token, apiBaseUrl })
+  };
+}
+async function switchOpenPondAccount(input) {
+  const baseUrl = normalizeBaseUrl(input.baseUrl);
+  await setActiveProfile(input.handle, {
+    baseUrl
+  });
+  return loadOpenPondAccountContext(input.handle, baseUrl);
+}
+
+// ../../packages/runtime/dist/errors.js
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../../packages/runtime/dist/chat.js
+var PROVIDER_CATALOG_FETCH_TIMEOUT_MS = 2500;
+async function loadOpenPondProviderCatalog() {
+  const context = await loadOpenPondAccountContext();
+  if (!context.token) {
+    return {
+      catalog: null,
+      error: "No OpenPond API key or session token is configured."
+    };
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort(new Error("OpenPond provider catalog request timed out."));
+  }, PROVIDER_CATALOG_FETCH_TIMEOUT_MS);
+  try {
+    const catalog = await listOpChatProviderCatalog({
+      apiBaseUrl: context.chatApiBaseUrl,
+      token: context.token,
+      signal: controller.signal
+    });
+    return {
+      catalog,
+      error: null
+    };
+  } catch (error) {
+    return {
+      catalog: null,
+      error: errorMessage(error)
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function* streamOpenPondHostedChatTurn(input) {
+  const context = await loadOpenPondAccountContext();
+  if (!context.token) {
+    throw new Error("OpenPond is signed out. Add an account in Settings before using OpenPond Chat.");
+  }
+  yield* streamOpChatChatCompletion({
+    apiBaseUrl: context.chatApiBaseUrl,
+    token: context.token,
+    model: input.model || DEFAULT_OPENPOND_CHAT_MODEL,
+    messages: input.messages,
+    tools: input.tools,
+    toolChoice: input.toolChoice,
+    requestId: input.requestId,
+    signal: input.signal
+  });
+}
+async function listOpChatProviderCatalog(options) {
+  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "provider-catalog"), {
+    method: "GET",
+    headers: opChatHeaders(options.token, "application/json"),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(`OpenPond OpChat provider catalog failed: ${response.status} ${await readOpChatError(response)}`);
+  }
+  return ProviderCatalogSchema.parse(await response.json());
+}
+async function* streamOpChatChatCompletion(options) {
+  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "chat/completions"), {
+    method: "POST",
+    headers: opChatHeaders(options.token, "text/event-stream", options.requestId),
+    body: JSON.stringify(buildOpChatBody(options)),
+    signal: options.signal
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`OpenPond OpChat stream 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;
+    }
+  }
+  if (hasToolCalls && reasoningText) {
+    yield {
+      type: "continuation",
+      continuation: {
+        kind: "chat_completions_reasoning",
+        reasoningContent: reasoningText
+      },
+      raw: latestRaw
+    };
+  }
+  if (pendingFinish)
+    yield pendingFinish;
+}
+function buildOpChatBody(options) {
+  const body = {
+    model: options.model,
+    messages: options.messages.map(opChatMessage),
+    stream: true
+  };
+  if (options.tools) {
+    body.tools = options.tools;
+  }
+  if (options.toolChoice !== void 0) {
+    body.tool_choice = options.toolChoice;
+  }
+  return body;
+}
+function opChatMessage(message) {
+  const { continuation, ...projected } = message;
+  if (message.role === "assistant" && continuation?.kind === "chat_completions_reasoning") {
+    return {
+      ...projected,
+      reasoning_content: continuation.reasoningContent
+    };
+  }
+  return projected;
+}
+function opChatEndpointUrl(apiBaseUrl, path) {
+  const normalized = apiBaseUrl.trim().replace(/\/+$/, "");
+  if (!normalized)
+    throw new Error("OpenPond OpChat API base URL is required.");
+  return `${normalized}/${path}`;
+}
+function opChatHeaders(token, accept, requestId) {
+  const trimmed = token.trim();
+  if (!trimmed)
+    throw new Error("OpenPond API key is required for OpChat.");
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${trimmed}`);
+  headers.set("Content-Type", "application/json");
+  headers.set("Accept", accept);
+  headers.set("x-openpond-client", "openpond-app");
+  headers.set("x-openpond-request-id", requestId || randomUUID());
+  return headers;
+}
+async function readOpChatError(response) {
+  const text = await response.text().catch(() => "");
+  if (!text)
+    return response.statusText || `HTTP ${response.status}`;
+  try {
+    return errorMessageFromPayload(JSON.parse(text));
+  } catch {
+    return text;
+  }
+}
+function errorMessageFromPayload(payload) {
+  if (!payload || typeof payload !== "object")
+    return String(payload || "unknown_error");
+  const record = payload;
+  const error = record.error;
+  if (error && typeof error === "object") {
+    const errorRecord = error;
+    return [
+      stringValue(errorRecord.code),
+      stringValue(errorRecord.type),
+      stringValue(errorRecord.message)
+    ].filter(Boolean).join(": ");
+  }
+  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") : [];
+}
+function parseUsage(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const usage = raw.usage;
+  if (!usage || typeof usage !== "object")
+    return null;
+  return usage;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+// ../../packages/runtime/dist/version.js
+import { readFileSync as readFileSync2 } from "node:fs";
+var bundledRuntimeVersion;
+function getBundledRuntimeVersion() {
+  if (bundledRuntimeVersion !== void 0)
+    return bundledRuntimeVersion ?? "openpond-code bundled";
+  try {
+    const packageJsonUrl = new URL("../package.json", import.meta.resolve("openpond"));
+    const packageJson = JSON.parse(readFileSync2(packageJsonUrl, "utf8"));
+    bundledRuntimeVersion = typeof packageJson.version === "string" ? `openpond-code@${packageJson.version}` : null;
+  } catch {
+    bundledRuntimeVersion = null;
+  }
+  return bundledRuntimeVersion ?? "openpond-code bundled";
+}
+
+// ../../packages/runtime/dist/system-browser.js
+import { spawn } from "node:child_process";
+function resolveSystemBrowserCommand(url, platform = process.platform) {
+  if (platform === "darwin")
+    return { command: "open", args: [url] };
+  if (platform === "win32") {
+    return {
+      command: "rundll32.exe",
+      args: ["url.dll,FileProtocolHandler", url]
+    };
+  }
+  return { command: "xdg-open", args: [url] };
+}
+async function openUrlWithSystemBrowser(url, options = {}) {
+  const browser = options.command ?? resolveSystemBrowserCommand(url);
+  const handoffTimeoutMs = options.handoffTimeoutMs ?? 1500;
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      resolve(result);
+    };
+    const child = spawn(browser.command, browser.args, {
+      detached: false,
+      shell: false,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.once("error", (error) => {
+      const code = error.code;
+      finish({
+        opened: false,
+        error: code ? `browser launcher ${browser.command} failed (${code})` : `browser launcher ${browser.command} failed`
+      });
+    });
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        finish({ opened: true });
+        return;
+      }
+      const detail = signal ? `signal ${signal}` : `code ${code ?? "unknown"}`;
+      finish({ opened: false, error: `browser launcher ${browser.command} exited with ${detail}` });
+    });
+    timer = setTimeout(() => {
+      child.unref();
+      finish({ opened: true });
+    }, handoffTimeoutMs);
+    timer.unref();
+  });
+}
+
+// ../../packages/runtime/dist/apps.js
+function normalizeApp(input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const item = input;
+  const id = typeof item.id === "string" ? item.id : null;
+  const name = typeof item.name === "string" ? item.name : id;
+  if (!id || !name)
+    return null;
+  const deployment = item.latestDeployment && typeof item.latestDeployment === "object" ? item.latestDeployment : null;
+  const registryResult = SandboxAppActionRegistrySchema.safeParse(item.sandboxActionRegistry);
+  return {
+    id,
+    name,
+    description: typeof item.description === "string" ? item.description : null,
+    visibility: typeof item.visibility === "string" ? item.visibility : null,
+    gitOwner: typeof item.gitOwner === "string" ? item.gitOwner : null,
+    gitRepo: typeof item.gitRepo === "string" ? item.gitRepo : null,
+    gitHost: typeof item.gitHost === "string" ? item.gitHost : null,
+    defaultBranch: typeof item.defaultBranch === "string" ? item.defaultBranch : null,
+    sandbox: item.sandbox === true,
+    sandboxActionRegistry: registryResult.success ? registryResult.data : null,
+    sandboxManifestHash: typeof item.sandboxManifestHash === "string" ? item.sandboxManifestHash : null,
+    sandboxManifestPath: typeof item.sandboxManifestPath === "string" ? item.sandboxManifestPath : null,
+    sandboxManifestSyncedAt: typeof item.sandboxManifestSyncedAt === "string" ? item.sandboxManifestSyncedAt : item.sandboxManifestSyncedAt instanceof Date ? item.sandboxManifestSyncedAt.toISOString() : null,
+    sandboxManifestError: typeof item.sandboxManifestError === "string" ? item.sandboxManifestError : null,
+    updatedAt: typeof item.updatedAt === "string" ? item.updatedAt : null,
+    latestDeployment: deployment ? {
+      id: typeof deployment.id === "string" ? deployment.id : void 0,
+      status: typeof deployment.status === "string" ? deployment.status : void 0,
+      deploymentDomain: typeof deployment.deploymentDomain === "string" ? deployment.deploymentDomain : null,
+      createdAt: typeof deployment.createdAt === "string" ? deployment.createdAt : void 0,
+      isProduction: typeof deployment.isProduction === "boolean" ? deployment.isProduction : null,
+      gitBranch: typeof deployment.gitBranch === "string" ? deployment.gitBranch : null
+    } : null,
+    scheduleSummary: normalizeScheduleSummary(item.scheduleSummary)
+  };
+}
+function normalizeDateString(value) {
+  if (typeof value === "string")
+    return value;
+  if (value instanceof Date)
+    return value.toISOString();
+  return null;
+}
+function normalizeSchedule(input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const item = input;
+  const id = typeof item.id === "string" ? item.id : null;
+  const name = typeof item.name === "string" ? item.name : id;
+  const deploymentId = typeof item.deploymentId === "string" ? item.deploymentId : null;
+  if (!id || !name || !deploymentId)
+    return null;
+  return {
+    id,
+    name,
+    description: typeof item.description === "string" ? item.description : null,
+    scheduleType: typeof item.scheduleType === "string" ? item.scheduleType : "cron",
+    scheduleExpression: typeof item.scheduleExpression === "string" ? item.scheduleExpression : "",
+    enabled: Boolean(item.enabled),
+    rawEnabled: typeof item.rawEnabled === "boolean" ? item.rawEnabled : void 0,
+    syncStatus: typeof item.syncStatus === "string" ? item.syncStatus : null,
+    syncError: typeof item.syncError === "string" ? item.syncError : null,
+    startAt: normalizeDateString(item.startAt),
+    endAt: normalizeDateString(item.endAt),
+    maxRuns: typeof item.maxRuns === "number" ? item.maxRuns : null,
+    executionCount: typeof item.executionCount === "number" ? item.executionCount : null,
+    lifecycleStatus: typeof item.lifecycleStatus === "string" ? item.lifecycleStatus : null,
+    lifecycleReason: typeof item.lifecycleReason === "string" ? item.lifecycleReason : null,
+    lastExecutionAt: normalizeDateString(item.lastExecutionAt),
+    lastExecutionStatus: typeof item.lastExecutionStatus === "string" ? item.lastExecutionStatus : null,
+    lastRunNowAt: normalizeDateString(item.lastRunNowAt),
+    lastRunNowStatus: typeof item.lastRunNowStatus === "string" ? item.lastRunNowStatus : null,
+    updatedAt: normalizeDateString(item.updatedAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
+    deploymentId,
+    isProduction: typeof item.isProduction === "boolean" ? item.isProduction : void 0,
+    payload: item.payload
+  };
+}
+function normalizeScheduleSummary(input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const item = input;
+  const schedules = Array.isArray(item.schedules) ? item.schedules.map(normalizeSchedule).filter((value) => Boolean(value)) : [];
+  const total = typeof item.total === "number" ? item.total : schedules.length;
+  const active = typeof item.active === "number" ? item.active : schedules.filter((schedule) => schedule.enabled).length;
+  const paused = typeof item.paused === "number" ? item.paused : Math.max(0, total - active);
+  return {
+    total,
+    active,
+    paused,
+    enabled: typeof item.enabled === "number" ? item.enabled : active,
+    disabled: typeof item.disabled === "number" ? item.disabled : paused,
+    nextRunAt: normalizeDateString(item.nextRunAt),
+    lastRunAt: normalizeDateString(item.lastRunAt),
+    schedules,
+    truncated: typeof item.truncated === "boolean" ? item.truncated : void 0
+  };
+}
+async function loadAccountProfileLookups(context) {
+  const accounts = Array.isArray(context.config.accounts) ? context.config.accounts : [];
+  const entries = await Promise.all(accounts.map(async (account) => {
+    const key = profileKey(account.handle, account.baseUrl);
+    const token = accountToken(account);
+    if (!token) {
+      return [key, { response: null, authFailed: false }];
+    }
+    try {
+      return [
+        key,
+        {
+          response: await getOpenPondAccount(resolvePublicApiBaseUrl(account, context.config), token),
+          authFailed: false
+        }
+      ];
+    } catch {
+      return [key, { response: null, authFailed: true }];
+    }
+  }));
+  return Object.fromEntries(entries);
+}
+async function loadOpenPondApps(options = {}) {
+  const context = await loadOpenPondAccountContext();
+  if (!context.token) {
+    const accountProfiles2 = await loadAccountProfileLookups(context);
+    return {
+      account: toAccountState({ ...context, accountProfiles: accountProfiles2 }),
+      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),
+    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;
+  return {
+    account: toAccountState({
+      ...context,
+      accountResponse,
+      balanceResponse,
+      accountProfiles,
+      health: effectiveHealth,
+      authFailed: Boolean(authError),
+      error: authError ?? profileError,
+      balanceError: balanceResult.status === "rejected" ? errorMessage(balanceResult.reason) : null
+    }),
+    apps: appsResult.status === "fulfilled" ? appsResult.value.map(normalizeApp).filter((value) => Boolean(value)) : [],
+    error: appsError
+  };
+}
+async function createOpenPondRepoApp(input) {
+  const context = await loadOpenPondAccountContext();
+  if (!context.token) {
+    throw new Error("No OpenPond API key or session token is configured.");
+  }
+  return {
+    account: context,
+    response: await createRepo(context.apiBaseUrl, context.token, input)
+  };
+}
+
+// ../../packages/runtime/dist/save-account.js
+import { createHash } from "node:crypto";
+function fallbackHandleForApiKey(apiKey) {
+  const digest = createHash("sha256").update(apiKey).digest("hex").slice(0, 8);
+  return `account-${digest}`;
+}
+function normalizeDerivedHandle(value) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return null;
+  return trimmed.replace(/^@/, "");
+}
+async function deriveHandleForApiKey(input, apiBaseUrl) {
+  const explicit = normalizeDerivedHandle(input.handle);
+  if (explicit)
+    return explicit;
+  try {
+    const response = await getOpenPondAccount(apiBaseUrl, input.apiKey);
+    const account = response.account;
+    const fromProfile = normalizeDerivedHandle(account.handle) ?? normalizeDerivedHandle(account.email?.split("@")[0]) ?? normalizeDerivedHandle(account.id);
+    if (fromProfile)
+      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) {
+  const baseUrl = input.baseUrl ?? DEFAULT_OPENPOND_WEB_BASE_URL;
+  const apiBaseUrl = normalizeBaseUrl(input.apiBaseUrl) ?? mapUiBaseToApiBase(baseUrl) ?? DEFAULT_OPENPOND_API_BASE_URL;
+  const chatApiBaseUrl = normalizeBaseUrl(input.chatApiBaseUrl);
+  const handle = await deriveHandleForApiKey(input, apiBaseUrl);
+  await saveProfileApiKey({
+    handle,
+    apiKey: input.apiKey,
+    baseUrl,
+    apiBaseUrl,
+    chatApiBaseUrl,
+    environment: input.environment ?? "production",
+    setActive: input.setActive
+  });
+  return loadOpenPondAccountContext(handle, baseUrl);
+}
+
+// ../../packages/runtime/dist/update-account-config.js
+function findAccountIndex(accounts, handle, currentBaseUrl) {
+  const normalizedCurrentBaseUrl = normalizeBaseUrl(currentBaseUrl);
+  const exactIndex = accounts.findIndex((account) => handleEquals(account.handle, handle) && baseUrlEquals(account.baseUrl, normalizedCurrentBaseUrl));
+  if (exactIndex !== -1)
+    return exactIndex;
+  const sameHandle = accounts.map((account, index) => ({ account, index })).filter(({ account }) => handleEquals(account.handle, handle));
+  if (sameHandle.length === 1)
+    return sameHandle[0].index;
+  if (sameHandle.length > 1) {
+    throw new Error(`Multiple OpenPond accounts match ${handle}; select one with its current base URL.`);
+  }
+  return -1;
+}
+function applyOptionalUrl(account, key, value) {
+  if (value === void 0)
+    return;
+  const normalized = normalizeBaseUrl(value);
+  if (normalized) {
+    account[key] = normalized;
+    return;
+  }
+  if (value === null || value.trim() === "")
+    delete account[key];
+}
+async function updateOpenPondAccountConfig(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((account) => ({ ...account }));
+  const index = findAccountIndex(accounts, handle, input.currentBaseUrl);
+  if (index === -1)
+    throw new Error(`OpenPond account not found: ${handle}`);
+  const previousAccount = accounts[index];
+  const nextAccount = { ...previousAccount };
+  applyOptionalUrl(nextAccount, "baseUrl", input.baseUrl);
+  applyOptionalUrl(nextAccount, "apiBaseUrl", input.apiBaseUrl);
+  applyOptionalUrl(nextAccount, "chatApiBaseUrl", input.chatApiBaseUrl);
+  if (input.environment === null) {
+    delete nextAccount.environment;
+  } else if (typeof input.environment === "string" && input.environment.trim()) {
+    nextAccount.environment = input.environment.trim();
+  }
+  const duplicateIndex = accounts.findIndex((account, candidateIndex) => candidateIndex !== index && handleEquals(account.handle, nextAccount.handle) && baseUrlEquals(account.baseUrl, nextAccount.baseUrl));
+  if (duplicateIndex !== -1) {
+    throw new Error("Another OpenPond account already uses that handle and base URL.");
+  }
+  const activeProfile = normalizeActiveProfile(config.activeProfile);
+  const wasActive = Boolean(activeProfile && accountMatchesSelector(previousAccount, activeProfile));
+  accounts[index] = nextAccount;
+  await saveConfig({
+    ...config,
+    accounts,
+    activeProfile: input.setActive || wasActive ? selectorFromAccount(nextAccount) : config.activeProfile
+  });
+  return loadOpenPondAccountContext(nextAccount.handle, nextAccount.baseUrl);
+}
+
+// ../../packages/runtime/dist/actions.js
+async function getOpenPondAppEnvironment(input) {
+  const context = await loadOpenPondAccountContext();
+  if (!context.token) {
+    throw new Error("OpenPond is signed out. Add an account before reading app config.");
+  }
+  return getAppEnvironment(context.apiBaseUrl, context.token, input.appId);
+}
+
+// ../../packages/runtime/dist/ready-line-parser.js
+function createReadyLineParser(prefix, onReady) {
+  let buffer = "";
+  const processLine = (line) => {
+    if (!line.startsWith(prefix))
+      return;
+    onReady(JSON.parse(line.slice(prefix.length)));
+  };
+  return {
+    push(chunk) {
+      buffer += chunk;
+      while (true) {
+        const lineEnd = nextLineEnd(buffer);
+        if (lineEnd < 0)
+          return;
+        const line = buffer.slice(0, lineEnd).replace(/\r$/, "");
+        const newlineLength = buffer[lineEnd] === "\r" && buffer[lineEnd + 1] === "\n" ? 2 : 1;
+        buffer = buffer.slice(lineEnd + newlineLength);
+        processLine(line);
+      }
+    },
+    flush() {
+      const line = buffer.trimEnd();
+      buffer = "";
+      if (line)
+        processLine(line);
+    }
+  };
+}
+function nextLineEnd(value) {
+  const lf = value.indexOf("\n");
+  const cr = value.indexOf("\r");
+  if (lf < 0)
+    return cr;
+  if (cr < 0)
+    return lf;
+  return Math.min(lf, cr);
+}
+
+export {
+  loadOpenPondAccountContext,
+  switchOpenPondAccount,
+  loadOpenPondApps,
+  createOpenPondRepoApp,
+  loadOpenPondProviderCatalog,
+  streamOpenPondHostedChatTurn,
+  saveOpenPondAccount,
+  updateOpenPondAccountConfig,
+  getOpenPondAppEnvironment,
+  getBundledRuntimeVersion,
+  createReadyLineParser,
+  openUrlWithSystemBrowser
+};