segmind 0.2.2 → 0.2.4

package/README.md

@@ -97,7 +97,17 @@ const { url } = await segmind.files.upload('portrait.jpg'); // a path (Node), a
 const result = await segmind.run('some-image-to-image-model', { image: url });
 ```
 
-Each file goes straight to storage on a presigned URL, so large videos never travel as base64 JSON. The URLs are public and temporary (kept for at least two days): they are for passing files to models, not for keeping them. Pass an array to upload several, in order. Bytes without a name need `{ filename: 'clip.mp4' }` unless their type can be read from the first bytes.
+Each file goes straight to storage on a presigned URL, so large videos never travel as base64 JSON. By default the URLs are public and temporary (kept for at least two days): they are for passing files to models, not for keeping them. Pass an array to upload several, in order. Bytes without a name need `{ filename: 'clip.mp4' }` unless their type can be read from the first bytes.
+
+To keep a file, pass `persist: true`. It is saved to your asset library and its URL does not expire, the same as the Python SDK's upload:
+
+```ts
+const logo = await segmind.files.upload('logo.png', { persist: true });
+logo.url; // https://images.segmind.com/assets/…
+logo.persistent; // true
+```
+
+Persistent uploads take images, video, audio, PDF and common document types, up to 2 GB each.
 
 ## Generations
 
@@ -115,12 +125,12 @@ const latest = await segmind.generations.recent('flux-schnell');
 ```ts
 const hook = await segmind.webhooks.add('https://example.com/hooks/segmind', ['PIXELFLOW']);
 const hooks = await segmind.webhooks.get(); // each with its signing_secret
