segmind 0.2.2 → 0.2.4

package/dist/index.d.ts

@@ -147,6 +147,12 @@ interface UploadOptions {
     filename?: string;
     /** The file's type, when neither the name nor the bytes tell. */
     mimeType?: string;
+    /**
+     * Keep the file in your Segmind asset library and return a URL that does not
+     * expire, as the Python SDK's upload does. By default the file is a temporary
+     * model input, kept for at least two days.
+     */
+    persist?: boolean;
     signal?: AbortSignal;
 }
 interface UploadedFile {
@@ -154,11 +160,13 @@ interface UploadedFile {
     url: string;
     filename: string;
     size: number;
+    /** True when the file is in your asset library and the URL does not expire. */
+    persistent: boolean;
 }
 /**
  * Uploads files to pass as model inputs. Each file goes straight to storage on
  * a presigned URL, so large videos never travel as base64 JSON. The URLs are
- * public and temporary: the files are kept for at least two days.
+ * public. They are temporary unless you pass `persist: true`.
  */
 declare class Files {
     private readonly client;
@@ -168,6 +176,12 @@ declare class Files {
     /** Uploads several files, in order. */
     upload(files: FileInput[], options?: Omit<UploadOptions, 'filename'>): Promise<UploadedFile[]>;
     private uploadOne;
+    /** A temporary model input on the inference API's input bucket. */
+    private stage;
+    /** A file in the caller's asset library: presign, PUT, then confirm to register it. */
+    private persist;
+    /** A PUT to the same key is idempotent, so it retries. `bare` keeps the API key off the storage host. */
+    private put;
 }
 
 /** One page of a paginated list. */
@@ -391,11 +405,20 @@ declare class Webhooks {
     add(webhookUrl: string, eventTypes: WebhookEventType[], options?: {
         signal?: AbortSignal;
     }): Promise<Webhook>;
-    /** Changes a registration's URL and event types. */
-    update(webhookId: string, webhookUrl: string, eventTypes: WebhookEventType[], options?: {
+    /**
+     * 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.
+     */
+    update(webhookId: string, webhookUrl: string, _eventTypes?: WebhookEventType[], options?: {
         signal?: AbortSignal;
     }): Promise<Record<string, unknown>>;
-    /** Deactivates a registration. */
+    /**
+     * Deactivates a registration. Not retried: a second attempt after a lost
+     * response would report the registration as already deactivated.
+     */
     delete(webhookId: string, options?: {
         signal?: AbortSignal;
     }): Promise<Record<string, unknown>>;
@@ -418,6 +441,8 @@ interface ClientOptions {
     spotURL?: string;
     /** The account API. Default https://cloud.segmind.com/api. */
     consoleURL?: string;
+    /** The asset library API, for persistent uploads. Default https://platform-api.segmind.com. */
+    assetsURL?: string;
     /** Milliseconds per HTTP request. Default 600 000. */
     timeout?: number;
     /** Retries for requests that cannot bill twice. Default 2. */
@@ -445,6 +470,7 @@ declare class Segmind {
     readonly baseURL: string;
     readonly spotURL: string;
     readonly consoleURL: string;
+    readonly assetsURL: string;
     readonly models: Models;
     readonly accounts: Accounts;
     /** Upload files to pass as model inputs. */
@@ -581,7 +607,7 @@ declare class InferenceTimeout extends SegmindError {
     constructor(requestId: string, elapsedMs: number);
 }
 
-declare const VERSION = "0.2.2";
+declare const VERSION = "0.2.4";
 
 /** `new Segmind().run(...)` with the key from `SEGMIND_API_KEY`. */
 declare const run: (slug: string, params?: Params, options?: RunOptions) => Promise<RunResult>;

package/dist/index.js

@@ -423,12 +423,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) {
@@ -437,16 +441,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 });
   }
 };
 
@@ -684,7 +713,7 @@ function failureDetail(body) {
 }
 
 // src/version.ts
-var VERSION = "0.2.2";
+var VERSION = "0.2.4";
 
 // src/webhooks.ts
 var Webhooks = class {
@@ -703,16 +732,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 = {}) {
@@ -733,10 +772,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. */
@@ -765,6 +806,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}`;
@@ -857,7 +899,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);
@@ -918,6 +960,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(/\/+$/, "");
 }