openpond-sdk 0.0.2 → 0.0.3

package/README.md

@@ -33,7 +33,29 @@ 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.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, command, and output progress to a client.
+
+Completed files written under `/workspace/outputs` are collected automatically. The model does not need to publish or register them. Each detected file is emitted as an `output` event and returned in `result.outputs`:
+
+```ts
+const result = await openpond.work.run({
+  prompt: "Create a DOCX summary",
+  onEvent(event) {
+    if (event.type === "output") console.log(event.output.name);
+  },
+});
+
+for (const output of result.outputs) {
+  const downloaded = await openpond.work.downloadOutput(
+    result.sandboxId,
+    output,
+  );
+  const bytes = Buffer.from(downloaded.file.contentsBase64, "base64");
+  // Stream bytes from your authenticated server route.
+}
+```
+
+Output descriptors include the sandbox path, filename, MIME type, size, modification time, and preview hints. `downloadOutput` remains a separate deterministic file operation, so downloading a result never starts another model turn.
 
 If sandbox execution is unavailable, the API fails with the stable `sandbox_runner_unavailable` error instead of returning a successful command result.
 
@@ -66,17 +88,6 @@ console.log(result.command.output);
 
 The package also exports `createOpenPondSandboxClient`, all public sandbox input and response types, and the OpChat helpers used by the Work loop.
 
-## Staging
-
-Use a server-only environment file while developing:
-
-```dotenv
-OPENPOND_API_KEY=opk_...
-OPENPOND_API_URL=https://staging-api.openpond.ai
-```
-
-If the staging deployment has Vercel protection enabled, also set `VERCEL_AUTOMATION_BYPASS_SECRET`. The SDK only sends that bypass header to OpenPond staging hosts.
-
 ## Lifecycle and cleanup
 
 Work sandboxes remain available so conversations can continue. Delete them when a conversation is removed or expires:

package/dist/index.js

@@ -2321,6 +2321,8 @@ async function* streamHostedChatTurn(options) {
 var DEFAULT_MODEL = "openpond-chat";
 var DEFAULT_MAX_STEPS = 24;
 var MAX_TOOL_OUTPUT_CHARS = 4e4;
+var WORK_OUTPUT_DIRECTORY = "/workspace/outputs";
+var MAX_WORK_OUTPUTS = 100;
 var OpenPondWorkClient = class {
   #apiKey;
   #apiBaseUrl;
@@ -2344,6 +2346,7 @@ var OpenPondWorkClient = class {
       sandboxId: sandbox.id,
       state: sandbox.state
     });
+    const outputBaseline = await this.#prepareOutputDirectory(sandbox.id);
     const messages = [
       { role: "system", content: systemPrompt(sandbox.id) },
       ...(input.history ?? []).map((message) => ({ ...message })),
@@ -2382,7 +2385,14 @@ var OpenPondWorkClient = class {
         await emit({ type: "assistant", text: assistantText });
       }
       if (toolCalls.length === 0) {
-        const result = { sandboxId: sandbox.id, text: finalText, steps: step };
+        const outputs = await this.#collectOutputs(sandbox.id, outputBaseline);
+        for (const output of outputs) await emit({ type: "output", output });
+        const result = {
+          sandboxId: sandbox.id,
+          text: finalText,
+          steps: step,
+          outputs
+        };
         await emit({ type: "done", ...result });
         return result;
       }
@@ -2404,6 +2414,33 @@ var OpenPondWorkClient = class {
     if (sandbox.state === "deleted") return;
     await this.#sandboxes.delete(sandboxId, { async: true });
   }
+  downloadOutput(sandboxId, output) {
+    return this.#sandboxes.downloadFileResponse(
+      sandboxId,
+      typeof output === "string" ? output : output.path
+    );
+  }
+  async #prepareOutputDirectory(sandboxId) {
+    await this.#sandboxes.mkdir(sandboxId, {
+      path: WORK_OUTPUT_DIRECTORY,
+      recursive: true
+    });
+    return outputSignatures(await this.#listOutputFiles(sandboxId));
+  }
+  async #collectOutputs(sandboxId, baseline) {
+    const files = await this.#listOutputFiles(sandboxId);
+    return files.filter((file) => baseline.get(file.path) !== outputSignature(file)).sort((left, right) => left.path.localeCompare(right.path)).slice(0, MAX_WORK_OUTPUTS).map(workOutputFromFile);
+  }
+  async #listOutputFiles(sandboxId) {
+    const listed = await this.#sandboxes.listFiles(sandboxId, {
+      path: WORK_OUTPUT_DIRECTORY,
+      recursive: true,
+      maxEntries: 500
+    });
+    return listed.files.filter(
+      (file) => file.type === "file" && !normalizedOutputPath(file.path).includes("/.openpond-")
+    );
+  }
   async #resolveSandbox(input) {
     if (input.sandboxId) {
       const existing = await this.#sandboxes.get(input.sandboxId);
@@ -2516,11 +2553,63 @@ function systemPrompt(sandboxId) {
     "You are OpenPond Work, a careful coding agent operating in a persistent Linux sandbox.",
     `The active sandbox is ${sandboxId}.`,
     "Use run_command to inspect the workspace, edit files, and validate your work.",
+    `Place completed user-facing files in ${WORK_OUTPUT_DIRECTORY}. The runtime collects new and revised files there automatically when the turn completes.`,
     "Do the requested work completely. Preserve existing user changes and avoid destructive commands.",
     "Keep the user informed with concise prose, but call tools whenever verification or file changes are needed.",
     "Before finishing, run relevant tests and summarize the concrete result."
   ].join("\n");
 }
+function outputSignatures(files) {
+  return new Map(files.map((file) => [file.path, outputSignature(file)]));
+}
+function outputSignature(file) {
+  return `${file.sizeBytes}:${file.updatedAt}`;
+}
+function workOutputFromFile(file) {
+  const name = normalizedOutputPath(file.path).split("/").at(-1) || file.path;
+  const mimeType = workOutputMimeType(name);
+  return {
+    path: file.path,
+    name,
+    mimeType,
+    sizeBytes: file.sizeBytes,
+    updatedAt: file.updatedAt,
+    isBinary: file.isBinary ?? null,
+    previewable: file.previewable ?? (mimeType.startsWith("image/") || mimeType === "application/pdf" || mimeType.startsWith("text/"))
+  };
+}
+function normalizedOutputPath(value) {
+  return value.replaceAll("\\", "/");
+}
+function workOutputMimeType(name) {
+  const extension = name.toLowerCase().match(/\.[^.]+$/)?.[0] ?? "";
+  return WORK_OUTPUT_MIME_TYPES[extension] ?? "application/octet-stream";
+}
+var WORK_OUTPUT_MIME_TYPES = Object.freeze({
+  ".avif": "image/avif",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".html": "text/html",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json",
+  ".m4a": "audio/mp4",
+  ".md": "text/markdown",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".svg": "image/svg+xml",
+  ".tsv": "text/tab-separated-values",
+  ".txt": "text/plain",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+});
 function toolMessage(toolCallId, payload) {
   return { role: "tool", tool_call_id: toolCallId, content: JSON.stringify(payload) };
 }