openpond-sdk 0.0.1 → 0.0.2

package/README.md

@@ -35,7 +35,9 @@ export async function POST(request: Request) {
 
 `work.run` creates a sandbox when `sandboxId` is omitted. Pass the returned ID into the next turn to continue in the same filesystem. Use `onEvent` to stream sandbox, model, and command progress to a client.
 
-Work requires a real `remote-firecracker` runtime. It fails closed if an environment returns the simulator or a nominal remote sandbox responds with a non-executing command marker, so an accepted command can never be mistaken for actual filesystem work.
+If sandbox execution is unavailable, the API fails with the stable `sandbox_runner_unavailable` error instead of returning a successful command result.
+
+API failures are exposed as `OpenPondApiError`, with `status` and stable `code` fields for server-side handling. `work.run` propagates these failures instead of asking the model to interpret infrastructure errors.
 
 ## Raw sandbox API
 

package/dist/index.js

@@ -252,12 +252,6 @@ async function runSandboxSmoke(client, options = {}) {
       )
     );
     sandboxId = sandbox.id;
-    const expectedRuntimeDriver = options.expectedRuntimeDriver ?? "remote-firecracker";
-    if (sandbox.runtimeDriver !== expectedRuntimeDriver) {
-      throw new Error(
-        `expected ${expectedRuntimeDriver}, got ${sandbox.runtimeDriver}`
-      );
-    }
     const expectedMppMode = options.expectedMppMode;
     if (expectedMppMode && sandbox.reservation.mpp?.mode !== expectedMppMode) {
       throw new Error(
@@ -608,6 +602,19 @@ var ApiResponseTooLargeError = class extends Error {
   requestUrl;
   code = "OPENPOND_API_RESPONSE_TOO_LARGE";
 };
+var OpenPondApiError = class extends Error {
+  constructor(status, errorCode, label, apiMessage = null) {
+    const detail = apiMessage || errorCode;
+    super(`${label} failed: ${status}${detail ? ` ${detail}` : ""}`);
+    this.status = status;
+    this.apiMessage = apiMessage;
+    this.name = "OpenPondApiError";
+    this.code = errorCode || "OPENPOND_API_ERROR";
+  }
+  status;
+  apiMessage;
+  code;
+};
 async function apiFetch(baseUrl, token, requestPath, options = {}) {
   const { timeoutMs = DEFAULT_API_TIMEOUT_MS, maxResponseBytes = DEFAULT_API_RESPONSE_BYTES, ...init } = options;
   const requestUrl = `${baseUrl}${requestPath}`;
@@ -656,8 +663,9 @@ async function readApiJson(response, label) {
     payload = {};
   }
   if (!response.ok) {
-    const message = typeof payload.message === "string" ? payload.message : typeof payload.error === "string" ? payload.error : "";
-    throw new Error(`${label} failed: ${response.status}${message ? ` ${message}` : ""}`);
+    const errorCode = typeof payload.error === "string" ? payload.error : null;
+    const apiMessage = typeof payload.message === "string" ? payload.message : null;
+    throw new OpenPondApiError(response.status, errorCode, label, apiMessage);
   }
   return payload;
 }
@@ -2313,17 +2321,6 @@ async function* streamHostedChatTurn(options) {
 var DEFAULT_MODEL = "openpond-chat";
 var DEFAULT_MAX_STEPS = 24;
 var MAX_TOOL_OUTPUT_CHARS = 4e4;
-var OpenPondNonExecutingSandboxError = class extends Error {
-  constructor(sandboxId) {
-    super(
-      `Sandbox ${sandboxId} accepted a command without executing it. A real remote runner is required for OpenPond Work.`
-    );
-    this.sandboxId = sandboxId;
-    this.name = "OpenPondNonExecutingSandboxError";
-  }
-  sandboxId;
-  code = "OPENPOND_NON_EXECUTING_SANDBOX";
-};
 var OpenPondWorkClient = class {
   #apiKey;
   #apiBaseUrl;
@@ -2342,19 +2339,10 @@ var OpenPondWorkClient = class {
     const emit = async (event) => input.onEvent?.(event);
     await emit({ type: "status", message: "Preparing sandbox" });
     const sandbox = await this.#resolveSandbox(input);
-    if (sandbox.runtimeDriver === "simulated-firecracker" && !input.allowSimulated) {
-      if (!input.sandboxId) {
-        await this.#sandboxes.delete(sandbox.id, { async: true }).catch(() => void 0);
-      }
-      throw new Error(
-        "OpenPond Work requires a remote-firecracker sandbox, but this environment returned the non-executing simulated-firecracker driver."
-      );
-    }
     await emit({
       type: "sandbox",
       sandboxId: sandbox.id,
-      state: sandbox.state,
-      runtimeDriver: sandbox.runtimeDriver
+      state: sandbox.state
     });
     const messages = [
       { role: "system", content: systemPrompt(sandbox.id) },
@@ -2484,18 +2472,6 @@ var OpenPondWorkClient = class {
         timeoutSeconds: boundedInteger(timeoutSeconds, 1, 900, 180)
       });
       const output = truncate(response.command.output, MAX_TOOL_OUTPUT_CHARS);
-      if (isNonExecutingSandboxOutput(output)) {
-        await emit({
-          type: "tool",
-          toolCallId,
-          command,
-          status: "failed",
-          output: "Staging accepted the command but did not execute it.",
-          exitCode: response.command.exitCode
-        });
-        await this.#sandboxes.delete(sandboxId, { async: true }).catch(() => void 0);
-        throw new OpenPondNonExecutingSandboxError(sandboxId);
-      }
       const status = response.command.status === "succeeded" ? "succeeded" : "failed";
       await emit({
         type: "tool",
@@ -2511,7 +2487,7 @@ var OpenPondWorkClient = class {
         output
       });
     } catch (error) {
-      if (error instanceof OpenPondNonExecutingSandboxError) throw error;
+      if (error instanceof OpenPondApiError) throw error;
       const output = errorMessage(error);
       await emit({ type: "tool", toolCallId, command, status: "failed", output });
       return toolMessage(toolCallId, { status: "failed", error: output });
@@ -2560,10 +2536,6 @@ function truncate(value, maximum) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function isNonExecutingSandboxOutput(output) {
-  const normalized = output.toLowerCase();
-  return normalized.includes("command accepted by simulated-firecracker driver") || normalized.includes("no host command was executed");
-}
 function sleep2(milliseconds, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -2585,7 +2557,7 @@ function sleep2(milliseconds, signal) {
 
 // ../cloud/src/sandbox/types/runtime-profiles.ts
 var SANDBOX_RUNTIME_PROFILE_IDS = [
-  "openpond-generic-firecracker-v1",
+  "openpond-generic-v1",
   "openpond-work-v1",
   "openpond-coding-core-v1",
   "openpond-agent-harness-v1"
@@ -2616,8 +2588,8 @@ function createOpenPondClient(options) {
   return new OpenPondClient(options);
 }
 export {
+  OpenPondApiError,
   OpenPondClient,
-  OpenPondNonExecutingSandboxError,
   OpenPondSandboxClient,
   OpenPondWorkClient,
   SANDBOX_RUNTIME_PROFILE_IDS,