openpond 0.0.38 → 0.0.40

package/dist/chunks/{chunk-JWF37O5E.js → chunk-3HW6OSHP.js}

@@ -4,7 +4,7 @@ import {
   parseSandboxRuntimeProfileIdOption,
   parseSandboxRuntimePromotionPolicyOption,
   parseSandboxWorkflowModeOption
-} from "./chunk-275WCETC.js";
+} from "./chunk-FCVVOMIP.js";
 import {
   parseBooleanOption,
   parseCsvOption,
@@ -79,7 +79,6 @@ function formatSandboxLine(sandbox) {
   return [
     sandbox.id,
     sandbox.state,
-    sandbox.runtimeDriver,
     `spent=${captured}/${budget}`,
     mppMode,
     repo
@@ -589,7 +588,6 @@ function summarizeSandbox(sandbox) {
   return {
     id: sandbox.id,
     state: sandbox.state,
-    runtimeDriver: sandbox.runtimeDriver,
     repo: sandbox.repo,
     runtimeId: sandbox.runtimeId ?? null,
     repoRef: sandbox.repoRef ?? null,

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

@@ -1,10 +1,228 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  getOpChatModel,
-  listOpChatModels,
-  sendHostedChatTurn,
-  streamHostedChatTurn
-} from "./chunk-HLCTINEP.js";
+  withVercelProtectionBypass
+} from "./chunk-DBHSOTYZ.js";
+import {
+  DEFAULT_OPENPOND_OPCHAT_API_BASE_URL
+} from "./chunk-KSRWKXRB.js";
+
+// ../../packages/cloud/src/hosted-chat.ts
+import { randomUUID } from "node:crypto";
+function normalizeApiBaseUrl(value) {
+  const trimmed = normalizeOptionalOpChatApiBaseUrl(value);
+  if (!trimmed) throw new Error("apiBaseUrl is required");
+  return trimmed;
+}
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function normalizeOptionalOpChatApiBaseUrl(value) {
+  let trimmed = trimTrailingSlashes(value?.trim() ?? "");
+  if (!trimmed) return null;
+  trimmed = trimmed.replace(/\/chat\/completions$/i, "").replace(/\/models(?:\/[^/]+)?$/i, "");
+  if (trimmed.endsWith("/opchat/v1")) return trimmed;
+  if (trimmed.endsWith("/opchat")) return `${trimmed}/v1`;
+  if (trimmed.endsWith("/v1")) {
+    trimmed = trimmed.slice(0, -"/v1".length);
+  }
+  return `${trimTrailingSlashes(trimmed)}/opchat/v1`;
+}
+function resolveOpChatApiBaseUrl(options = {}) {
+  const runtimeEnv = options.env ?? (typeof process !== "undefined" ? process.env : {});
+  const explicit = normalizeOptionalOpChatApiBaseUrl(options.opChatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_OPCHAT_API_URL);
+  if (explicit) return explicit;
+  const migrationInput = normalizeOptionalOpChatApiBaseUrl(options.chatApiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_CHAT_API_URL) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_GATEWAY_URL);
+  if (migrationInput) return migrationInput;
+  const apiBase = normalizeOptionalOpChatApiBaseUrl(options.apiBaseUrl) ?? normalizeOptionalOpChatApiBaseUrl(runtimeEnv.OPENPOND_API_URL);
+  return apiBase ?? DEFAULT_OPENPOND_OPCHAT_API_BASE_URL;
+}
+function requireToken(value) {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error("OpenPond API key is required");
+  return trimmed;
+}
+function hostedHeaders(requestUrl, token, accept, requestId) {
+  const headers = new Headers();
+  headers.set("Authorization", `Bearer ${requireToken(token)}`);
+  headers.set("Content-Type", "application/json");
+  headers.set("Accept", accept);
+  headers.set("x-openpond-client", "openpond-code");
+  headers.set("x-openpond-request-id", requestId || randomUUID());
+  return withVercelProtectionBypass(requestUrl, headers);
+}
+async function readError(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) return response.statusText || `HTTP ${response.status}`;
+  try {
+    const payload = JSON.parse(text);
+    const error = typeof payload.error === "string" ? payload.error : payload.error && typeof payload.error === "object" && !Array.isArray(payload.error) ? payload.error : null;
+    const code = typeof payload.code === "string" ? payload.code : error && typeof error !== "string" && typeof error.code === "string" ? error.code : null;
+    const message = typeof payload.message === "string" ? payload.message : error && typeof error !== "string" && typeof error.message === "string" ? error.message : null;
+    const label = typeof error === "string" ? error : error && typeof error.type === "string" ? error.type : null;
+    return [code, label, message].filter(Boolean).join(": ") || text;
+  } catch {
+    return text;
+  }
+}
+function buildHostedChatBody(options, stream) {
+  const body = {
+    model: options.model,
+    messages: options.messages,
+    stream
+  };
+  if (typeof options.temperature === "number") {
+    body.temperature = options.temperature;
+  }
+  if (typeof options.maxTokens === "number") {
+    body.max_tokens = options.maxTokens;
+  }
+  if (options.tools) {
+    body.tools = options.tools;
+  }
+  const toolChoice = options.toolChoice ?? options.tool_choice;
+  if (toolChoice !== void 0) {
+    body.tool_choice = toolChoice;
+  }
+  if (options.metadata) {
+    body.metadata = options.metadata;
+  }
+  return body;
+}
+async function listOpChatModels(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/models`;
+  const response = await fetch(requestUrl, {
+    method: "GET",
+    headers: hostedHeaders(requestUrl, options.token, "application/json"),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Hosted model list failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function getOpChatModel(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/models/${encodeURIComponent(options.model)}`;
+  const response = await fetch(
+    requestUrl,
+    {
+      method: "GET",
+      headers: hostedHeaders(requestUrl, options.token, "application/json"),
+      signal: options.signal
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Hosted model lookup failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  return await response.json();
+}
+async function sendHostedChatTurn(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/chat/completions`;
+  const response = await fetch(requestUrl, {
+    method: "POST",
+    headers: hostedHeaders(
+      requestUrl,
+      options.token,
+      "application/json",
+      options.requestId
+    ),
+    body: JSON.stringify(buildHostedChatBody(options, false)),
+    signal: options.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Hosted chat failed: ${response.status} ${await readError(response)}`
+    );
+  }
+  return await response.json();
+}
+async function* parseOpenAISSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const readAbortError = () => signal?.reason instanceof Error ? signal.reason : new Error("hosted_chat_aborted");
+  try {
+    while (true) {
+      if (signal?.aborted) throw readAbortError();
+      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) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("data:")) continue;
+        const data = trimmed.slice(5).trim();
+        if (!data) continue;
+        if (data === "[DONE]") return;
+        yield JSON.parse(data);
+      }
+    }
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function* streamHostedChatTurn(options) {
+  const apiBaseUrl = normalizeApiBaseUrl(options.apiBaseUrl);
+  const requestUrl = `${apiBaseUrl}/chat/completions`;
+  const response = await fetch(requestUrl, {
+    method: "POST",
+    headers: hostedHeaders(
+      requestUrl,
+      options.token,
+      "text/event-stream",
+      options.requestId
+    ),
+    body: JSON.stringify(buildHostedChatBody(options, true)),
+    signal: options.signal
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(
+      `Hosted chat stream failed: ${response.status} ${await readError(
+        response
+      )}`
+    );
+  }
+  for await (const raw of parseOpenAISSE(response.body, options.signal)) {
+    const chunk = raw;
+    if (chunk.error) {
+      throw new Error(chunk.error.message || "Hosted chat stream error");
+    }
+    if (chunk.usage) {
+      yield { type: "usage", usage: chunk.usage, raw };
+    }
+    const choice = chunk.choices?.[0];
+    if (!choice) continue;
+    const content = choice.delta?.content;
+    if (content) {
+      yield { type: "text_delta", text: content, raw };
+    }
+    const reasoning = choice.delta?.reasoning_content;
+    if (reasoning) {
+      yield { type: "reasoning_delta", text: reasoning, raw };
+    }
+    const toolCalls = choice.delta?.tool_calls;
+    if (Array.isArray(toolCalls) && toolCalls.length > 0) {
+      yield { type: "tool_call_delta", toolCalls, raw };
+    }
+    if (choice.finish_reason !== void 0 && choice.finish_reason !== null) {
+      yield { type: "finish", finishReason: choice.finish_reason, raw };
+    }
+  }
+}
 
 // ../../packages/cloud/src/opchat-smoke.ts
 var DEFAULT_MODEL = "openpond-chat";
@@ -290,5 +508,10 @@ function formatUsage(usage) {
 }
 
 export {
+  resolveOpChatApiBaseUrl,
+  listOpChatModels,
+  getOpChatModel,
+  sendHostedChatTurn,
+  streamHostedChatTurn,
   runOpChatSmoke
 };

package/dist/chunks/{chunk-YTJL6XPU.js → chunk-75ZLFVFZ.js}

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

package/dist/chunks/{chunk-HS2AGRDV.js → chunk-CZG4XKVF.js}

@@ -3,7 +3,7 @@ import { createRequire as __openpondCreateRequire } from "node:module"; var requ
 // ../server/src/constants.ts
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 17874;
-var VERSION = "0.0.38";
+var VERSION = "0.0.40";
 var HOSTED_CHAT_SYSTEM_PROMPT = "You are OpenPond Chat. Respond in the user's language. If the user's latest message is language-neutral, ambiguous, or only a short test, respond in English. Be concise and directly answer the latest request. Do not use emojis. Use Markdown when it improves scanability. If you emit reasoning or thinking content, keep it sparse and user-readable: at most one short sentence for major progress, decisions, or blockers. Omit reasoning for routine searches, reads, tool calls, and obvious next steps. Do not restate the user request, narrate every action, or include code blocks, code excerpts, diffs, raw tool payloads, or markdown examples in reasoning. Put necessary code or exact snippets only in the final assistant answer. When the user asks to show or preview an image that is available as a workspace path or signed image URL, use Markdown image syntax like ![description](path-or-url) instead of a bare path or raw HTML. For workspace-backed answers, use a Codex-style shape: brief outcome first, then Changed Files if files changed, then Verification if checks ran. End with a concise final answer that summarizes the result and verification when relevant. Do not mention raw tool JSON, internal repo paths, or origin/remote URLs unless the user explicitly asks for them or they are necessary to explain a git/deploy failure.";
 var APP_PREFERENCES_CACHE_TYPE = "app_preferences";
 var APP_PREFERENCES_CACHE_KEY = "global";