-await segmind.webhooks.update(hook.id, 'https://example.com/hooks/v2', ['PIXELFLOW']);
+await segmind.webhooks.update(hook.id, 'https://example.com/hooks/v2'); // URL only
 await segmind.webhooks.logs(hook.id);
 await segmind.webhooks.delete(hook.id);
 ```
 
-Event types are subscription types: `PIXELFLOW` for PixelFlow runs, plus `WORKFLOW`, `INFERENCE` and `FINETUNE`.
+Event types are subscription types: `PIXELFLOW` for PixelFlow runs, plus `WORKFLOW`, `INFERENCE` and `FINETUNE`. `update` changes the URL only; to change the event types, `delete` the registration and `add` a new one. Before 0.2.4, `update` registered a second hook and `delete` deactivated nothing, so check `webhooks.get()` for registrations left behind.
 
 ## PixelFlow workflows
 

package/dist/index.cjs

@@ -491,12 +491,16 @@ var Files = class {
   }
   async uploadOne(input, options) {
     const file = await readFileInput(input, { ...options, caller: "files.upload" });
-    const { http } = this.client;
-    const ticket = await http.json({
+    const url = options.persist ? await this.persist(file, options.signal) : await this.stage(file, options.signal);
+    return { url, filename: file.filename, size: file.bytes.byteLength, persistent: options.persist === true };
+  }
+  /** A temporary model input on the inference API's input bucket. */
+  async stage(file, signal) {
+    const ticket = await this.client.http.json({
       method: "POST",
       url: `${this.client.spotURL}/inference-request/input-presign`,
       body: { filename: file.filename, size: file.bytes.byteLength },
-      signal: options.signal,
+      signal,
       retry: true
     });
     if (!ticket.upload_url || !ticket.url) {
@@ -505,16 +509,41 @@ var Files = class {
     const headers = { ...ticket.required_headers };
     delete headers["Content-Length"];
     delete headers["content-length"];
-    await http.request({
-      method: "PUT",
-      url: ticket.upload_url,
-      rawBody: file.bytes,
-      headers,
-      bare: true,
-      signal: options.signal,
+    await this.put(ticket.upload_url, file, headers, signal);
+    return ticket.url;
+  }
+  /** A file in the caller's asset library: presign, PUT, then confirm to register it. */
+  async persist(file, signal) {
+    const contentType = file.mimeType;
+    if (!contentType) {
+      throw new SegmindError(`files.upload: cannot tell the type of ${file.filename}; pass { mimeType } to persist it`);
+    }
+    const { http, assetsURL } = this.client;
+    const ticket = await http.json({
+      method: "POST",
+      url: `${assetsURL}/upload-asset/presign`,
+      body: { filename: file.filename, contentType, size: file.bytes.byteLength },
+      signal,
       retry: true
     });
-    return { url: ticket.url, filename: file.filename, size: file.bytes.byteLength };
+    if (!ticket.presignedUrl || !ticket.s3Key || !ticket.publicUrl) {
+      throw new SegmindError("files.upload: the asset presign response had no presignedUrl, s3Key or publicUrl", {
+        body: ticket
+      });
+    }
+    await this.put(ticket.presignedUrl, file, { "Content-Type": contentType }, signal);
+    const confirmed = await http.json({
+      method: "POST",
+      url: `${assetsURL}/upload-asset/confirm`,
+      body: { s3Key: ticket.s3Key, publicUrl: ticket.publicUrl, contentType, filename: file.filename },
+      signal,
+      retry: true
+    });
+    return confirmed.asset?.url ?? ticket.publicUrl;
+  }
+  /** A PUT to the same key is idempotent, so it retries. `bare` keeps the API key off the storage host. */
+  async put(url, file, headers, signal) {
+    await this.client.http.request({ method: "PUT", url, rawBody: file.bytes, headers, bare: true, signal, retry: true });
   }
 };
 
@@ -752,7 +781,7 @@ function failureDetail(body) {
 }
 
 // src/version.ts
-var VERSION = "0.2.2";
+var VERSION = "0.2.4";
 
 // src/webhooks.ts
 var Webhooks = class {
@@ -771,16 +800,26 @@ var Webhooks = class {
       signal: options.signal
     });
   }
-  /** Changes a registration's URL and event types. */
-  async update(webhookId, webhookUrl, eventTypes, options = {}) {
-    return this.call("POST", "/update", {
-      body: { webhook_id: webhookId, webhook_url: webhookUrl, event: { types: requireTypes(eventTypes) } },
-      signal: options.signal
+  /**
+   * Points an active registration at a new URL. The event types stay as
+   * registered: to change them, `delete` the registration and `add` a new one.
+   *
+   * @param _eventTypes Ignored. Kept so 0.2 calls still compile; the API never
+   *   changed event types in place.
+   */
+  async update(webhookId, webhookUrl, _eventTypes, options = {}) {
+    return this.call("PUT", "/update", {
+      body: { webhook_id: webhookId, webhook_url: webhookUrl },
+      signal: options.signal,
+      retry: true
     });
   }
-  /** Deactivates a registration. */
+  /**
+   * Deactivates a registration. Not retried: a second attempt after a lost
+   * response would report the registration as already deactivated.
+   */
   async delete(webhookId, options = {}) {
-    return this.call("GET", "/inactive", { query: { webhook_id: webhookId }, signal: options.signal, retry: true });
+    return this.call("DELETE", "/inactive", { query: { webhook_id: webhookId }, signal: options.signal });
   }
   /** Delivery history for one registration. */
   async logs(webhookId, options = {}) {
@@ -801,10 +840,12 @@ function requireTypes(eventTypes) {
 var DEFAULT_BASE_URL = "https://api.segmind.com";
 var DEFAULT_SPOT_URL = "https://api.spotprod.segmind.com";
 var DEFAULT_CONSOLE_URL = "https://cloud.segmind.com/api";
+var DEFAULT_ASSETS_URL = "https://platform-api.segmind.com";
 var Segmind = class {
   baseURL;
   spotURL;
   consoleURL;
+  assetsURL;
   models;
   accounts;
   /** Upload files to pass as model inputs. */
@@ -833,6 +874,7 @@ var Segmind = class {
     this.baseURL = trimBase(options.baseURL ?? readEnv("SEGMIND_BASE_URL") ?? DEFAULT_BASE_URL);
     this.spotURL = trimSlash(options.spotURL ?? DEFAULT_SPOT_URL);
     this.consoleURL = trimSlash(options.consoleURL ?? DEFAULT_CONSOLE_URL);
+    this.assetsURL = trimSlash(options.assetsURL ?? DEFAULT_ASSETS_URL);
     const headers = { "X-Initiator": "SDK-JS", ...options.defaultHeaders };
     const node = nodeVersion();
     if (runtime === "node" && node) headers["User-Agent"] = `segmind-js/${VERSION} node/${node}`;
@@ -925,7 +967,7 @@ var Segmind = class {
             body
           });
         }
-        return new Job(this.http, validateSubmit(body, response.status), transform);
+        return new Job(this.http, onBase(validateSubmit(body, response.status), this.baseURL), transform);
       }
       if (canRetry && response.status === 503) {
         await response.body?.cancel().catch(() => void 0);
@@ -986,6 +1028,14 @@ function path(slug) {
   if (!clean) throw new SegmindError("A model slug is required.");
   return clean;
 }
+function onBase(body, baseURL) {
+  const origin = new URL(baseURL).origin;
+  const pin = (url) => {
+    const target = new URL(url, `${baseURL}/`);
+    return target.origin === origin ? target.href : `${baseURL}${target.pathname}${target.search}`;
+  };
+  return { ...body, status_url: pin(body.status_url), response_url: pin(body.response_url) };
+}
 function trimSlash(url) {
   return url.replace(/\/+$/, "");
 }