@visgate_ai/client 0.2.17

package/dist/index.js

@@ -0,0 +1,765 @@
+// src/exceptions.ts
+var VisgateError = class _VisgateError extends Error {
+  constructor(message, errorCode = "VISGATE_ERROR", details = {}, statusCode) {
+    super(message);
+    this.name = "VisgateError";
+    this.message = message;
+    this.errorCode = errorCode;
+    this.details = details;
+    this.statusCode = statusCode;
+    Object.setPrototypeOf(this, _VisgateError.prototype);
+  }
+  toString() {
+    return `[${this.errorCode}] ${this.message}`;
+  }
+};
+var AuthenticationError = class _AuthenticationError extends VisgateError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "AUTHENTICATION_ERROR", {}, 401);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends VisgateError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR", field ? { field } : {}, 422);
+    this.name = "ValidationError";
+    this.field = field;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends VisgateError {
+  constructor(message = "Rate limit exceeded", retryAfter) {
+    super(message, "RATE_LIMIT_ERROR", retryAfter != null ? { retry_after: retryAfter } : {}, 429);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var ProviderError = class _ProviderError extends VisgateError {
+  constructor(message, provider = "unknown") {
+    super(message, "PROVIDER_ERROR", { provider });
+    this.name = "ProviderError";
+    this.provider = provider;
+    Object.setPrototypeOf(this, _ProviderError.prototype);
+  }
+};
+var VisgateTimeoutError = class _VisgateTimeoutError extends VisgateError {
+  constructor(message = "Request timed out") {
+    super(message, "TIMEOUT_ERROR");
+    this.name = "VisgateTimeoutError";
+    Object.setPrototypeOf(this, _VisgateTimeoutError.prototype);
+  }
+};
+var VisgateConnectionError = class _VisgateConnectionError extends VisgateError {
+  constructor(message = "Connection failed") {
+    super(message, "CONNECTION_ERROR");
+    this.name = "VisgateConnectionError";
+    Object.setPrototypeOf(this, _VisgateConnectionError.prototype);
+  }
+};
+
+// src/resources/billing.ts
+function billingInfoFromResponse(data) {
+  return {
+    tier: data.tier ?? "free",
+    balanceMicro: data.balance_micro ?? 0,
+    billingStatus: data.billing_status ?? "active",
+    monthlyBudgetCents: data.monthly_budget_cents,
+    usageThisMonthCents: data.usage_this_month_cents ?? 0,
+    supportEmail: data.support_email,
+    companyName: data.company_name,
+    freeModeEnabled: data.free_mode_enabled
+  };
+}
+function modelPricingFromResponse(data) {
+  return {
+    id: data.id ?? "",
+    providerType: data.provider_type ?? "",
+    model: data.model ?? "",
+    modelName: data.model_name ?? "",
+    modelType: data.model_type ?? "image",
+    modelClass: data.model_class,
+    costPerUnitMicro: data.cost_per_unit_micro ?? 0,
+    usageCount: data.usage_count ?? 0,
+    totalSavingsMicro: data.total_savings_micro ?? 0,
+    avgSavingsMicro: data.avg_savings_micro ?? 0
+  };
+}
+function pricingResponseFromResponse(data) {
+  const pricing = data.pricing ?? [];
+  return {
+    lastUpdated: data.last_updated ?? null,
+    pricing: pricing.map(modelPricingFromResponse)
+  };
+}
+var Billing = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  /** Public billing stats for landing/marketing (GET /billing/stats). May not require auth. */
+  async getStats() {
+    return await this._client._request("GET", "/billing/stats");
+  }
+  /** Organization billing info (GET /billing/info). */
+  async getInfo() {
+    const data = await this._client._request("GET", "/billing/info");
+    return billingInfoFromResponse(data);
+  }
+  /** Create checkout session (POST /billing/checkout). */
+  async checkout(amountDollars, returnUrl, options) {
+    const body = {
+      amount_dollars: amountDollars,
+      return_url: returnUrl
+    };
+    if (options?.customerEmail != null) body.customer_email = options.customerEmail;
+    if (options?.firebaseUid != null) body.firebase_uid = options.firebaseUid;
+    return await this._client._request("POST", "/billing/checkout", {
+      body: JSON.stringify(body)
+    });
+  }
+  /** Get pricing for all models (GET /billing/pricing). */
+  async getPricing() {
+    const data = await this._client._request("GET", "/billing/pricing");
+    return pricingResponseFromResponse(data);
+  }
+  /** Update organization subscription tier (POST /billing/subscription). */
+  async updateSubscription(tier) {
+    const data = await this._client._request("POST", "/billing/subscription", {
+      body: JSON.stringify({ tier })
+    });
+    return {
+      success: Boolean(data.success),
+      tier: data.tier ?? tier
+    };
+  }
+};
+
+// src/utils.ts
+function parseDateTime(value) {
+  if (value == null || value === "") return null;
+  const normalized = value.replace("Z", "+00:00");
+  const date = new Date(normalized);
+  return isNaN(date.getTime()) ? null : date;
+}
+function hasProcessEnv() {
+  return typeof process !== "undefined" && typeof process.env !== "undefined";
+}
+function resolveApiKey(apiKey) {
+  const key = apiKey ?? (hasProcessEnv() ? process.env.VISGATE_API_KEY : void 0);
+  if (!key || typeof key !== "string" || key.trim() === "") {
+    throw new AuthenticationError(
+      "No API key provided. Pass apiKey or set the VISGATE_API_KEY environment variable."
+    );
+  }
+  return key.trim();
+}
+
+// src/resources/generate.ts
+function generateResultFromResponse(data) {
+  return {
+    id: data.id,
+    status: data.status ?? "success",
+    imageUrl: data.image_url ?? null,
+    images: data.images ?? [],
+    model: data.model,
+    provider: data.provider ?? "",
+    mode: data.mode ?? "",
+    cost: data.estimated_cost_usd ?? 0,
+    costPerMegapixel: data.cost_per_megapixel_usd ?? 0,
+    latencyMs: data.latency_ms ?? 0,
+    resolution: data.resolution ?? {},
+    createdAt: parseDateTime(data.created_at)
+  };
+}
+var DEFAULT_MODEL = "fal-ai/flux/schnell";
+var Generate = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async __call__(prompt, model = DEFAULT_MODEL, params) {
+    const payload = { prompt, model };
+    if (params) payload.params = params;
+    const data = await this._client._request("POST", "/generate", {
+      body: JSON.stringify(payload)
+    });
+    return generateResultFromResponse(data);
+  }
+};
+
+// src/resources/images.ts
+function imageResultFromResponse(data) {
+  const cacheSource = data.cache_source;
+  return {
+    id: data.id,
+    status: data.status,
+    images: data.images ?? [],
+    model: data.model,
+    provider: data.provider,
+    cost: data.cost ?? 0,
+    cacheHit: data.cache_hit ?? false,
+    latencyMs: data.latency_ms ?? null,
+    savedAmount: data.saved_amount,
+    marginPercent: data.margin_percent,
+    cacheSource: cacheSource === "exact" || cacheSource === "semantic" ? cacheSource : void 0,
+    createdAt: parseDateTime(data.created_at)
+  };
+}
+var Images = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async generate(model, prompt, options = {}) {
+    const {
+      negativePrompt,
+      width = 1024,
+      height = 1024,
+      numImages = 1,
+      seed,
+      imageUrl,
+      preferCache,
+      maxLatencyMs,
+      webhookUrl,
+      callbackId,
+      params
+    } = options;
+    const payload = {
+      model,
+      prompt,
+      width,
+      height,
+      num_images: numImages
+    };
+    if (negativePrompt) payload.negative_prompt = negativePrompt;
+    if (seed != null) payload.seed = seed;
+    if (imageUrl) payload.image_url = imageUrl;
+    if (preferCache !== void 0) payload.prefer_cache = preferCache;
+    if (maxLatencyMs != null) payload.max_latency_ms = maxLatencyMs;
+    if (webhookUrl) payload.webhook_url = webhookUrl;
+    if (callbackId) payload.callback_id = callbackId;
+    if (params) Object.assign(payload, params);
+    const data = await this._client._request("POST", "/images/generate", {
+      body: JSON.stringify(payload)
+    });
+    return imageResultFromResponse(data);
+  }
+};
+
+// src/resources/models.ts
+function modelInfoFromResponse(data) {
+  return {
+    id: data.id ?? "",
+    name: data.name ?? "",
+    provider: data.provider ?? "",
+    mediaType: data.media_type ?? "image",
+    description: data.description,
+    category: data.category,
+    tags: data.tags ?? [],
+    coverImageUrl: data.cover_image_url,
+    author: data.author,
+    url: data.url,
+    baseCostMicro: data.base_cost_micro ?? 0,
+    normalizedCostMicro: data.normalized_cost_micro ?? 0,
+    pricing: data.pricing,
+    pricingUnit: data.pricing_unit,
+    runCount: data.run_count ?? 0,
+    inputTypes: data.input_types ?? [],
+    outputType: data.output_type,
+    capabilities: data.capabilities ?? [],
+    firstSeenAt: data.first_seen_at,
+    providerCreatedAt: data.provider_created_at,
+    lastSyncedAt: data.last_synced_at,
+    compliance: data.compliance ?? void 0
+  };
+}
+function featuredSectionFromResponse(data) {
+  const models = data.models ?? [];
+  return {
+    title: data.title ?? "",
+    key: data.key ?? "",
+    models: models.map(modelInfoFromResponse)
+  };
+}
+function modelsResponseFromResponse(data) {
+  const models = data.models ?? [];
+  const featuredRaw = data.featured;
+  return {
+    models: models.map(modelInfoFromResponse),
+    totalCount: data.total_count ?? 0,
+    lastUpdated: data.last_updated,
+    featured: featuredRaw ? featuredRaw.map(featuredSectionFromResponse) : void 0
+  };
+}
+var Models = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async list(options = {}) {
+    const {
+      provider,
+      mediaType,
+      capability,
+      search,
+      sort,
+      limit = 100,
+      featured = false
+    } = options;
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    if (provider) params.set("provider", provider);
+    if (mediaType) params.set("media_type", mediaType);
+    if (capability) params.set("capability", capability);
+    if (search) params.set("search", search);
+    if (sort) params.set("sort", sort);
+    if (featured) params.set("featured", "true");
+    const data = await this._client._request("GET", `/models?${params.toString()}`);
+    return modelsResponseFromResponse(data);
+  }
+  async get(modelId) {
+    const data = await this._client._request("GET", `/models/${encodeURIComponent(modelId)}`);
+    return modelInfoFromResponse(data);
+  }
+  async search(query, limit = 20) {
+    return this.list({ search: query, limit });
+  }
+};
+
+// src/resources/providers.ts
+function providerKeyInfoFromResponse(data) {
+  return {
+    provider: data.provider ?? "",
+    validated: Boolean(data.validated),
+    validatedAt: data.validated_at,
+    maskedKey: data.masked_key
+  };
+}
+function providerKeysResponseFromResponse(data) {
+  const keys = data.keys ?? [];
+  return { keys: keys.map(providerKeyInfoFromResponse) };
+}
+function providerValidationResultFromResponse(data) {
+  return {
+    valid: Boolean(data.valid),
+    message: String(data.message ?? "")
+  };
+}
+function providerBalanceItemFromResponse(data) {
+  return {
+    provider: data.provider ?? "",
+    configured: Boolean(data.configured),
+    available: Boolean(data.available),
+    limit: data.limit,
+    remaining: data.remaining,
+    currency: data.currency,
+    message: data.message
+  };
+}
+function providerBalancesResponseFromResponse(data) {
+  const balances = data.balances ?? [];
+  return { balances: balances.map(providerBalanceItemFromResponse) };
+}
+var Providers = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async listKeys() {
+    const data = await this._client._request("GET", "/providers/keys");
+    return providerKeysResponseFromResponse(data);
+  }
+  async setKey(provider, apiKey) {
+    const data = await this._client._request("PUT", "/providers/keys", {
+      body: JSON.stringify({ provider, api_key: apiKey })
+    });
+    return providerKeyInfoFromResponse(data);
+  }
+  async deleteKey(provider) {
+    return await this._client._request("DELETE", `/providers/keys/${encodeURIComponent(provider)}`);
+  }
+  async validateKey(provider, apiKey) {
+    const data = await this._client._request("POST", "/providers/validate", {
+      body: JSON.stringify({ provider, api_key: apiKey })
+    });
+    return providerValidationResultFromResponse(data);
+  }
+  async balances() {
+    const data = await this._client._request("GET", "/providers/balances");
+    return providerBalancesResponseFromResponse(data);
+  }
+};
+
+// src/resources/requests.ts
+function requestStatusFromResponse(data) {
+  return {
+    requestId: data.request_id ?? data.requestId,
+    status: data.status ?? "pending",
+    mediaType: data.media_type ?? "video",
+    provider: data.provider ?? "",
+    model: data.model ?? "",
+    outputUrl: data.output_url ?? null,
+    errorMessage: data.error_message ?? null,
+    createdAt: data.created_at ?? null,
+    completedAt: data.completed_at ?? null
+  };
+}
+var Requests = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  /** Get status of an async generation request (video/image). */
+  async get(requestId) {
+    const data = await this._client._request("GET", `/requests/${encodeURIComponent(requestId)}`);
+    return requestStatusFromResponse(data);
+  }
+};
+
+// src/resources/usage.ts
+function byProviderFromBreakdown(providerBreakdown) {
+  if (!providerBreakdown || typeof providerBreakdown !== "object") return {};
+  const out = {};
+  for (const [provider, stats] of Object.entries(providerBreakdown)) {
+    const s = stats;
+    const requests = s?.requests ?? 0;
+    if (provider) out[provider] = requests;
+  }
+  return out;
+}
+function usageSummaryFromResponse(data) {
+  const totalRequests = data.total_requests ?? 0;
+  const cachedRequests = data.cached_requests ?? 0;
+  const cacheHitRateFromApi = data.cache_hit_rate;
+  const cacheHitRate = typeof cacheHitRateFromApi === "number" ? cacheHitRateFromApi : totalRequests === 0 ? 0 : cachedRequests / totalRequests * 100;
+  const providerBreakdown = data.provider_breakdown;
+  const history = data.history;
+  return {
+    totalRequests,
+    successfulRequests: data.successful_requests ?? 0,
+    failedRequests: data.failed_requests ?? 0,
+    cachedRequests,
+    totalProviderCost: data.total_provider_effective_cost ?? data.total_provider_cost ?? 0,
+    totalBilledCost: data.total_billed_cost ?? data.total_cost_usd ?? 0,
+    totalSavings: data.total_savings ?? 0,
+    byProvider: data.by_provider ?? byProviderFromBreakdown(providerBreakdown),
+    byModel: data.by_model ?? {},
+    period: data.period ?? "month",
+    periodStart: parseDateTime(data.period_start),
+    periodEnd: parseDateTime(data.period_end),
+    cacheHitRate,
+    avgLatency: data.avg_latency,
+    providerBreakdown,
+    history: Array.isArray(history) ? history : void 0
+  };
+}
+var Usage = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  async get(period = "month") {
+    const data = await this._client._request("GET", `/usage?period=${encodeURIComponent(period)}`);
+    return usageSummaryFromResponse(data);
+  }
+  async logs(options = {}) {
+    const { limit = 50, offset = 0 } = options;
+    const params = new URLSearchParams();
+    params.set("limit", String(limit));
+    params.set("offset", String(offset));
+    const data = await this._client._request("GET", `/usage/logs?${params.toString()}`);
+    if (Array.isArray(data)) return data;
+    return data.logs ?? [];
+  }
+  async dashboard(period = "month") {
+    return await this._client._request(
+      "GET",
+      `/dashboard?period=${encodeURIComponent(period)}`
+    );
+  }
+  /**
+   * Track a download event for a request (POST /usage/downloads).
+   * Increments download_count and adds timestamp to downloaded_at.
+   */
+  async trackDownload(requestId, outputUrl, options) {
+    const body = { request_id: requestId, output_url: outputUrl };
+    if (options?.mediaType) body.media_type = options.mediaType;
+    const data = await this._client._request("POST", "/usage/downloads", {
+      body: JSON.stringify(body)
+    });
+    return {
+      success: Boolean(data.success),
+      request_id: data.request_id ?? requestId,
+      download_count: data.download_count ?? 0
+    };
+  }
+};
+
+// src/resources/videos.ts
+function blobToDataUrl(blob) {
+  if (typeof FileReader !== "undefined") {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => {
+        if (typeof reader.result === "string") resolve(reader.result);
+        else reject(new Error("FileReader did not return a string"));
+      };
+      reader.onerror = () => reject(reader.error);
+      reader.readAsDataURL(blob);
+    });
+  }
+  return (async () => {
+    const ab = await blob.arrayBuffer();
+    const mime = blob.type || "image/jpeg";
+    const NodeBuffer = typeof globalThis !== "undefined" && globalThis.Buffer;
+    const base64 = NodeBuffer ? NodeBuffer.from(ab).toString("base64") : btoa(String.fromCharCode(...new Uint8Array(ab)));
+    return `data:${mime};base64,${base64}`;
+  })();
+}
+var VIDEO_MODEL_PRESETS = {
+  fal: "fal-ai/veo3",
+  replicate: "replicate/lucataco/cogvideox-5b",
+  runway: "runway/gen4_turbo"
+};
+function videoResultFromResponse(data) {
+  const cacheSource = data.cache_source;
+  return {
+    id: data.id,
+    status: data.status,
+    videoUrl: data.video_url ?? null,
+    model: data.model,
+    provider: data.provider,
+    cost: data.cost ?? 0,
+    cacheHit: data.cache_hit ?? false,
+    latencyMs: data.latency_ms ?? null,
+    savedAmount: data.saved_amount,
+    marginPercent: data.margin_percent,
+    cacheSource: cacheSource === "exact" || cacheSource === "semantic" ? cacheSource : void 0,
+    createdAt: parseDateTime(data.created_at)
+  };
+}
+var Videos = class {
+  constructor(_client) {
+    this._client = _client;
+  }
+  /**
+   * Generate a video from a prompt (and optional image for img2vid).
+   * Supports managed mode and BYOK (set falKey/replicateKey/runwayKey on client or via proxy env).
+   * Use preferAsync: true to avoid 502 when video takes longer than proxy/Cloudflare timeout.
+   */
+  async generate(model, prompt, options = {}) {
+    const {
+      imageUrl,
+      imageFile,
+      durationSeconds = 5,
+      fps,
+      webhookUrl,
+      callbackId,
+      skipGcsUpload,
+      preferAsync,
+      params
+    } = options;
+    let resolvedImageUrl = null;
+    if (imageFile) {
+      resolvedImageUrl = await blobToDataUrl(imageFile);
+    } else if (imageUrl) {
+      resolvedImageUrl = imageUrl;
+    }
+    const payload = {
+      model,
+      prompt,
+      duration_seconds: durationSeconds
+    };
+    if (resolvedImageUrl) payload.image_url = resolvedImageUrl;
+    if (fps != null) payload.fps = fps;
+    if (webhookUrl) payload.webhook_url = webhookUrl;
+    if (callbackId) payload.callback_id = callbackId;
+    if (skipGcsUpload === true) payload.skip_gcs_upload = true;
+    if (params && Object.keys(params).length > 0) Object.assign(payload, params);
+    const headers = {};
+    if (preferAsync === true) headers["Prefer"] = "respond-async";
+    const data = await this._client._request("POST", "/videos/generate", {
+      body: JSON.stringify(payload),
+      headers: Object.keys(headers).length > 0 ? headers : void 0
+    });
+    if ("request_id" in data && typeof data.request_id === "string" && !("video_url" in data)) {
+      return { requestId: data.request_id, status: "accepted" };
+    }
+    return videoResultFromResponse(data);
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://visgateai.com/api/v1";
+var DEFAULT_TIMEOUT = 12e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var SDK_VERSION = "0.2.2";
+function getVersion() {
+  try {
+    if (typeof __VERSION__ !== "undefined") return __VERSION__;
+  } catch {
+  }
+  return SDK_VERSION;
+}
+function buildHeaders(apiKey, options) {
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": `visgate-client/${getVersion()}`
+  };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  if (options.falKey) headers["X-Fal-Key"] = options.falKey;
+  if (options.replicateKey) headers["X-Replicate-Key"] = options.replicateKey;
+  if (options.runwayKey) headers["X-Runway-Key"] = options.runwayKey;
+  return headers;
+}
+function backoff(attempt) {
+  return Math.min(0.5 * Math.pow(2, attempt), 8) * 1e3;
+}
+function retryWaitFromResponse(response, attempt) {
+  const retryAfter = response.headers.get("Retry-After");
+  if (retryAfter) {
+    const sec = parseInt(retryAfter, 10);
+    if (!isNaN(sec)) return sec * 1e3;
+  }
+  return backoff(attempt);
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function handleResponse(response) {
+  const status = response.status;
+  if (status < 400) {
+    const text2 = await response.text();
+    if (!text2) return {};
+    try {
+      return JSON.parse(text2);
+    } catch {
+      return {};
+    }
+  }
+  let body = {};
+  const text = await response.text();
+  try {
+    if (text) body = JSON.parse(text);
+  } catch {
+  }
+  if (status === 401) {
+    throw new AuthenticationError("Invalid or missing API key");
+  }
+  if (status === 422) {
+    const message2 = body.message ?? text ?? "Validation failed";
+    const field = body.details?.field;
+    throw new ValidationError(message2, field);
+  }
+  if (status === 429) {
+    const retryAfterHeader = response.headers.get("Retry-After");
+    const retryAfter = retryAfterHeader ? parseInt(retryAfterHeader, 10) : void 0;
+    throw new RateLimitError("Rate limit exceeded", Number.isNaN(retryAfter) ? void 0 : retryAfter);
+  }
+  const errorCode = body.error ?? `HTTP_${status}`;
+  const message = body.message ?? text ?? "Request failed";
+  if (String(errorCode).includes("PROVIDER")) {
+    const provider = body.details?.provider ?? "unknown";
+    throw new ProviderError(message, provider);
+  }
+  throw new VisgateError(message, errorCode, body.details ?? {}, status);
+}
+var Client = class {
+  constructor(options = {}) {
+    this.apiKey = options.proxyUrl ? options.apiKey != null && options.apiKey !== "" ? resolveApiKey(options.apiKey) : null : resolveApiKey(options.apiKey);
+    this.baseUrl = (options.proxyUrl ?? options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    this.headers = buildHeaders(this.apiKey, options.proxyUrl ? {} : {
+      falKey: options.falKey,
+      replicateKey: options.replicateKey,
+      runwayKey: options.runwayKey
+    });
+    this.images = new Images(this);
+    this.models = new Models(this);
+    this.videos = new Videos(this);
+    this.requests = new Requests(this);
+    this.usage = new Usage(this);
+    this.providers = new Providers(this);
+    this.billing = new Billing(this);
+    this._generate = new Generate(this);
+  }
+  /**
+   * Generate an image with a single call.
+   */
+  generate(prompt, options) {
+    return this._generate.__call__(prompt, options?.model, options?.params);
+  }
+  /**
+   * Check API health status.
+   */
+  health() {
+    return this._request("GET", "/health");
+  }
+  async _request(method, path, init = {}) {
+    const url = `${this.baseUrl}${path}`;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        const fetchInit = {
+          method,
+          ...init,
+          headers: { ...this.headers, ...init.headers },
+          signal: controller.signal
+        };
+        if (method !== "GET" && init.body !== void 0) {
+          fetchInit.body = init.body;
+        }
+        const response = await fetch(url, fetchInit);
+        clearTimeout(timeoutId);
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+          const waitMs = retryWaitFromResponse(response, attempt);
+          await sleep(waitMs);
+          continue;
+        }
+        return await handleResponse(response);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof AuthenticationError && this.apiKey === null) {
+          throw new AuthenticationError("Proxy returned 401. Check VISGATE_API_KEY on the server (proxy).");
+        }
+        if (err instanceof VisgateError && !(err instanceof RateLimitError)) throw err;
+        if (attempt >= this.maxRetries) {
+          if (err instanceof Error && err.name === "AbortError") {
+            throw new VisgateTimeoutError(`Request timed out after ${this.maxRetries + 1} attempt(s)`);
+          }
+          if (err instanceof TypeError && err.message.includes("fetch")) {
+            throw new VisgateConnectionError(`Connection failed: ${err.message}`);
+          }
+          throw err;
+        }
+        const waitMs = backoff(attempt);
+        await sleep(waitMs);
+      }
+    }
+    throw new VisgateError(
+      `Request failed after ${this.maxRetries + 1} attempts`,
+      "VISGATE_ERROR",
+      {},
+      void 0
+    );
+  }
+  /** No-op for API compatibility (JS has no connection pool to close). */
+  close() {
+  }
+  toString() {
+    return `Client(baseUrl=${JSON.stringify(this.baseUrl)})`;
+  }
+};
+var AsyncClient = class extends Client {
+  constructor(options = {}) {
+    super(options);
+  }
+  toString() {
+    return `AsyncClient(baseUrl=${JSON.stringify(this.baseUrl)})`;
+  }
+};
+
+// src/index.ts
+var VERSION = "0.2.2";
+
+export { AsyncClient, AuthenticationError, Billing, Client, Generate, Images, Models, ProviderError, Providers, RateLimitError, Requests, Usage, VERSION, VIDEO_MODEL_PRESETS, ValidationError, Videos, VisgateConnectionError, VisgateError, VisgateTimeoutError, billingInfoFromResponse, featuredSectionFromResponse, generateResultFromResponse, imageResultFromResponse, modelInfoFromResponse, modelPricingFromResponse, modelsResponseFromResponse, pricingResponseFromResponse, providerBalanceItemFromResponse, providerBalancesResponseFromResponse, providerKeyInfoFromResponse, providerKeysResponseFromResponse, providerValidationResultFromResponse, requestStatusFromResponse, usageSummaryFromResponse, videoResultFromResponse };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map