openpond 0.1.1 → 0.2.1

package/dist/chunks/chunk-EFET7LB7.js

@@ -1,1331 +0,0 @@
-import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
-import {
-  DEFAULT_OPENPOND_CHAT_MODEL,
-  ProviderCatalogSchema,
-  SandboxAppActionRegistrySchema,
-  createRepo,
-  getAppEnvironment,
-  getOpenPondAccount,
-  listApps,
-  listConfiguredProfiles,
-  loadGlobalConfig,
-  saveConfig,
-  saveProfileApiKey,
-  setActiveProfile
-} from "./chunk-6G6MDZLM.js";
-import {
-  DEFAULT_OPENPOND_API_BASE_URL,
-  DEFAULT_OPENPOND_WEB_BASE_URL
-} from "./chunk-JTHL5XJ2.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, env = process.env) {
-  const candidates = [
-    account?.apiKey,
-    account?.session?.token,
-    account?.token,
-    env.OPENPOND_API_KEY
-  ];
-  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 (sameHandle.length === 1)
-      return sameHandle[0] ?? null;
-    return 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
-  };
-}
-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 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, accountProfiles, health, authFailed, error } = input;
-  const chatApiBaseUrl = resolveHostedChatApiBaseUrl(account, config, apiBaseUrl);
-  const profile = normalizeProfile(accountResponse ?? null);
-  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,
-    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 = 15e3;
-function displayNameForHostedModel(id) {
-  if (id === DEFAULT_OPENPOND_CHAT_MODEL)
-    return "OpenPond Chat";
-  if (id === "deepseek-v4-flash")
-    return "DeepSeek V4 Flash";
-  return id.replace(/[-_/]+/g, " ");
-}
-function normalizeHostedModel(model) {
-  const id = typeof model.id === "string" ? model.id : null;
-  if (!id)
-    return null;
-  return {
-    id,
-    displayName: displayNameForHostedModel(id),
-    ownedBy: typeof model.owned_by === "string" ? model.owned_by : null,
-    streaming: true,
-    raw: model
-  };
-}
-async function loadOpenPondHostedModels() {
-  const context = await loadOpenPondAccountContext();
-  if (!context.token) {
-    return {
-      models: [],
-      error: "No OpenPond API key or session token is configured."
-    };
-  }
-  try {
-    const result = await listOpChatModels({
-      apiBaseUrl: context.chatApiBaseUrl,
-      token: context.token
-    });
-    const models = result.data.map((model) => normalizeHostedModel(model)).filter((value) => Boolean(value));
-    return {
-      models,
-      error: null
-    };
-  } catch (error) {
-    return {
-      models: [],
-      error: errorMessage(error)
-    };
-  }
-}
-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,
-    reasoningEffort: input.reasoningEffort,
-    maxTokens: input.maxTokens,
-    temperature: input.temperature,
-    topP: input.topP,
-    signal: input.signal
-  });
-}
-async function listOpChatModels(options) {
-  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "models");
-  const response = await fetch(requestUrl, {
-    method: "GET",
-    headers: opChatHeaders(options.token, "application/json"),
-    signal: options.signal
-  });
-  if (!response.ok) {
-    throw new Error(`OpenPond OpChat model list failed: ${response.status} ${await readOpChatError(response)}`);
-  }
-  return await response.json();
-}
-async function listOpChatProviderCatalog(options) {
-  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "provider-catalog");
-  const response = await fetch(requestUrl, {
-    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 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, true)),
-    signal: options.signal
-  });
-  if (!response.ok) {
-    throw new Error(`OpenPond OpChat request failed: ${response.status} ${await readOpChatError(response)}`);
-  }
-  if (!response.body) {
-    throw new Error("OpenPond OpChat request failed: streaming response body is missing.");
-  }
-  const toolCalls = /* @__PURE__ */ new Map();
-  let sawDone = false;
-  let finishReason = null;
-  let lastPayload = {};
-  let accumulatedReasoning = "";
-  let usage = null;
-  const responseHeaderUsage = cacheUsageFromResponseHeaders(response.headers);
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let dataLines = [];
-  const consumeEvent = () => {
-    if (dataLines.length === 0)
-      return [];
-    const data = dataLines.join("\n");
-    dataLines = [];
-    if (data === "[DONE]") {
-      sawDone = true;
-      return [];
-    }
-    let payload;
-    try {
-      payload = JSON.parse(data);
-    } catch {
-      throw new Error("OpenPond OpChat request failed: malformed streaming event.");
-    }
-    if (payload && typeof payload === "object" && "error" in payload) {
-      throw new Error(`OpenPond OpChat request failed: ${errorMessageFromPayload(payload)}`);
-    }
-    lastPayload = payload;
-    const record = payload && typeof payload === "object" ? payload : {};
-    const choices = Array.isArray(record.choices) ? record.choices : [];
-    const choice = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
-    const delta = choice.delta && typeof choice.delta === "object" ? choice.delta : {};
-    const deltas = [];
-    const reasoningChunk = streamTextValue(delta.reasoning_content);
-    if (reasoningChunk) {
-      accumulatedReasoning += reasoningChunk;
-      deltas.push({ type: "reasoning_delta", text: reasoningChunk, raw: payload });
-    }
-    const textChunk = streamTextValue(delta.content);
-    if (textChunk) {
-      deltas.push({ type: "text_delta", text: textChunk, raw: payload });
-    }
-    mergeOpChatToolCallDeltas(toolCalls, delta.tool_calls);
-    finishReason = stringValue(choice.finish_reason) ?? finishReason;
-    usage = parseUsage(payload) ?? usage;
-    return deltas;
-  };
-  const consumeLine = (line) => {
-    const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
-    if (!normalized) {
-      return consumeEvent();
-    }
-    if (normalized.startsWith(":"))
-      return [];
-    if (normalized.startsWith("data:")) {
-      dataLines.push(normalized.slice("data:".length).trimStart());
-    }
-    return [];
-  };
-  try {
-    while (true) {
-      const result = await reader.read();
-      if (result.done)
-        break;
-      buffer += decoder.decode(result.value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        for (const delta of consumeLine(line))
-          yield delta;
-      }
-    }
-    buffer += decoder.decode();
-    if (buffer) {
-      for (const delta of consumeLine(buffer))
-        yield delta;
-    }
-    for (const delta of consumeEvent())
-      yield delta;
-  } finally {
-    reader.releaseLock();
-  }
-  if (!sawDone) {
-    throw new Error("OpenPond OpChat request failed: stream ended before [DONE].");
-  }
-  const completedToolCalls = completedOpChatToolCalls(toolCalls);
-  if (completedToolCalls.length > 0) {
-    yield { type: "tool_call_delta", toolCalls: completedToolCalls, raw: lastPayload };
-  }
-  if (completedToolCalls.length > 0 && accumulatedReasoning) {
-    yield {
-      type: "continuation",
-      continuation: {
-        kind: "chat_completions_reasoning",
-        reasoningContent: accumulatedReasoning
-      },
-      raw: lastPayload
-    };
-  }
-  const completedUsage = usageWithResponseHeaderCache(usage, responseHeaderUsage);
-  if (completedUsage)
-    yield { type: "usage", usage: completedUsage, raw: lastPayload };
-  yield { type: "finish", finishReason, raw: lastPayload };
-}
-function cacheUsageFromResponseHeaders(headers) {
-  const promptTokens = firstHeaderTokenCount(headers, [
-    "fireworks-prompt-tokens",
-    "prompt-tokens"
-  ]);
-  const cachedPromptTokens = firstHeaderTokenCount(headers, [
-    "fireworks-cached-prompt-tokens",
-    "cached-prompt-tokens"
-  ]);
-  if (cachedPromptTokens === null)
-    return null;
-  return {
-    ...promptTokens === null ? {} : { prompt_tokens: promptTokens },
-    cached_input_tokens: cachedPromptTokens,
-    cache_telemetry_source: "provider_response_headers"
-  };
-}
-function firstHeaderTokenCount(headers, names) {
-  for (const name of names) {
-    const value = headers.get(name);
-    if (value === null || !/^\d+$/.test(value.trim()))
-      continue;
-    const parsed = Number(value);
-    if (Number.isSafeInteger(parsed) && parsed >= 0)
-      return parsed;
-  }
-  return null;
-}
-function usageWithResponseHeaderCache(usage, responseHeaderUsage) {
-  if (!responseHeaderUsage || usageHasCacheTelemetry(usage))
-    return usage;
-  const merged = {
-    ...usage ?? {},
-    cached_input_tokens: responseHeaderUsage.cached_input_tokens,
-    cache_telemetry_source: "provider_response_headers"
-  };
-  if (usageTokenCount(usage?.prompt_tokens) === null && responseHeaderUsage.prompt_tokens !== void 0) {
-    merged.prompt_tokens = responseHeaderUsage.prompt_tokens;
-  }
-  return merged;
-}
-function usageHasCacheTelemetry(usage) {
-  if (!usage)
-    return false;
-  if (usageTokenCount(usage.cached_input_tokens) !== null || usageTokenCount(usage.cache_read_input_tokens) !== null || usageTokenCount(usage.cache_creation_input_tokens) !== null || usageTokenCount(usage.prompt_cache_hit_tokens) !== null || usageTokenCount(usage.prompt_cache_miss_tokens) !== null)
-    return true;
-  return usageTokenCount(usage.prompt_tokens_details?.cached_tokens) !== null || usageTokenCount(usage.input_tokens_details?.cached_tokens) !== null;
-}
-function usageTokenCount(value) {
-  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
-    return value;
-  if (typeof value !== "string" || !/^\d+$/.test(value.trim()))
-    return null;
-  const parsed = Number(value);
-  return Number.isSafeInteger(parsed) ? parsed : null;
-}
-function mergeOpChatToolCallDeltas(calls, value) {
-  if (!Array.isArray(value))
-    return;
-  value.forEach((item, position) => {
-    if (!item || typeof item !== "object")
-      return;
-    const record = item;
-    const index = typeof record.index === "number" && Number.isInteger(record.index) ? record.index : position;
-    const current = calls.get(index) ?? { arguments: "" };
-    if (typeof record.id === "string")
-      current.id = record.id;
-    const fn = record.function && typeof record.function === "object" ? record.function : {};
-    if (typeof fn.name === "string") {
-      current.name = `${current.name ?? ""}${fn.name}`;
-    }
-    if (typeof fn.arguments === "string") {
-      current.arguments += fn.arguments;
-    }
-    calls.set(index, current);
-  });
-}
-function completedOpChatToolCalls(calls) {
-  return [...calls.entries()].sort(([left], [right]) => left - right).flatMap(([, call]) => call.id && call.name ? [{
-    id: call.id,
-    type: "function",
-    function: {
-      name: call.name,
-      arguments: call.arguments
-    }
-  }] : []);
-}
-function buildOpChatBody(options, stream) {
-  const body = {
-    model: options.model,
-    messages: options.messages.map(opChatMessage),
-    stream
-  };
-  if (options.tools) {
-    body.tools = options.tools;
-  }
-  if (options.toolChoice !== void 0) {
-    body.tool_choice = options.toolChoice;
-  }
-  if (typeof options.maxTokens === "number") {
-    body.max_tokens = options.maxTokens;
-  }
-  if (typeof options.temperature === "number") {
-    body.temperature = options.temperature;
-  }
-  if (typeof options.topP === "number") {
-    body.top_p = options.topP;
-  }
-  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, images, ...projected } = message;
-  const content = images?.length ? [
-    ...typeof message.content === "string" && message.content.trim() ? [{ type: "text", text: message.content }] : [],
-    ...images.map((image) => ({
-      type: "image_url",
-      image_url: {
-        url: image.url,
-        ...image.detail ? { detail: image.detail } : {}
-      }
-    }))
-  ] : message.content;
-  if (message.role === "assistant" && continuation?.kind === "chat_completions_reasoning") {
-    return {
-      ...projected,
-      ...content !== void 0 ? { content } : {},
-      reasoning_content: continuation.reasoningContent
-    };
-  }
-  return { ...projected, ...content !== void 0 ? { content } : {} };
-}
-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);
-}
-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;
-}
-function streamTextValue(value) {
-  return typeof value === "string" && value.length > 0 ? 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, error: null }
-      ];
-    }
-    try {
-      return [
-        key,
-        {
-          response: await getOpenPondAccount(resolvePublicApiBaseUrl(account, context.config), token),
-          authFailed: false,
-          error: null
-        }
-      ];
-    } catch (error) {
-      return [
-        key,
-        {
-          response: null,
-          authFailed: true,
-          error: errorMessage(error)
-        }
-      ];
-    }
-  }));
-  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) {
-    return {
-      ...await accountPromise,
-      apps: [],
-      error: "No OpenPond API key or session token is configured."
-    };
-  }
-  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
-    })
-  ]);
-  if (accountResult.status === "rejected")
-    throw accountResult.reason;
-  return {
-    account: accountResult.value.account,
-    apps: appsResult.status === "fulfilled" ? appsResult.value.map(normalizeApp).filter((value) => Boolean(value)) : [],
-    error: appsResult.status === "rejected" ? errorMessage(appsResult.reason) : null
-  };
-}
-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 {
-  }
-  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/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/sign-out-account.js
-async function signOutOpenPondAccount() {
-  const config = await loadGlobalConfig();
-  const activeProfile = normalizeActiveProfile(config.activeProfile);
-  const accounts = (config.accounts ?? []).map((account) => ({ ...account }));
-  const activeIndex = activeProfile ? accounts.findIndex((account) => accountMatchesSelector(account, activeProfile)) : 0;
-  if (activeIndex < 0 || !accounts[activeIndex]) {
-    throw new Error("No active OpenPond account to log out.");
-  }
-  const signedOutAccount = { ...accounts[activeIndex] };
-  delete signedOutAccount.apiKey;
-  delete signedOutAccount.session;
-  accounts[activeIndex] = signedOutAccount;
-  await saveConfig({ ...config, accounts });
-  return loadOpenPondAccountContext(signedOutAccount.handle, signedOutAccount.baseUrl);
-}
-
-// ../../packages/runtime/dist/update-account-config.js
-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)
-    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 = findAccountIndex2(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,
-  loadOpenPondAccountState,
-  loadOpenPondApps,
-  createOpenPondRepoApp,
-  loadOpenPondHostedModels,
-  loadOpenPondProviderCatalog,
-  streamOpenPondHostedChatTurn,
-  saveOpenPondAccount,
-  removeOpenPondAccount,
-  signOutOpenPondAccount,
-  updateOpenPondAccountConfig,
-  getOpenPondAppEnvironment,
-  getBundledRuntimeVersion,
-  createReadyLineParser,
-  openUrlWithSystemBrowser
-};