segmind 0.1.0 → 0.2.0

package/dist/index.js

@@ -34,8 +34,8 @@ var APIConnectionError = class extends SegmindError {
 var InferenceFailed = class extends SegmindError {
   /** The status body that reported the failure. */
   statusBody;
-  constructor(requestId, statusBody) {
-    const detail = typeof statusBody.error === "string" ? statusBody.error : void 0;
+  constructor(requestId, statusBody, detail) {
+    detail ??= typeof statusBody.error === "string" ? statusBody.error : void 0;
     super(detail ? `request ${requestId} failed: ${detail}` : `request ${requestId} failed`, {
       detail,
       requestId,
@@ -272,14 +272,15 @@ var HttpClient = class {
     }, timeout);
     const onAbort = () => controller.abort(signal.reason);
     signal?.addEventListener("abort", onAbort, { once: true });
-    const headers = { ...this.config.headers, ...req.headers };
-    if (this.config.apiKey) headers["x-api-key"] = this.config.apiKey;
+    const headers = req.bare ? { ...req.headers } : { ...this.config.headers, ...req.headers };
+    if (this.config.apiKey && !req.bare) headers["x-api-key"] = this.config.apiKey;
     if (req.body !== void 0) headers["content-type"] = "application/json";
+    const body = req.rawBody ?? (req.body === void 0 ? void 0 : JSON.stringify(req.body));
     try {
-      return await this.config.fetch(req.url, {
+      return await this.config.fetch(withQuery(req.url, req.query), {
         method: req.method,
         headers,
-        body: req.body === void 0 ? void 0 : JSON.stringify(req.body),
+        body,
         signal: controller.signal
       });
     } catch (err) {
@@ -304,6 +305,15 @@ async function readJson(response) {
     });
   }
 }
+function withQuery(url, query) {
+  if (!query) return url;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${url}${url.includes("?") ? "&" : "?"}${qs}` : url;
+}
 function describe(err) {
   if (err instanceof Error) {
     const cause = err.cause;
@@ -312,6 +322,182 @@ function describe(err) {
   return String(err);
 }
 
+// src/core/input.ts
+var MIME_BY_EXTENSION = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  heic: "image/heic",
+  heif: "image/heif",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  avif: "image/avif",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  avi: "video/x-msvideo",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  aac: "audio/aac",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  json: "application/json",
+  glb: "model/gltf-binary"
+};
+var EXTENSION_BY_MIME = Object.fromEntries(
+  Object.entries(MIME_BY_EXTENSION).map(([ext, mime]) => [mime, ext])
+);
+EXTENSION_BY_MIME["image/jpeg"] = "jpg";
+function mimeFromName(name) {
+  const extension = name.includes(".") ? name.split(".").pop().toLowerCase() : "";
+  return MIME_BY_EXTENSION[extension];
+}
+async function readFileInput(input, options) {
+  let bytes;
+  let name = options.filename;
+  let mimeType = options.mimeType;
+  if (typeof input === "string") {
+    if (detectRuntime() !== "node") {
+      throw new SegmindError(`${options.caller}: file paths work in Node only; pass a Blob or bytes`);
+    }
+    const { readFile } = await import("node:fs/promises");
+    try {
+      bytes = new Uint8Array(await readFile(input));
+    } catch (err) {
+      throw new SegmindError(`${options.caller}: cannot read ${JSON.stringify(input)}: ${err.message}`, {
+        cause: err
+      });
+    }
+    name ??= input.split(/[\\/]/).pop();
+  } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+    bytes = new Uint8Array(await input.arrayBuffer());
+    name ??= input.name || void 0;
+    mimeType ??= input.type || void 0;
+  } else {
+    bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  }
+  mimeType ??= name && mimeFromName(name) || sniff(bytes);
+  if (!name || !name.includes(".")) {
+    const extension = mimeType ? EXTENSION_BY_MIME[mimeType] : void 0;
+    if (!extension) {
+      throw new SegmindError(`${options.caller}: cannot tell the file type; pass { filename: 'name.ext' } or { mimeType }`);
+    }
+    name = `${name || "upload"}.${extension}`;
+  }
+  return { bytes, filename: name, mimeType };
+}
+function sniff(bytes) {
+  const at = (offset, signature) => signature.every((b, i) => bytes[offset + i] === b);
+  if (at(0, [137, 80, 78, 71])) return "image/png";
+  if (at(0, [255, 216, 255])) return "image/jpeg";
+  if (at(0, [71, 73, 70, 56])) return "image/gif";
+  if (at(0, [82, 73, 70, 70]) && at(8, [87, 69, 66, 80])) return "image/webp";
+  if (at(0, [82, 73, 70, 70]) && at(8, [87, 65, 86, 69])) return "audio/wav";
+  if (at(4, [102, 116, 121, 112])) return "video/mp4";
+  if (at(0, [73, 68, 51]) || at(0, [255, 251])) return "audio/mpeg";
+  if (at(0, [37, 80, 68, 70])) return "application/pdf";
+  return void 0;
+}
+
+// src/files.ts
+var Files = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  async upload(input, options = {}) {
+    if (Array.isArray(input)) {
+      const uploaded = [];
+      for (const file of input) uploaded.push(await this.uploadOne(file, { ...options, filename: void 0 }));
+      return uploaded;
+    }
+    return this.uploadOne(input, options);
+  }
+  async uploadOne(input, options) {
+    const file = await readFileInput(input, { ...options, caller: "files.upload" });
+    const { http } = this.client;
+    const ticket = await http.json({
+      method: "POST",
+      url: `${this.client.spotURL}/inference-request/input-presign`,
+      body: { filename: file.filename, size: file.bytes.byteLength },
+      signal: options.signal,
+      retry: true
+    });
+    if (!ticket.upload_url || !ticket.url) {
+      throw new SegmindError("files.upload: the presign response had no upload_url or url", { body: ticket });
+    }
+    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,
+      retry: true
+    });
+    return { url: ticket.url, filename: file.filename, size: file.bytes.byteLength };
+  }
+};
+
+// src/generations.ts
+var Generations = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  /** Generated outputs, newest first. */
+  async list(options = {}) {
+    return this.read("/inference-request/generations", options.signal, {
+      page: options.page ?? 1,
+      model_name: options.modelName,
+      start_date: options.startDate,
+      end_date: options.endDate,
+      user_id: options.userId
+    });
+  }
+  /** The newest generations for one model. */
+  async recent(modelName, options = {}) {
+    return this.read("/inference-request/recent-generations", options.signal, { model_name: modelName });
+  }
+  /**
+   * Requests with their cost, inputs and outcome, failures included. A request
+   * with several outputs appears once per output, each carrying its full cost:
+   * de-duplicate on `request_id` before summing.
+   */
+  async history(options = {}) {
+    return this.read("/inference-request/request-history", options.signal, {
+      page: options.page ?? 1,
+      per_page: options.perPage ?? 20,
+      from_date: options.fromDate,
+      to_date: options.toDate,
+      model_name: options.modelName,
+      status: options.status,
+      user_id: options.userId,
+      user_email: options.userEmail,
+      sort_by: options.sortBy,
+      sort_order: options.sortOrder
+    });
+  }
+  /** One of your own requests, of any age. A teammate's request id is not found. */
+  async get(requestId, options = {}) {
+    return this.read(`/inference-request/request-history/${encodeURIComponent(requestId)}`, options.signal);
+  }
+  read(path2, signal, query) {
+    return this.client.http.json({ method: "GET", url: `${this.client.spotURL}${path2}`, query, signal, retry: true });
+  }
+};
+
 // src/job.ts
 var DEFAULT_WAIT_TIMEOUT_MS = 6e5;
 var DEFAULT_WAIT_INTERVAL_MS = 1e3;
@@ -381,8 +567,167 @@ var Job = class {
   }
 };
 
+// src/pixelflows.ts
+var DONE = /* @__PURE__ */ new Set(["COMPLETED", "SUCCESS", "SUCCEEDED"]);
+var FAILED = /* @__PURE__ */ new Set(["FAILED", "ERROR"]);
+var DEFAULT_TIMEOUT_MS = 6e5;
+var DEFAULT_INTERVAL_MS = 2e3;
+var PixelFlows = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  /** Runs a workflow and waits for its outputs. */
+  async run(slug, inputs = {}, options = {}) {
+    const job = await this.submit(slug, inputs, options);
+    return job.wait(options);
+  }
+  /** Starts a workflow and returns a job to wait on. Never retried: a run bills. */
+  async submit(slug, inputs = {}, options = {}) {
+    const clean = slug.trim().replace(/^\/+/, "");
+    if (!clean) throw new SegmindError("pixelflows: a workflow slug is required");
+    const route = options.engine === "v1" ? "/workflows/" : "/workflows/v2/";
+    const body = await this.client.http.json({
+      method: "POST",
+      url: `${this.client.baseURL}${route}${clean}`,
+      body: inputs,
+      signal: options.signal
+    });
+    const requestId = body.request_id;
+    if (typeof requestId !== "string" || !requestId) {
+      throw new SegmindError("pixelflows: the submit response had no request_id", { body });
+    }
+    return new PixelflowJob(this, requestId);
+  }
+  /** A run's current state, without waiting. */
+  async getStatus(requestId, options = {}) {
+    const raw = await this.client.http.json({
+      method: "GET",
+      url: `${this.client.baseURL}/workflows/request/${encodeURIComponent(requestId)}`,
+      signal: options.signal,
+      retry: true
+    });
+    return toStatus(raw);
+  }
+  /** Waits for a run started earlier, by its request id. */
+  async poll(requestId, options = {}) {
+    return new PixelflowJob(this, requestId).wait(options);
+  }
+};
+var PixelflowJob = class {
+  constructor(pixelflows2, requestId) {
+    this.pixelflows = pixelflows2;
+    this.requestId = requestId;
+  }
+  pixelflows;
+  requestId;
+  status(options = {}) {
+    return this.pixelflows.getStatus(this.requestId, options);
+  }
+  /**
+   * Polls until the run finishes. Throws `InferenceFailed` (its `detail` names
+   * the failing node) or `InferenceTimeout`; the run may still finish after a
+   * timeout, so `wait()` can be called again.
+   */
+  async wait(options = {}) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    const interval = options.interval ?? DEFAULT_INTERVAL_MS;
+    const started = Date.now();
+    for (; ; ) {
+      const state = await this.status({ signal: options.signal });
+      if (DONE.has(state.status)) return state;
+      if (FAILED.has(state.status)) throw new InferenceFailed(this.requestId, state.raw, failureDetail(state.raw));
+      const elapsed = Date.now() - started;
+      if (elapsed + interval > timeout) throw new InferenceTimeout(this.requestId, elapsed);
+      await sleep(interval, options.signal);
+    }
+  }
+};
+function toStatus(body) {
+  const raw = { ...body };
+  if (typeof raw.output === "string") {
+    try {
+      raw.output = JSON.parse(raw.output);
+    } catch {
+    }
+  }
+  const status = String(raw.status ?? "UNKNOWN").toUpperCase();
+  return { status, outputs: DONE.has(status) ? flattenOutputs(raw.output) : {}, raw };
+}
+function flattenOutputs(output) {
+  const outputs = {};
+  if (Array.isArray(output)) {
+    for (const item of output) {
+      if (item && typeof item === "object" && typeof item.keyname === "string") {
+        const { keyname, value } = item;
+        outputs[keyname] = unwrap(value);
+      }
+    }
+  } else if (output && typeof output === "object") {
+    for (const [key, value] of Object.entries(output)) outputs[key] = unwrap(value);
+  }
+  return outputs;
+}
+function unwrap(value) {
+  if (value && typeof value === "object" && "data" in value) return value.data;
+  return value;
+}
+function failureDetail(body) {
+  const error = body.error_message ?? body.error;
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    const e = error;
+    const text = e.details ?? e.error_message ?? e.error;
+    if (typeof text === "string") return text;
+  }
+  return void 0;
+}
+
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
+
+// src/webhooks.ts
+var Webhooks = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  /** Every registration; `[]` when you have none. */
+  async get(options = {}) {
+    return this.call("GET", "/get", { signal: options.signal, retry: true });
+  }
+  /** Registers an endpoint for the given event types. */
+  async add(webhookUrl, eventTypes, options = {}) {
+    return this.call("POST", "/add", {
+      body: { webhook_url: webhookUrl, event: { types: requireTypes(eventTypes) } },
+      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
+    });
+  }
+  /** Deactivates a registration. */
+  async delete(webhookId, options = {}) {
+    return this.call("GET", "/inactive", { query: { webhook_id: webhookId }, signal: options.signal, retry: true });
+  }
+  /** Delivery history for one registration. */
+  async logs(webhookId, options = {}) {
+    return this.call("GET", "/dispatch-logs", { query: { webhook_id: webhookId }, signal: options.signal, retry: true });
+  }
+  call(method, path2, req) {
+    return this.client.http.json({ method, url: `${this.client.spotURL}/webhook${path2}`, ...req });
+  }
+};
+function requireTypes(eventTypes) {
+  if (!Array.isArray(eventTypes) || eventTypes.length === 0) {
+    throw new SegmindError('webhooks: pass at least one event type, e.g. ["PIXELFLOW_API_RUN"]');
+  }
+  return eventTypes;
+}
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.segmind.com";
@@ -394,6 +739,14 @@ var Segmind = class {
   consoleURL;
   models;
   accounts;
+  /** Upload files to pass as model inputs. */
+  files;
+  /** Your generations and request history. */
+  generations;
+  /** Your webhook registrations. */
+  webhooks;
+  /** Run published PixelFlow workflows. */
+  pixelflows;
   /** @internal */
   http;
   constructor(options = {}) {
@@ -424,6 +777,10 @@ var Segmind = class {
     });
     this.models = new Models(this);
     this.accounts = new Accounts(this);
+    this.files = new Files(this);
+    this.generations = new Generations(this);
+    this.webhooks = new Webhooks(this);
+    this.pixelflows = new PixelFlows(this);
   }
   /**
    * Runs a model and returns its result: submits to the v2 queue, then polls
@@ -569,62 +926,12 @@ function trimBase(url) {
 }
 
 // src/image-url.ts
-var MIME_BY_EXTENSION = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  bmp: "image/bmp",
-  svg: "image/svg+xml",
-  heic: "image/heic",
-  heif: "image/heif",
-  tif: "image/tiff",
-  tiff: "image/tiff",
-  avif: "image/avif"
-};
 async function imageUrl(input, options = {}) {
-  return { type: "image_url", image_url: { url: await toDataUri(input, options.mimeType) } };
-}
-async function toDataUri(input, mimeType) {
-  if (typeof input === "string") {
-    if (/^(https?:|data:)/i.test(input)) return input;
-    if (detectRuntime() !== "node") {
-      throw new SegmindError(`imageUrl: ${JSON.stringify(input)} is not an http(s) or data: URL (file paths work in Node only)`);
-    }
-    return fileToDataUri(input, mimeType);
+  if (typeof input === "string" && /^(https?:|data:)/i.test(input)) {
+    return { type: "image_url", image_url: { url: input } };
   }
-  if (typeof Blob !== "undefined" && input instanceof Blob) {
-    const bytes2 = new Uint8Array(await input.arrayBuffer());
-    return dataUri(bytes2, mimeType ?? (input.type || sniff(bytes2)));
-  }
-  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
-  return dataUri(bytes, mimeType ?? sniff(bytes));
-}
-async function fileToDataUri(path2, mimeType) {
-  const { readFile } = await import("node:fs/promises");
-  let bytes;
-  try {
-    bytes = new Uint8Array(await readFile(path2));
-  } catch (err) {
-    throw new SegmindError(`imageUrl: cannot read ${JSON.stringify(path2)}: ${err.message}`, { cause: err });
-  }
-  const extension = path2.split(".").pop()?.toLowerCase() ?? "";
-  return dataUri(bytes, mimeType ?? MIME_BY_EXTENSION[extension] ?? sniff(bytes));
-}
-function dataUri(bytes, mimeType) {
-  if (!mimeType) {
-    throw new SegmindError("imageUrl: cannot tell the image type; pass { mimeType }");
-  }
-  return `data:${mimeType};base64,${toBase64(bytes)}`;
-}
-function sniff(bytes) {
-  const at = (offset, signature) => signature.every((b, i) => bytes[offset + i] === b);
-  if (at(0, [137, 80, 78, 71])) return "image/png";
-  if (at(0, [255, 216, 255])) return "image/jpeg";
-  if (at(0, [71, 73, 70, 56])) return "image/gif";
-  if (at(0, [82, 73, 70, 70]) && at(8, [87, 69, 66, 80])) return "image/webp";
-  return void 0;
+  const file = await readFileInput(input, { mimeType: options.mimeType, caller: "imageUrl" });
+  return { type: "image_url", image_url: { url: `data:${file.mimeType};base64,${toBase64(file.bytes)}` } };
 }
 
 // src/index.ts
@@ -645,6 +952,28 @@ var models = {
 var accounts = {
   current: (options) => client().accounts.current(options)
 };
+var files = {
+  upload: ((input, options) => client().files.upload(input, options))
+};
+var generations = {
+  list: (options) => client().generations.list(options),
+  recent: (modelName, options) => client().generations.recent(modelName, options),
+  history: (options) => client().generations.history(options),
+  get: (requestId, options) => client().generations.get(requestId, options)
+};
+var webhooks = {
+  get: (options) => client().webhooks.get(options),
+  add: (webhookUrl, eventTypes, options) => client().webhooks.add(webhookUrl, eventTypes, options),
+  update: (webhookId, webhookUrl, eventTypes, options) => client().webhooks.update(webhookId, webhookUrl, eventTypes, options),
+  delete: (webhookId, options) => client().webhooks.delete(webhookId, options),
+  logs: (webhookId, options) => client().webhooks.logs(webhookId, options)
+};
+var pixelflows = {
+  run: (slug, inputs, options) => client().pixelflows.run(slug, inputs, options),
+  submit: (slug, inputs, options) => client().pixelflows.submit(slug, inputs, options),
+  getStatus: (requestId, options) => client().pixelflows.getStatus(requestId, options),
+  poll: (requestId, options) => client().pixelflows.poll(requestId, options)
+};
 export {
   APIConnectionError,
   Accounts,
@@ -654,21 +983,30 @@ export {
   DEFAULT_SPOT_URL,
   DEFAULT_WAIT_INTERVAL_MS,
   DEFAULT_WAIT_TIMEOUT_MS,
+  Files,
+  Generations,
   InferenceFailed,
   InferenceTimeout,
   Job,
   Models,
+  PixelFlows,
+  PixelflowJob,
   Segmind,
   SegmindError,
   VERSION,
+  Webhooks,
   accounts,
   chat,
   chatSync,
+  files,
+  generations,
   imageUrl,
   models,
+  pixelflows,
   run,
   runSync,
   submit,
-  submitChat
+  submitChat,
+  webhooks
 };
 //# sourceMappingURL=index.js.map