@mindstudio-ai/agent 0.1.108 → 0.1.109

package/dist/index.d.ts

@@ -109,6 +109,13 @@ declare class Store {
     get access(): FileAccess;
     /** Store bytes. Returns a {@link StoredFile} with a ready-to-use `url`. */
     put(content: Buffer | Uint8Array | string, options?: PutOptions): Promise<StoredFile>;
+    /**
+     * Large-content half of {@link put}: mint a presigned POST scoped to exactly
+     * these bytes and send them direct to storage — the JSON transport's body
+     * limit never sees them. Same result contract as the small path; the final
+     * `head` keeps the returned metadata honest (server-observed size/type/time).
+     */
+    private _putPresigned;
     /** Read an object's bytes (backend / trusted context). */
     get(key: string): Promise<Buffer>;
     /** Metadata without downloading. Rejects if the object doesn't exist. */

package/dist/index.js

@@ -2592,6 +2592,7 @@ function toBase64(content) {
     typeof content === "string" ? Buffer.from(content) : content
   ).toString("base64");
 }
+var PRESIGN_THRESHOLD = 4 * 1024 * 1024;
 function extensionFor(filename) {
   if (!filename) {
     return "";
@@ -2619,16 +2620,73 @@ var Store = class {
     const ext = extensionFor(options?.filename);
     const key = options?.key ?? (options?.contentAddressed ? `${createHash("sha256").update(content).digest("hex")}${ext}` : `${randomUUID()}${ext}`);
     const cacheControl = options?.cacheControl ?? (!options?.key && this._access === "public" ? "public, max-age=31536000, immutable" : void 0);
+    const bytes = typeof content === "string" ? Buffer.from(content) : content;
+    if (bytes.byteLength >= PRESIGN_THRESHOLD) {
+      return this._putPresigned(bytes, key, {
+        ...options?.contentType ? { contentType: options.contentType } : {},
+        ...cacheControl ? { cacheControl } : {}
+      });
+    }
     const meta = await this._call("put", {
       store: this._store,
       access: this._access,
       key,
-      body: toBase64(content),
+      body: toBase64(bytes),
       ...options?.contentType ? { contentType: options.contentType } : {},
       ...cacheControl ? { cacheControl } : {}
     });
     return this._toFile(key, meta);
   }
+  /**
+   * Large-content half of {@link put}: mint a presigned POST scoped to exactly
+   * these bytes and send them direct to storage — the JSON transport's body
+   * limit never sees them. Same result contract as the small path; the final
+   * `head` keeps the returned metadata honest (server-observed size/type/time).
+   */
+  async _putPresigned(bytes, key, options) {
+    const res = await this._call("create-upload", {
+      store: this._store,
+      access: this._access,
+      key,
+      maxSize: bytes.byteLength,
+      ...options.contentType ? { contentType: options.contentType } : {},
+      ...options.cacheControl ? { cacheControl: options.cacheControl } : {}
+    });
+    const form = new FormData();
+    for (const [k, v] of Object.entries(
+      res.uploadFields
+    )) {
+      form.append(k, v);
+    }
+    const view = new Uint8Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength
+    );
+    form.append(
+      "file",
+      new Blob([view], options.contentType ? { type: options.contentType } : void 0)
+    );
+    const upload = await fetch(res.uploadUrl, {
+      method: "POST",
+      body: form
+    });
+    if (!upload.ok) {
+      const errorText = await upload.text().catch(() => "");
+      throw new MindStudioError(
+        `Upload failed: ${upload.status} ${upload.statusText}${errorText ? ` \u2014 ${errorText.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ").trim().slice(0, 200)}` : ""}`,
+        "upload_error",
+        upload.status,
+        errorText || void 0
+      );
+    }
+    const meta = await this._call("head", {
+      store: this._store,
+      access: this._access,
+      key
+    });
+    return this._toFile(key, meta);
+  }
   /** Read an object's bytes (backend / trusted context). */
   async get(key) {
     const res = await this._call("get", {