getaiapi 0.1.0

package/dist/chunk-O4TLMX4T.js

@@ -0,0 +1,1363 @@
+// src/gateway.ts
+import { randomUUID } from "crypto";
+
+// src/errors.ts
+var GetAIApiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GetAIApiError";
+  }
+};
+var AuthError = class extends GetAIApiError {
+  provider;
+  envVar;
+  constructor(provider, envVar) {
+    super(`Missing or invalid API key for ${provider}. Set the ${envVar} environment variable.`);
+    this.name = "AuthError";
+    this.provider = provider;
+    this.envVar = envVar;
+  }
+};
+var ModelNotFoundError = class extends GetAIApiError {
+  query;
+  suggestions;
+  constructor(query, suggestions = []) {
+    const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : "";
+    super(`Model "${query}" not found.${hint}`);
+    this.name = "ModelNotFoundError";
+    this.query = query;
+    this.suggestions = suggestions;
+  }
+};
+var ValidationError = class extends GetAIApiError {
+  field;
+  constructor(field, message) {
+    super(`Validation error on "${field}": ${message}`);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+};
+var ProviderError = class extends GetAIApiError {
+  provider;
+  model;
+  statusCode;
+  raw;
+  constructor(provider, model, statusCode, raw) {
+    super(
+      `Provider ${provider} returned status ${statusCode} for model "${model}".`
+    );
+    this.name = "ProviderError";
+    this.provider = provider;
+    this.model = model;
+    this.statusCode = statusCode;
+    this.raw = raw;
+  }
+};
+var TimeoutError = class extends GetAIApiError {
+  provider;
+  model;
+  timeoutMs;
+  constructor(provider, model, timeoutMs) {
+    super(
+      `Generation timed out after ${timeoutMs}ms for model "${model}" on ${provider}.`
+    );
+    this.name = "TimeoutError";
+    this.provider = provider;
+    this.model = model;
+    this.timeoutMs = timeoutMs;
+  }
+};
+var RateLimitError = class extends GetAIApiError {
+  provider;
+  retryAfterMs;
+  constructor(provider, retryAfterMs) {
+    super(
+      `Rate limited by ${provider}. Retry after ${retryAfterMs}ms.`
+    );
+    this.name = "RateLimitError";
+    this.provider = provider;
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+
+// src/auth.ts
+var ENV_MAP = {
+  "fal-ai": "FAL_KEY",
+  replicate: "REPLICATE_API_TOKEN",
+  wavespeed: "WAVESPEED_API_KEY"
+};
+var AuthManager = class {
+  keys;
+  constructor() {
+    this.keys = /* @__PURE__ */ new Map();
+    for (const [provider, envVar] of Object.entries(ENV_MAP)) {
+      const key = process.env[envVar]?.trim();
+      if (key) this.keys.set(provider, key);
+    }
+  }
+  availableProviders() {
+    return [...this.keys.keys()];
+  }
+  getKey(provider) {
+    const key = this.keys.get(provider);
+    if (!key) {
+      throw new AuthError(provider, ENV_MAP[provider]);
+    }
+    return key;
+  }
+  canAccess(model) {
+    return model.providers.some((p) => this.keys.has(p.provider));
+  }
+  listAvailableModels(registry) {
+    return registry.filter((m) => this.canAccess(m));
+  }
+};
+
+// src/resolver.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var registryCache = null;
+function loadRegistry() {
+  if (registryCache) {
+    return registryCache;
+  }
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(dir, "registry", "registry.json");
+    try {
+      const raw = readFileSync(candidate, "utf-8");
+      registryCache = JSON.parse(raw);
+      return registryCache;
+    } catch {
+      dir = dirname(dir);
+    }
+  }
+  throw new Error(
+    "Could not find registry/registry.json. Searched upward from: " + __dirname
+  );
+}
+function normalizeModelName(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]/g, "").replace(/(?<=\d)v(?=\d)/g, "").replace(/v(?=\d)/g, "");
+}
+function resolveModel(query, availableProviders) {
+  if (!query || typeof query !== "string" || query.trim() === "") {
+    throw new ModelNotFoundError("Model name is required");
+  }
+  const trimmedQuery = query.trim();
+  const registry = loadRegistry();
+  let matched;
+  matched = registry.find((e) => e.canonical_name === trimmedQuery);
+  if (!matched) {
+    matched = registry.find(
+      (e) => e.aliases.some((a) => a === trimmedQuery)
+    );
+  }
+  if (!matched) {
+    const normalizedQuery = normalizeModelName(trimmedQuery);
+    matched = registry.find(
+      (e) => normalizeModelName(e.canonical_name) === normalizedQuery
+    );
+    if (!matched) {
+      matched = registry.find(
+        (e) => e.aliases.some((a) => normalizeModelName(a) === normalizedQuery)
+      );
+    }
+  }
+  if (!matched) {
+    const suggestions = findSuggestions(trimmedQuery, registry);
+    throw new ModelNotFoundError(trimmedQuery, suggestions);
+  }
+  if (availableProviders && availableProviders.length > 0) {
+    const filteredProviders = matched.providers.filter(
+      (p) => availableProviders.includes(p.provider)
+    );
+    if (filteredProviders.length === 0) {
+      const suggestions = findSuggestions(trimmedQuery, registry);
+      throw new ModelNotFoundError(trimmedQuery, suggestions);
+    }
+    return { ...matched, providers: filteredProviders };
+  }
+  return matched;
+}
+function findSuggestions(query, registry) {
+  const normalizedQuery = normalizeModelName(query);
+  if (normalizedQuery === "") {
+    return [];
+  }
+  const matches = registry.filter((e) => {
+    const normalizedCanonical = normalizeModelName(e.canonical_name);
+    if (normalizedCanonical.startsWith(normalizedQuery) || normalizedCanonical.includes(normalizedQuery) || normalizedQuery.startsWith(normalizedCanonical)) {
+      return true;
+    }
+    const minLen = Math.min(normalizedQuery.length, normalizedCanonical.length);
+    let shared = 0;
+    for (let i = 0; i < minLen; i++) {
+      if (normalizedQuery[i] === normalizedCanonical[i]) {
+        shared++;
+      } else {
+        break;
+      }
+    }
+    return shared >= 3 && shared >= normalizedQuery.length * 0.3;
+  });
+  return matches.sort((a, b) => a.canonical_name.length - b.canonical_name.length).slice(0, 5).map((e) => e.canonical_name);
+}
+
+// src/mapper.ts
+function mapInput(request, binding, template) {
+  const result = {};
+  const provider = binding.provider;
+  for (const mapping of template.input_mappings) {
+    const value = getUniversalValue(request, mapping.universal);
+    if (value === void 0 || value === null) {
+      if (mapping.required) {
+        throw new ValidationError(
+          mapping.universal,
+          `"${mapping.universal}" is required but was not provided.`
+        );
+      }
+      continue;
+    }
+    const providerKey = mapping.providers[provider];
+    if (providerKey === void 0) {
+      continue;
+    }
+    const transformed = applyTransform(value, mapping, provider);
+    if (Array.isArray(providerKey)) {
+      if (typeof transformed === "object" && transformed !== null && !Array.isArray(transformed)) {
+        const obj = transformed;
+        for (const key of providerKey) {
+          if (obj[key] !== void 0) {
+            result[key] = obj[key];
+          }
+        }
+      }
+    } else {
+      result[providerKey] = transformed;
+    }
+  }
+  if (request.options) {
+    for (const [key, val] of Object.entries(request.options)) {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function getUniversalValue(request, field) {
+  return request[field];
+}
+function applyTransform(value, mapping, provider) {
+  const transform = mapping.transform;
+  if (!transform || transform === "none") {
+    return value;
+  }
+  if (transform === "flip_boolean") {
+    if (provider === "replicate") {
+      return !value;
+    }
+    return value;
+  }
+  if (transform === "parse_size") {
+    return parseSizeForProvider(value, mapping, provider);
+  }
+  return value;
+}
+function parseSizeForProvider(value, mapping, provider) {
+  if (provider === "fal-ai") {
+    if (typeof value === "string") {
+      const [w, h] = value.split("x").map(Number);
+      return { width: w, height: h };
+    }
+    return value;
+  }
+  if (provider === "replicate") {
+    if (typeof value === "string") {
+      const [w, h] = value.split("x").map(Number);
+      return { width: w, height: h };
+    }
+    if (typeof value === "object" && value !== null) {
+      return value;
+    }
+    return value;
+  }
+  return value;
+}
+function mapOutput(raw, outputMapping) {
+  const { type, extract_path, content_type } = outputMapping;
+  const defaultContentType = content_type || "image/jpeg";
+  const data = raw;
+  if (extract_path === "images[].url") {
+    const images = data?.images ?? [];
+    return images.map((img) => ({
+      type,
+      url: img.url,
+      content_type: img.content_type || defaultContentType
+    }));
+  }
+  if (extract_path === "output[]") {
+    const arr = Array.isArray(data) ? data : data?.output ?? [];
+    return arr.map((url) => ({
+      type,
+      url,
+      content_type: defaultContentType
+    }));
+  }
+  if (extract_path === "data.outputs[]") {
+    const outputs = data?.data?.outputs ?? [];
+    return outputs.map((url) => ({
+      type,
+      url,
+      content_type: defaultContentType
+    }));
+  }
+  if (extract_path === "video.url") {
+    return [{
+      type: "video",
+      url: data?.video?.url,
+      content_type: "video/mp4"
+    }];
+  }
+  if (extract_path === "audio.url") {
+    return [{
+      type: "audio",
+      url: data?.audio?.url,
+      content_type: "audio/mpeg"
+    }];
+  }
+  return genericExtract(data, extract_path, type, defaultContentType);
+}
+function genericExtract(data, path, type, contentType) {
+  const segments = path.split(".");
+  let current = data;
+  for (const seg of segments) {
+    if (current === null || current === void 0) return [];
+    const arrayMatch = seg.match(/^(.+)\[\]$/);
+    if (arrayMatch) {
+      const key = arrayMatch[1];
+      current = current[key];
+      if (Array.isArray(current)) {
+        const remaining = segments.slice(segments.indexOf(seg) + 1).join(".");
+        if (remaining) {
+          return current.map((item) => ({
+            type,
+            url: getNestedValue(item, remaining),
+            content_type: contentType
+          }));
+        }
+        return current.map((item) => ({
+          type,
+          url: typeof item === "string" ? item : item?.url,
+          content_type: contentType
+        }));
+      }
+      return [];
+    }
+    current = current[seg];
+  }
+  if (typeof current === "string") {
+    return [{ type, url: current, content_type: contentType }];
+  }
+  return [];
+}
+function getNestedValue(obj, path) {
+  let current = obj;
+  for (const key of path.split(".")) {
+    if (current === null || current === void 0) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+
+// src/categories/text-to-image.ts
+var textToImageTemplate = {
+  category: "text-to-image",
+  input_mappings: [
+    {
+      universal: "prompt",
+      providers: {
+        "fal-ai": "prompt",
+        "replicate": "prompt",
+        "wavespeed": "prompt"
+      },
+      required: true
+    },
+    {
+      universal: "negative_prompt",
+      providers: {
+        "fal-ai": "negative_prompt",
+        "replicate": "negative_prompt",
+        "wavespeed": "negative_prompt"
+      }
+    },
+    {
+      universal: "count",
+      providers: {
+        "fal-ai": "num_images",
+        "replicate": "num_outputs",
+        "wavespeed": "num_outputs"
+      }
+    },
+    {
+      universal: "size",
+      providers: {
+        "fal-ai": "image_size",
+        "replicate": ["width", "height"],
+        "wavespeed": "resolution"
+      },
+      transform: "parse_size"
+    },
+    {
+      universal: "guidance",
+      providers: {
+        "fal-ai": "guidance_scale",
+        "replicate": "guidance",
+        "wavespeed": "guidance_scale"
+      }
+    },
+    {
+      universal: "steps",
+      providers: {
+        "fal-ai": "num_inference_steps",
+        "replicate": "num_inference_steps",
+        "wavespeed": "num_inference_steps"
+      }
+    },
+    {
+      universal: "seed",
+      providers: {
+        "fal-ai": "seed",
+        "replicate": "seed",
+        "wavespeed": "seed"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "quality",
+      providers: {
+        "fal-ai": "quality",
+        "replicate": "output_quality",
+        "wavespeed": "quality"
+      }
+    },
+    {
+      universal: "safety",
+      providers: {
+        "fal-ai": "enable_safety_checker",
+        "replicate": "disable_safety_checker",
+        "wavespeed": "enable_safety_checker"
+      },
+      transform: "flip_boolean"
+    }
+  ],
+  output_type: "image",
+  output_extract: {
+    "fal-ai": "images[].url",
+    "replicate": "output[]",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 6e4
+};
+
+// src/categories/image-edit.ts
+var imageEditTemplate = {
+  category: "image-edit",
+  input_mappings: [
+    {
+      universal: "image",
+      providers: {
+        "fal-ai": "image_url",
+        "replicate": "image",
+        "wavespeed": "image_url"
+      },
+      required: true
+    },
+    {
+      universal: "prompt",
+      providers: {
+        "fal-ai": "prompt",
+        "replicate": "prompt",
+        "wavespeed": "prompt"
+      },
+      required: true
+    },
+    {
+      universal: "strength",
+      providers: {
+        "fal-ai": "strength",
+        "replicate": "strength",
+        "wavespeed": "strength"
+      }
+    },
+    {
+      universal: "mask",
+      providers: {
+        "fal-ai": "mask_url",
+        "replicate": "mask",
+        "wavespeed": "mask_url"
+      }
+    },
+    {
+      universal: "seed",
+      providers: {
+        "fal-ai": "seed",
+        "replicate": "seed",
+        "wavespeed": "seed"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "quality",
+      providers: {
+        "fal-ai": "quality",
+        "replicate": "output_quality",
+        "wavespeed": "quality"
+      }
+    },
+    {
+      universal: "safety",
+      providers: {
+        "fal-ai": "enable_safety_checker",
+        "replicate": "disable_safety_checker",
+        "wavespeed": "enable_safety_checker"
+      },
+      transform: "flip_boolean"
+    }
+  ],
+  output_type: "image",
+  output_extract: {
+    "fal-ai": "images[].url",
+    "replicate": "output[]",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 6e4
+};
+
+// src/categories/text-to-video.ts
+var textToVideoTemplate = {
+  category: "text-to-video",
+  input_mappings: [
+    {
+      universal: "prompt",
+      providers: {
+        "fal-ai": "prompt",
+        "replicate": "prompt",
+        "wavespeed": "prompt"
+      },
+      required: true
+    },
+    {
+      universal: "negative_prompt",
+      providers: {
+        "fal-ai": "negative_prompt",
+        "replicate": "negative_prompt",
+        "wavespeed": "negative_prompt"
+      }
+    },
+    {
+      universal: "count",
+      providers: {
+        "fal-ai": "num_videos",
+        "replicate": "num_outputs",
+        "wavespeed": "num_outputs"
+      }
+    },
+    {
+      universal: "size",
+      providers: {
+        "fal-ai": "video_size",
+        "replicate": ["width", "height"],
+        "wavespeed": "resolution"
+      },
+      transform: "parse_size"
+    },
+    {
+      universal: "guidance",
+      providers: {
+        "fal-ai": "guidance_scale",
+        "replicate": "guidance",
+        "wavespeed": "guidance_scale"
+      }
+    },
+    {
+      universal: "steps",
+      providers: {
+        "fal-ai": "num_inference_steps",
+        "replicate": "num_inference_steps",
+        "wavespeed": "num_inference_steps"
+      }
+    },
+    {
+      universal: "seed",
+      providers: {
+        "fal-ai": "seed",
+        "replicate": "seed",
+        "wavespeed": "seed"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "safety",
+      providers: {
+        "fal-ai": "enable_safety_checker",
+        "replicate": "disable_safety_checker",
+        "wavespeed": "enable_safety_checker"
+      },
+      transform: "flip_boolean"
+    }
+  ],
+  output_type: "video",
+  output_extract: {
+    "fal-ai": "video.url",
+    "replicate": "output",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 3e5
+};
+
+// src/categories/image-to-video.ts
+var imageToVideoTemplate = {
+  category: "image-to-video",
+  input_mappings: [
+    {
+      universal: "image",
+      providers: {
+        "fal-ai": "image_url",
+        "replicate": "image",
+        "wavespeed": "image_url"
+      },
+      required: true
+    },
+    {
+      universal: "prompt",
+      providers: {
+        "fal-ai": "prompt",
+        "replicate": "prompt",
+        "wavespeed": "prompt"
+      }
+    },
+    {
+      universal: "negative_prompt",
+      providers: {
+        "fal-ai": "negative_prompt",
+        "replicate": "negative_prompt",
+        "wavespeed": "negative_prompt"
+      }
+    },
+    {
+      universal: "seed",
+      providers: {
+        "fal-ai": "seed",
+        "replicate": "seed",
+        "wavespeed": "seed"
+      }
+    },
+    {
+      universal: "guidance",
+      providers: {
+        "fal-ai": "guidance_scale",
+        "replicate": "guidance",
+        "wavespeed": "guidance_scale"
+      }
+    },
+    {
+      universal: "steps",
+      providers: {
+        "fal-ai": "num_inference_steps",
+        "replicate": "num_inference_steps",
+        "wavespeed": "num_inference_steps"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "safety",
+      providers: {
+        "fal-ai": "enable_safety_checker",
+        "replicate": "disable_safety_checker",
+        "wavespeed": "enable_safety_checker"
+      },
+      transform: "flip_boolean"
+    }
+  ],
+  output_type: "video",
+  output_extract: {
+    "fal-ai": "video.url",
+    "replicate": "output",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 3e5
+};
+
+// src/categories/upscale-image.ts
+var upscaleImageTemplate = {
+  category: "upscale-image",
+  input_mappings: [
+    {
+      universal: "image",
+      providers: {
+        "fal-ai": "image_url",
+        "replicate": "image",
+        "wavespeed": "image_url"
+      },
+      required: true
+    },
+    {
+      universal: "strength",
+      providers: {
+        "fal-ai": "scale",
+        "replicate": "scale",
+        "wavespeed": "scale"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "quality",
+      providers: {
+        "fal-ai": "quality",
+        "replicate": "output_quality",
+        "wavespeed": "quality"
+      }
+    }
+  ],
+  output_type: "image",
+  output_extract: {
+    "fal-ai": "images[].url",
+    "replicate": "output[]",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 12e4
+};
+
+// src/categories/text-to-audio.ts
+var textToAudioTemplate = {
+  category: "text-to-audio",
+  input_mappings: [
+    {
+      universal: "prompt",
+      providers: {
+        "fal-ai": "text",
+        "replicate": "prompt",
+        "wavespeed": "prompt"
+      },
+      required: true
+    },
+    {
+      universal: "count",
+      providers: {
+        "fal-ai": "num_outputs",
+        "replicate": "num_outputs",
+        "wavespeed": "num_outputs"
+      }
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "seed",
+      providers: {
+        "fal-ai": "seed",
+        "replicate": "seed",
+        "wavespeed": "seed"
+      }
+    }
+  ],
+  output_type: "audio",
+  output_extract: {
+    "fal-ai": "audio.url",
+    "replicate": "output",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 6e4
+};
+
+// src/categories/audio-to-text.ts
+var audioToTextTemplate = {
+  category: "audio-to-text",
+  input_mappings: [
+    {
+      universal: "audio",
+      providers: {
+        "fal-ai": "audio_url",
+        "replicate": "audio",
+        "wavespeed": "audio_url"
+      },
+      required: true
+    }
+  ],
+  output_type: "text",
+  output_extract: {
+    "fal-ai": "text",
+    "replicate": "output.text",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 12e4
+};
+
+// src/categories/remove-background.ts
+var removeBackgroundTemplate = {
+  category: "remove-background",
+  input_mappings: [
+    {
+      universal: "image",
+      providers: {
+        "fal-ai": "image_url",
+        "replicate": "image",
+        "wavespeed": "image_url"
+      },
+      required: true
+    },
+    {
+      universal: "format",
+      providers: {
+        "fal-ai": "output_format",
+        "replicate": "output_format",
+        "wavespeed": "output_format"
+      }
+    },
+    {
+      universal: "quality",
+      providers: {
+        "fal-ai": "quality",
+        "replicate": "output_quality",
+        "wavespeed": "quality"
+      }
+    }
+  ],
+  output_type: "image",
+  output_extract: {
+    "fal-ai": "images[].url",
+    "replicate": "output[]",
+    "wavespeed": "data.outputs[]"
+  },
+  default_timeout_ms: 6e4
+};
+
+// src/categories/index.ts
+var templates = {
+  "text-to-image": textToImageTemplate,
+  "image-edit": imageEditTemplate,
+  "text-to-video": textToVideoTemplate,
+  "image-to-video": imageToVideoTemplate,
+  "upscale-image": upscaleImageTemplate,
+  "text-to-audio": textToAudioTemplate,
+  "audio-to-text": audioToTextTemplate,
+  "remove-background": removeBackgroundTemplate
+};
+function getCategoryTemplate(category) {
+  return templates[category];
+}
+
+// src/adapters/fal-ai.ts
+var BASE_URL = "https://queue.fal.run";
+async function handleHttpErrors(response, endpoint) {
+  if (response.ok) return;
+  const status = response.status;
+  if (status === 401) {
+    throw new AuthError("fal-ai", "FAL_KEY");
+  }
+  if (status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    const retryMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 6e4;
+    throw new RateLimitError("fal-ai", retryMs);
+  }
+  let raw;
+  try {
+    raw = await response.json();
+  } catch {
+    raw = await response.text().catch(() => null);
+  }
+  throw new ProviderError("fal-ai", endpoint, status, raw);
+}
+function authHeaders(auth) {
+  return {
+    Authorization: `Key ${auth}`,
+    "Content-Type": "application/json"
+  };
+}
+var falAiAdapter = {
+  name: "fal-ai",
+  async submit(endpoint, params, auth) {
+    const url = `${BASE_URL}/${endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: authHeaders(auth),
+      body: JSON.stringify(params)
+    });
+    await handleHttpErrors(response, endpoint);
+    const data = await response.json();
+    return {
+      id: data.request_id,
+      status: "pending"
+    };
+  },
+  async poll(taskId, auth, endpoint) {
+    if (!endpoint) {
+      throw new ProviderError("fal-ai", "unknown", 400, "endpoint is required for polling");
+    }
+    const statusUrl = `${BASE_URL}/${endpoint}/requests/${taskId}/status`;
+    const statusResponse = await fetch(statusUrl, {
+      headers: { Authorization: `Key ${auth}` }
+    });
+    await handleHttpErrors(statusResponse, endpoint);
+    const statusData = await statusResponse.json();
+    if (statusData.status === "FAILED") {
+      return {
+        id: taskId,
+        status: "failed",
+        error: statusData.error ?? "Unknown error"
+      };
+    }
+    if (statusData.status !== "COMPLETED") {
+      return {
+        id: taskId,
+        status: "processing"
+      };
+    }
+    const resultUrl = `${BASE_URL}/${endpoint}/requests/${taskId}`;
+    const resultResponse = await fetch(resultUrl, {
+      headers: { Authorization: `Key ${auth}` }
+    });
+    await handleHttpErrors(resultResponse, endpoint);
+    const output = await resultResponse.json();
+    return {
+      id: taskId,
+      status: "completed",
+      output
+    };
+  },
+  parseOutput(raw, outputMapping) {
+    const data = raw;
+    const path = outputMapping.extract_path;
+    if (path === "images[].url") {
+      const images = data.images;
+      if (!Array.isArray(images)) return [];
+      return images.map((img) => ({
+        type: outputMapping.type,
+        url: img.url,
+        content_type: img.content_type ?? outputMapping.content_type ?? "image/jpeg"
+      }));
+    }
+    if (path === "video.url") {
+      const video = data.video;
+      if (!video?.url) return [];
+      return [
+        {
+          type: outputMapping.type,
+          url: video.url,
+          content_type: video.content_type ?? outputMapping.content_type ?? "video/mp4"
+        }
+      ];
+    }
+    if (path === "audio.url") {
+      const audio = data.audio;
+      if (!audio?.url) return [];
+      return [
+        {
+          type: outputMapping.type,
+          url: audio.url,
+          content_type: audio.content_type ?? outputMapping.content_type ?? "audio/mpeg"
+        }
+      ];
+    }
+    return [];
+  }
+};
+
+// src/adapters/replicate.ts
+var BASE_URL2 = "https://api.replicate.com/v1";
+async function handleHttpErrors2(response, endpoint) {
+  if (response.ok) return;
+  const status = response.status;
+  if (status === 401) {
+    throw new AuthError("replicate", "REPLICATE_API_TOKEN");
+  }
+  if (status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    const retryMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 6e4;
+    throw new RateLimitError("replicate", retryMs);
+  }
+  let raw;
+  try {
+    raw = await response.json();
+  } catch {
+    raw = await response.text().catch(() => null);
+  }
+  throw new ProviderError("replicate", endpoint, status, raw);
+}
+function authHeaders2(auth) {
+  return {
+    Authorization: `Bearer ${auth}`,
+    "Content-Type": "application/json"
+  };
+}
+function inferContentType(url) {
+  const lower = url.toLowerCase();
+  if (lower.includes(".png")) return "image/png";
+  if (lower.includes(".jpg") || lower.includes(".jpeg")) return "image/jpeg";
+  if (lower.includes(".webp")) return "image/webp";
+  if (lower.includes(".mp4")) return "video/mp4";
+  if (lower.includes(".mp3")) return "audio/mpeg";
+  if (lower.includes(".wav")) return "audio/wav";
+  return "image/jpeg";
+}
+var replicateAdapter = {
+  name: "replicate",
+  async submit(endpoint, params, auth) {
+    const url = `${BASE_URL2}/models/${endpoint}/predictions`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: authHeaders2(auth),
+      body: JSON.stringify({ input: params })
+    });
+    await handleHttpErrors2(response, endpoint);
+    const data = await response.json();
+    return {
+      id: data.id,
+      status: "pending"
+    };
+  },
+  async poll(taskId, auth) {
+    const url = `${BASE_URL2}/predictions/${taskId}`;
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${auth}` }
+    });
+    await handleHttpErrors2(response, taskId);
+    const data = await response.json();
+    if (data.status === "succeeded") {
+      return {
+        id: data.id,
+        status: "completed",
+        output: data.output
+      };
+    }
+    if (data.status === "failed" || data.status === "canceled") {
+      return {
+        id: data.id,
+        status: "failed",
+        error: data.error ?? `Prediction ${data.status}`
+      };
+    }
+    return {
+      id: data.id,
+      status: "processing"
+    };
+  },
+  parseOutput(raw, outputMapping) {
+    if (!Array.isArray(raw)) return [];
+    return raw.map((url) => ({
+      type: outputMapping.type,
+      url,
+      content_type: outputMapping.content_type ?? inferContentType(url)
+    }));
+  }
+};
+
+// src/adapters/wavespeed.ts
+var BASE_URL3 = "https://api.wavespeed.ai/api/v3";
+async function handleHttpErrors3(response, endpoint) {
+  if (response.ok) return;
+  const status = response.status;
+  if (status === 401) {
+    throw new AuthError("wavespeed", "WAVESPEED_API_KEY");
+  }
+  if (status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    const retryMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 6e4;
+    throw new RateLimitError("wavespeed", retryMs);
+  }
+  let raw;
+  try {
+    raw = await response.json();
+  } catch {
+    raw = await response.text().catch(() => null);
+  }
+  throw new ProviderError("wavespeed", endpoint, status, raw);
+}
+function authHeaders3(auth) {
+  return {
+    Authorization: `Bearer ${auth}`,
+    "Content-Type": "application/json"
+  };
+}
+function inferContentType2(url) {
+  const ext = url.split(".").pop()?.toLowerCase()?.split("?")[0];
+  switch (ext) {
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "gif":
+      return "image/gif";
+    case "mp4":
+      return "video/mp4";
+    case "mp3":
+      return "audio/mpeg";
+    case "wav":
+      return "audio/wav";
+    default:
+      return "application/octet-stream";
+  }
+}
+var wavespeedAdapter = {
+  name: "wavespeed",
+  async submit(endpoint, params, auth) {
+    const url = `${BASE_URL3}/${endpoint}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: authHeaders3(auth),
+      body: JSON.stringify(params)
+    });
+    await handleHttpErrors3(response, endpoint);
+    const json = await response.json();
+    return {
+      id: json.data.id,
+      status: "pending"
+    };
+  },
+  async poll(taskId, auth) {
+    const url = `${BASE_URL3}/predictions/${taskId}/result`;
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${auth}` }
+    });
+    await handleHttpErrors3(response, `predictions/${taskId}/result`);
+    const json = await response.json();
+    const { data } = json;
+    if (data.status === "failed") {
+      return {
+        id: taskId,
+        status: "failed",
+        error: data.error ?? "Unknown error"
+      };
+    }
+    if (data.status === "completed") {
+      return {
+        id: taskId,
+        status: "completed",
+        output: data
+      };
+    }
+    return {
+      id: taskId,
+      status: "processing"
+    };
+  },
+  parseOutput(raw, outputMapping) {
+    const data = raw;
+    const outputs = data.outputs;
+    if (!Array.isArray(outputs)) return [];
+    return outputs.map((url) => ({
+      type: outputMapping.type,
+      url,
+      content_type: outputMapping.content_type ?? inferContentType2(url)
+    }));
+  }
+};
+
+// src/retry.ts
+var DEFAULT_OPTIONS = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  timeoutMs: 3e5
+};
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function isRetryable(error) {
+  if (error instanceof AuthError || error instanceof ValidationError || error instanceof ModelNotFoundError) {
+    return false;
+  }
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof ProviderError) {
+    return error.statusCode >= 500;
+  }
+  if (error instanceof TypeError) {
+    return true;
+  }
+  return false;
+}
+function getDelayMs(error, attempt, options) {
+  if (error instanceof RateLimitError) {
+    return error.retryAfterMs;
+  }
+  const jitter = Math.random() * options.initialDelayMs * 0.5;
+  const delay = options.initialDelayMs * Math.pow(2, attempt) + jitter;
+  return Math.min(delay, options.maxDelayMs);
+}
+async function withRetry(fn, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const startTime = Date.now();
+  let lastError;
+  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+    if (attempt > 0) {
+      const elapsed = Date.now() - startTime;
+      if (elapsed >= opts.timeoutMs) {
+        throw new TimeoutError("unknown", "unknown", opts.timeoutMs);
+      }
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRetryable(error)) {
+        throw error;
+      }
+      if (attempt >= opts.maxRetries) {
+        throw error;
+      }
+      const delay = getDelayMs(error, attempt, opts);
+      const elapsed = Date.now() - startTime;
+      if (elapsed + delay >= opts.timeoutMs) {
+        throw new TimeoutError("unknown", "unknown", opts.timeoutMs);
+      }
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+// src/gateway.ts
+var adapters = {
+  "fal-ai": falAiAdapter,
+  "replicate": replicateAdapter,
+  "wavespeed": wavespeedAdapter
+};
+async function generate(request) {
+  const startTime = Date.now();
+  if (!request.model) throw new ValidationError("model", "model is required");
+  const auth = new AuthManager();
+  const model = resolveModel(request.model, auth.availableProviders());
+  const availableBindings = model.providers.filter(
+    (p) => auth.availableProviders().includes(p.provider) && adapters[p.provider]
+  );
+  if (availableBindings.length === 0) {
+    throw new ValidationError(
+      "model",
+      `No adapter available for model "${model.canonical_name}". Available providers: ${model.providers.map((p) => p.provider).join(", ")}`
+    );
+  }
+  const binding = availableBindings[0];
+  const template = getCategoryTemplate(model.category);
+  if (!template) {
+    throw new ValidationError("model", `No category template for "${model.category}" yet`);
+  }
+  const providerParams = mapInput(request, binding, template);
+  const adapter = adapters[binding.provider];
+  const apiKey = auth.getKey(binding.provider);
+  const timeoutMs = request.options?.timeout ?? template.default_timeout_ms;
+  const submitted = await withRetry(
+    () => adapter.submit(binding.endpoint, providerParams, apiKey),
+    { timeoutMs }
+  );
+  let result = submitted;
+  while (result.status === "processing" || result.status === "pending") {
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    result = await adapter.poll(submitted.id, apiKey, binding.endpoint);
+  }
+  if (result.status === "failed") {
+    throw new ProviderError(
+      binding.provider,
+      model.canonical_name,
+      0,
+      result.error || "Generation failed"
+    );
+  }
+  const outputs = mapOutput(result.output, binding.output_map);
+  return {
+    id: randomUUID(),
+    model: model.canonical_name,
+    provider: binding.provider,
+    status: "completed",
+    outputs,
+    metadata: {
+      inference_time_ms: Date.now() - startTime,
+      seed: typeof result.output === "object" && result.output !== null ? result.output.seed : void 0,
+      safety_flagged: typeof result.output === "object" && result.output !== null ? Array.isArray(result.output.has_nsfw_concepts) ? result.output.has_nsfw_concepts.some((v) => v) : void 0 : void 0
+    }
+  };
+}
+
+// src/discovery.ts
+function listModels(filters) {
+  const auth = new AuthManager();
+  let models = auth.listAvailableModels(loadRegistry());
+  if (filters?.category) {
+    models = models.filter((m) => m.category === filters.category);
+  }
+  if (filters?.provider) {
+    models = models.filter(
+      (m) => m.providers.some((p) => p.provider === filters.provider)
+    );
+  }
+  if (filters?.query) {
+    const q = filters.query.toLowerCase();
+    models = models.filter(
+      (m) => m.canonical_name.includes(q) || m.aliases.some((a) => a.includes(q))
+    );
+  }
+  return models;
+}
+function getModel(name) {
+  return resolveModel(name);
+}
+
+export {
+  GetAIApiError,
+  AuthError,
+  ModelNotFoundError,
+  ValidationError,
+  ProviderError,
+  TimeoutError,
+  RateLimitError,
+  generate,
+  listModels,
+  getModel
+};
+//# sourceMappingURL=chunk-O4TLMX4T.js.map