segmind 0.0.1 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1012 @@
+// src/core/errors.ts
+var SegmindError = class _SegmindError extends Error {
+  /** HTTP status, when the error came from a response. */
+  status;
+  /** The server's error text (`error` in the response body), when it sent one. */
+  detail;
+  /** The v2 request id the error belongs to, when there is one. */
+  requestId;
+  /** The parsed response body, or its text when it was not JSON. */
+  body;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = new.target.name;
+    this.status = options.status;
+    this.detail = options.detail;
+    this.requestId = options.requestId;
+    this.body = options.body;
+  }
+  /** Reads the response body and builds the error. Consumes the body. */
+  static async fromResponse(response, requestId) {
+    const text = await response.text().catch(() => "");
+    let body = text;
+    try {
+      body = text ? JSON.parse(text) : void 0;
+    } catch {
+    }
+    const detail = errorDetail(body) ?? (typeof body === "string" && body ? body.slice(0, 500) : void 0);
+    const message = detail ? `${response.status} ${detail}` : `${response.status} ${response.statusText || "request failed"}`;
+    return new _SegmindError(message, { status: response.status, detail, requestId, body });
+  }
+};
+var APIConnectionError = class extends SegmindError {
+};
+var InferenceFailed = class extends SegmindError {
+  /** The status body that reported the failure. */
+  statusBody;
+  constructor(requestId, statusBody, detail) {
+    detail ??= typeof statusBody.error === "string" ? statusBody.error : void 0;
+    super(detail ? `request ${requestId} failed: ${detail}` : `request ${requestId} failed`, {
+      detail,
+      requestId,
+      body: statusBody
+    });
+    this.statusBody = statusBody;
+  }
+};
+var InferenceTimeout = class extends SegmindError {
+  elapsedMs;
+  constructor(requestId, elapsedMs) {
+    super(`request ${requestId} did not finish within ${Math.round(elapsedMs)} ms`, { requestId });
+    this.elapsedMs = elapsedMs;
+  }
+};
+function errorDetail(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const record2 = body;
+  for (const key of ["error", "message", "detail"]) {
+    const value = record2[key];
+    if (typeof value === "string" && value) return value;
+    if (value && typeof value === "object" && typeof value.message === "string") {
+      return value.message;
+    }
+  }
+  return void 0;
+}
+
+// src/chat.ts
+var ChatResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  raw;
+  /** The assistant's text. Throws when the body holds none (inspect `raw`). */
+  get text() {
+    const text = extractText(this.raw);
+    if (text === void 0) {
+      throw new SegmindError(
+        `could not find assistant text in the response (top-level keys: ${Object.keys(this.raw).sort().join(", ")}); inspect ChatResponse.raw`,
+        { body: this.raw }
+      );
+    }
+    return text;
+  }
+  /** `text` parsed as JSON, for JSON mode and structured outputs. */
+  json() {
+    const text = this.text;
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new SegmindError(`ChatResponse.text is not valid JSON: ${err.message}`, {
+        body: text,
+        cause: err
+      });
+    }
+  }
+  /** The provider's token usage (`usage` or Gemini's `usageMetadata`). */
+  get usage() {
+    return (record(this.raw.usage) ?? record(this.raw.usageMetadata)) || void 0;
+  }
+  /** Why generation stopped (`finish_reason`, `stop_reason` or `finishReason`). */
+  get finishReason() {
+    if (Array.isArray(this.raw.choices)) return str(record(this.raw.choices[0])?.finish_reason);
+    if ("stop_reason" in this.raw) return str(this.raw.stop_reason);
+    if (Array.isArray(this.raw.candidates)) return str(record(this.raw.candidates[0])?.finishReason);
+    return void 0;
+  }
+  /** Tool calls in the OpenAI shape, when the model made any. */
+  get toolCalls() {
+    if (!Array.isArray(this.raw.choices)) return [];
+    const calls = record(record(this.raw.choices[0])?.message)?.tool_calls;
+    return Array.isArray(calls) ? calls : [];
+  }
+};
+function chatBody(params) {
+  if (params.messages === void 0 && params.prompt === void 0) {
+    throw new SegmindError('chat: pass messages: [...] or prompt: "..."');
+  }
+  if (params.stream === true) {
+    throw new SegmindError("chat: streaming is not supported yet; omit stream or set it to false");
+  }
+  return params;
+}
+function chatFromRunResult(body) {
+  const output = body.output;
+  if (typeof output === "string") {
+    try {
+      const parsed = JSON.parse(output);
+      if (record(parsed)) return new ChatResponse(parsed);
+    } catch {
+    }
+    return new ChatResponse({ choices: [{ message: { content: output } }] });
+  }
+  if (record(output)) return new ChatResponse(output);
+  return new ChatResponse(body);
+}
+function extractText(raw) {
+  if ("choices" in raw) {
+    const content = record(record(Array.isArray(raw.choices) ? raw.choices[0] : void 0)?.message)?.content;
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.map(record).filter((part) => part && (part.type === void 0 || part.type === "text")).map((part) => str(part.text) ?? "").join("");
+    }
+    return void 0;
+  }
+  if (Array.isArray(raw.content)) {
+    return raw.content.map(record).filter((part) => part?.type === "text").map((part) => str(part.text) ?? "").join("");
+  }
+  if ("candidates" in raw) {
+    const candidate = record(Array.isArray(raw.candidates) ? raw.candidates[0] : void 0);
+    const parts = record(candidate?.content)?.parts;
+    if (!Array.isArray(parts)) return candidate ? "" : void 0;
+    return parts.map((part) => str(record(part)?.text) ?? "").join("");
+  }
+  return void 0;
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/core/env.ts
+var g = globalThis;
+function detectRuntime() {
+  if (g.navigator?.product === "ReactNative") return "react-native";
+  if (typeof g.window !== "undefined" && typeof g.document !== "undefined") return "browser";
+  if (g.process?.versions?.node) return "node";
+  return "other";
+}
+function readEnv(name) {
+  try {
+    const value = g.process?.env?.[name];
+    return value?.trim() ? value.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function nodeVersion() {
+  return g.process?.versions?.node ? g.process.version : void 0;
+}
+function randomRequestId() {
+  const uuid = g.crypto?.randomUUID?.();
+  if (uuid) return uuid;
+  let id = "";
+  for (let i = 0; i < 32; i++) id += Math.floor(Math.random() * 16).toString(16);
+  return id;
+}
+function toBase64(bytes) {
+  if (g.Buffer) return g.Buffer.from(bytes).toString("base64");
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+
+// src/core/http.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 502, 503, 504]);
+var MAX_RETRY_DELAY_MS = 6e4;
+function retryDelay(attempt, retryAfter, now = Date.now()) {
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, MAX_RETRY_DELAY_MS);
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) return Math.min(Math.max(date - now, 0), MAX_RETRY_DELAY_MS);
+  }
+  const base = Math.min(500 * 2 ** attempt, 8e3);
+  return base * (0.75 + Math.random() * 0.25);
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(signal.reason);
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  /** The response whatever its status, after retries when `retry` is set. */
+  async fetchRaw(req) {
+    for (let attempt = 0; ; attempt++) {
+      const canRetry = req.retry === true && attempt < this.config.maxRetries;
+      let response;
+      try {
+        response = await this.attempt(req);
+      } catch (err) {
+        if (canRetry && err instanceof APIConnectionError) {
+          await sleep(retryDelay(attempt, null), req.signal);
+          continue;
+        }
+        throw err;
+      }
+      if (canRetry && RETRYABLE_STATUS.has(response.status)) {
+        await response.body?.cancel().catch(() => void 0);
+        await sleep(retryDelay(attempt, response.headers.get("retry-after")), req.signal);
+        continue;
+      }
+      return response;
+    }
+  }
+  /** The response, or a `SegmindError` for any status outside 2xx. */
+  async request(req) {
+    const response = await this.fetchRaw(req);
+    if (!response.ok) throw await SegmindError.fromResponse(response);
+    return response;
+  }
+  /** The parsed JSON body of a 2xx response. */
+  async json(req) {
+    return readJson(await this.request(req));
+  }
+  async attempt(req) {
+    const { signal } = req;
+    if (signal?.aborted) throw signal.reason;
+    const timeout = req.timeout ?? this.config.timeout;
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    const onAbort = () => controller.abort(signal.reason);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    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(withQuery(req.url, req.query), {
+        method: req.method,
+        headers,
+        body,
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (signal?.aborted) throw signal.reason ?? err;
+      const reason = timedOut ? `request timed out after ${timeout} ms` : `connection error: ${describe(err)}`;
+      throw new APIConnectionError(`${req.method} ${req.url}: ${reason}`, { cause: err });
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+};
+async function readJson(response) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    throw new SegmindError(`${response.status} response was not JSON`, {
+      status: response.status,
+      body: text.slice(0, 500),
+      cause: err
+    });
+  }
+}
+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;
+    return cause instanceof Error ? `${err.message} (${cause.message})` : err.message;
+  }
+  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;
+var TERMINAL = /* @__PURE__ */ new Set(["COMPLETED", "FAILED"]);
+var Job = class {
+  constructor(http, submitResponse, transform = (body) => body) {
+    this.http = http;
+    this.submitResponse = submitResponse;
+    this.transform = transform;
+    this.requestId = submitResponse.request_id;
+    this.statusUrl = submitResponse.status_url;
+    this.responseUrl = submitResponse.response_url;
+  }
+  http;
+  submitResponse;
+  transform;
+  requestId;
+  statusUrl;
+  responseUrl;
+  /** The current state, without waiting. */
+  async status(options = {}) {
+    return await this.read(this.statusUrl, options.signal);
+  }
+  /**
+   * The finished result. Throws `InferenceFailed` when the request failed, and
+   * a `SegmindError` when it has not finished yet (use `wait()` for that).
+   */
+  async result(options = {}) {
+    const body = await this.read(this.responseUrl, options.signal);
+    if (body.status === "FAILED") throw new InferenceFailed(this.requestId, body);
+    if (body.status !== void 0 && body.status !== "COMPLETED") {
+      throw new SegmindError(`request ${this.requestId} is still ${String(body.status)}; use wait()`, {
+        requestId: this.requestId,
+        body
+      });
+    }
+    return this.transform(body);
+  }
+  /** Polls until the request finishes, then returns its result. */
+  async wait(options = {}) {
+    const timeout = options.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+    const interval = options.interval ?? DEFAULT_WAIT_INTERVAL_MS;
+    const started = Date.now();
+    for (; ; ) {
+      const status = await this.status({ signal: options.signal });
+      if (status.status === "COMPLETED") return this.result({ signal: options.signal });
+      if (status.status === "FAILED") throw new InferenceFailed(this.requestId, status);
+      const elapsed = Date.now() - started;
+      if (elapsed >= timeout) throw new InferenceTimeout(this.requestId, elapsed);
+      await sleep(Math.min(interval, timeout - elapsed), options.signal);
+    }
+  }
+  /**
+   * The gateway serves a FAILED request's body with HTTP 422 on both the status
+   * and result URLs. A body that names a terminal state is the answer whatever
+   * its status code; anything else outside 2xx is a real error.
+   */
+  async read(url, signal) {
+    const response = await this.http.fetchRaw({ method: "GET", url, signal, retry: true });
+    if (response.ok) return readJson(response);
+    const error = await SegmindError.fromResponse(response, this.requestId);
+    const body = error.body;
+    if (body && typeof body === "object" && TERMINAL.has(String(body.status))) {
+      return body;
+    }
+    throw error;
+  }
+};
+
+// 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.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";
+var DEFAULT_SPOT_URL = "https://api.spotprod.segmind.com";
+var DEFAULT_CONSOLE_URL = "https://cloud.segmind.com/api";
+var Segmind = class {
+  baseURL;
+  spotURL;
+  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 = {}) {
+    const apiKey = options.apiKey ?? readEnv("SEGMIND_API_KEY");
+    const runtime = detectRuntime();
+    if (apiKey && (runtime === "browser" || runtime === "react-native") && !options.dangerouslyAllowBrowser) {
+      throw new SegmindError(
+        "An API key in a browser or mobile app exposes it to every user. Call Segmind from your backend instead, or pass dangerouslyAllowBrowser: true if you accept that risk."
+      );
+    }
+    if (!apiKey) {
+      throw new SegmindError("Missing API key: pass { apiKey } or set the SEGMIND_API_KEY environment variable.");
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
+    if (!fetchImpl) throw new SegmindError("No fetch implementation available: pass { fetch }.");
+    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);
+    const headers = { "X-Initiator": "SDK-JS", ...options.defaultHeaders };
+    const node = nodeVersion();
+    if (runtime === "node" && node) headers["User-Agent"] = `segmind-js/${VERSION} node/${node}`;
+    this.http = new HttpClient({
+      apiKey,
+      fetch: fetchImpl,
+      timeout: options.timeout ?? 6e5,
+      maxRetries: options.maxRetries ?? 2,
+      headers
+    });
+    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
+   * until it finishes. `params` go to the model unchanged.
+   */
+  async run(slug, params = {}, options = {}) {
+    const job = await this.submit(slug, params, options);
+    return job.wait(options);
+  }
+  /**
+   * One blocking `POST /v1/{slug}`. Returns the fetch `Response`: call
+   * `.arrayBuffer()` for media or `.json()` for JSON models. Never retried,
+   * because the call bills.
+   */
+  async runSync(slug, params = {}, options = {}) {
+    return this.http.request({
+      method: "POST",
+      url: `${this.baseURL}/v1/${path(slug)}`,
+      body: params,
+      signal: options.signal,
+      timeout: options.timeout
+    });
+  }
+  /**
+   * Submits to the v2 queue and returns a `Job` to wait on. Safe to retry: the
+   * submit carries an `X-Request-ID`, and the gateway answers a repeat with
+   * the existing request rather than a second one.
+   */
+  async submit(slug, params = {}, options = {}) {
+    return this.submitJob(slug, params, options, (body) => body);
+  }
+  /** Chat with an LLM through the v2 queue. Returns a provider-neutral reply. */
+  async chat(slug, params, options = {}) {
+    const job = await this.submitChat(slug, params, options);
+    return job.wait(options);
+  }
+  /** Chat with one blocking `POST /v1/{slug}`. */
+  async chatSync(slug, params, options = {}) {
+    const response = await this.runSync(slug, chatBody(params), options);
+    return new ChatResponse(await readJson(response));
+  }
+  /** Submits a chat to the v2 queue and returns a `Job` whose result is a `ChatResponse`. */
+  async submitChat(slug, params, options = {}) {
+    return this.submitJob(slug, chatBody(params), options, chatFromRunResult);
+  }
+  async submitJob(slug, params, options, transform) {
+    const url = `${this.baseURL}/v2/${path(slug)}`;
+    const maxRetries = this.http.config.maxRetries;
+    let requestId = options.requestId ?? randomRequestId();
+    for (let attempt = 0; ; attempt++) {
+      const canRetry = attempt < maxRetries;
+      let response;
+      try {
+        response = await this.http.fetchRaw({
+          method: "POST",
+          url,
+          body: params,
+          headers: { "X-Request-ID": requestId },
+          signal: options.signal
+        });
+      } catch (err) {
+        if (canRetry && err instanceof APIConnectionError) {
+          await sleep(retryDelay(attempt, null), options.signal);
+          continue;
+        }
+        throw err;
+      }
+      if (response.ok || response.status === 409) {
+        const body = await readJson(response);
+        if (response.status === 409 && !body.status_url) {
+          throw new SegmindError(`409 ${String(body.error ?? "conflict")}`, {
+            status: 409,
+            requestId,
+            body
+          });
+        }
+        return new Job(this.http, validateSubmit(body, response.status), transform);
+      }
+      if (canRetry && response.status === 503) {
+        await response.body?.cancel().catch(() => void 0);
+        requestId = randomRequestId();
+        await sleep(retryDelay(attempt, response.headers.get("retry-after")), options.signal);
+        continue;
+      }
+      if (canRetry && (response.status === 429 || response.status === 502 || response.status === 504)) {
+        await response.body?.cancel().catch(() => void 0);
+        await sleep(retryDelay(attempt, response.headers.get("retry-after")), options.signal);
+        continue;
+      }
+      throw await SegmindError.fromResponse(response, requestId);
+    }
+  }
+};
+var Models = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  /** Every model in the catalog, under the key `Inference Model Information List`. */
+  async list(options = {}) {
+    return this.client.http.json({
+      method: "GET",
+      url: `${this.client.spotURL}/inference-model-information/list`,
+      signal: options.signal,
+      retry: true
+    });
+  }
+};
+var Accounts = class {
+  constructor(client2) {
+    this.client = client2;
+  }
+  client;
+  /** Account details for the API key. */
+  async current(options = {}) {
+    return this.client.http.json({
+      method: "GET",
+      url: `${this.client.consoleURL}/auth/authenticate`,
+      signal: options.signal,
+      retry: true
+    });
+  }
+};
+function validateSubmit(body, status) {
+  if (!body.request_id || !body.status_url || !body.response_url) {
+    throw new SegmindError(
+      `v2 submit returned ${status} without request_id, status_url and response_url (keys: ${Object.keys(body).sort().join(", ")})`,
+      { status, body }
+    );
+  }
+  return body;
+}
+function path(slug) {
+  const clean = slug.trim().replace(/^\/+/, "");
+  if (!clean) throw new SegmindError("A model slug is required.");
+  return clean;
+}
+function trimSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function trimBase(url) {
+  return trimSlash(url).replace(/\/v\d+$/, "");
+}
+
+// src/image-url.ts
+async function imageUrl(input, options = {}) {
+  if (typeof input === "string" && /^(https?:|data:)/i.test(input)) {
+    return { type: "image_url", image_url: { url: input } };
+  }
+  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
+var shared;
+function client() {
+  shared ??= new Segmind();
+  return shared;
+}
+var run = (slug, params, options) => client().run(slug, params, options);
+var runSync = (slug, params, options) => client().runSync(slug, params, options);
+var submit = (slug, params, options) => client().submit(slug, params, options);
+var chat = (slug, params, options) => client().chat(slug, params, options);
+var chatSync = (slug, params, options) => client().chatSync(slug, params, options);
+var submitChat = (slug, params, options) => client().submitChat(slug, params, options);
+var models = {
+  list: (options) => client().models.list(options)
+};
+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,
+  ChatResponse,
+  DEFAULT_BASE_URL,
+  DEFAULT_CONSOLE_URL,
+  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,
+  webhooks
+};
+//# sourceMappingURL=index.js.map