segmind 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,707 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIConnectionError: () => APIConnectionError,
+  Accounts: () => Accounts,
+  ChatResponse: () => ChatResponse,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_CONSOLE_URL: () => DEFAULT_CONSOLE_URL,
+  DEFAULT_SPOT_URL: () => DEFAULT_SPOT_URL,
+  DEFAULT_WAIT_INTERVAL_MS: () => DEFAULT_WAIT_INTERVAL_MS,
+  DEFAULT_WAIT_TIMEOUT_MS: () => DEFAULT_WAIT_TIMEOUT_MS,
+  InferenceFailed: () => InferenceFailed,
+  InferenceTimeout: () => InferenceTimeout,
+  Job: () => Job,
+  Models: () => Models,
+  Segmind: () => Segmind,
+  SegmindError: () => SegmindError,
+  VERSION: () => VERSION,
+  accounts: () => accounts,
+  chat: () => chat,
+  chatSync: () => chatSync,
+  imageUrl: () => imageUrl,
+  models: () => models,
+  run: () => run,
+  runSync: () => runSync,
+  submit: () => submit,
+  submitChat: () => submitChat
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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) {
+    const 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 = { ...this.config.headers, ...req.headers };
+    if (this.config.apiKey) headers["x-api-key"] = this.config.apiKey;
+    if (req.body !== void 0) headers["content-type"] = "application/json";
+    try {
+      return await this.config.fetch(req.url, {
+        method: req.method,
+        headers,
+        body: req.body === void 0 ? void 0 : JSON.stringify(req.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 describe(err) {
+  if (err instanceof Error) {
+    const cause = err.cause;
+    return cause instanceof Error ? `${err.message} (${cause.message})` : err.message;
+  }
+  return String(err);
+}
+
+// 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/version.ts
+var VERSION = "0.1.0";
+
+// 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;
+  /** @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);
+  }
+  /**
+   * 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
+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 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;
+}
+
+// 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)
+};
+//# sourceMappingURL=index.cjs.map