getaiapi 0.4.12 → 1.0.0-alpha.0

package/dist/{chunk-LZV7KTSS.js → chunk-LHDSEV4H.js}

@@ -1,164 +1,21 @@
-// src/gateway.ts
-import { randomUUID as randomUUID2 } 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 NoProviderError = class extends GetAIApiError {
-  query;
-  model;
-  requiredProviders;
-  availableProviders;
-  constructor(query, model, requiredProviders, availableProviders) {
-    const envHints = {
-      "fal-ai": "FAL_KEY",
-      replicate: "REPLICATE_API_TOKEN",
-      wavespeed: "WAVESPEED_API_KEY",
-      openrouter: "OPENROUTER_API_KEY"
-    };
-    const needed = requiredProviders.map((p) => `${p} (${envHints[p] || "unknown"})`).join(" or ");
-    super(
-      `Model "${query}" found but requires ${needed}. You have: ${availableProviders.length > 0 ? availableProviders.join(", ") : "none"}.`
-    );
-    this.name = "NoProviderError";
-    this.query = query;
-    this.model = model;
-    this.requiredProviders = requiredProviders;
-    this.availableProviders = availableProviders;
-  }
-};
-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;
-  }
-};
-var StorageError = class extends GetAIApiError {
-  operation;
-  statusCode;
-  constructor(operation, message, statusCode) {
-    super(`Storage ${operation} failed: ${message}`);
-    this.name = "StorageError";
-    this.operation = operation;
-    this.statusCode = statusCode;
-  }
-};
+import {
+  AuthManager,
+  ModelNotFoundError,
+  NoProviderError,
+  ProviderError,
+  ValidationError,
+  configureAuth,
+  configureStorage,
+  falAiAdapter,
+  openRouterAdapter,
+  processParamsForUpload,
+  replicateAdapter,
+  wavespeedAdapter,
+  withRetry
+} from "./chunk-P7XV6JOH.js";
 
-// src/auth.ts
-var ENV_MAP = {
-  "fal-ai": "FAL_KEY",
-  replicate: "REPLICATE_API_TOKEN",
-  wavespeed: "WAVESPEED_API_KEY",
-  openrouter: "OPENROUTER_API_KEY"
-};
-var keyOverrides = /* @__PURE__ */ new Map();
-function configureAuth(keys) {
-  for (const [provider, key] of Object.entries(keys)) {
-    if (key?.trim()) {
-      keyOverrides.set(provider, key.trim());
-    }
-  }
-}
-var AuthManager = class {
-  keys;
-  constructor() {
-    this.keys = /* @__PURE__ */ new Map();
-    for (const [provider, key] of keyOverrides) {
-      this.keys.set(provider, key);
-    }
-    for (const [provider, envVar] of Object.entries(ENV_MAP)) {
-      if (!this.keys.has(provider)) {
-        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/gateway.ts
+import { randomUUID } from "crypto";
 
 // src/resolver.ts
 import { readFileSync } from "fs";
@@ -1503,869 +1360,6 @@ function getCategoryTemplate(category) {
   return templates[category];
 }
 
-// src/adapters/fal-ai.ts
-var BASE_URL = "https://queue.fal.run";
-function getBaseEndpoint(endpoint) {
-  const parts = endpoint.split("/");
-  if (parts.length <= 2) return endpoint;
-  return `${parts[0]}/${parts[1]}`;
-}
-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 baseEndpoint = getBaseEndpoint(endpoint);
-    const statusUrl = `${BASE_URL}/${baseEndpoint}/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}/${baseEndpoint}/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 === "image.url") {
-      const image = data.image;
-      if (!image?.url) return [];
-      return [
-        {
-          type: outputMapping.type,
-          url: image.url,
-          content_type: image.content_type ?? outputMapping.content_type ?? "image/png"
-        }
-      ];
-    }
-    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"
-        }
-      ];
-    }
-    if (path === "audio_file.url") {
-      const audioFile = data.audio_file;
-      if (!audioFile?.url) return [];
-      return [
-        {
-          type: outputMapping.type,
-          url: audioFile.url,
-          content_type: audioFile.content_type ?? outputMapping.content_type ?? "audio/mpeg"
-        }
-      ];
-    }
-    if (path === "audio_url") {
-      const audioUrl = data.audio_url;
-      if (!audioUrl) return [];
-      const url = typeof audioUrl === "string" ? audioUrl : audioUrl.url;
-      if (!url) return [];
-      return [
-        {
-          type: outputMapping.type,
-          url,
-          content_type: (typeof audioUrl === "object" ? audioUrl.content_type : void 0) ?? outputMapping.content_type ?? "audio/mpeg"
-        }
-      ];
-    }
-    if (path === "video_url") {
-      const videoUrl = data.video_url;
-      if (!videoUrl) return [];
-      return [
-        {
-          type: outputMapping.type,
-          url: videoUrl,
-          content_type: outputMapping.content_type ?? "video/mp4"
-        }
-      ];
-    }
-    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 versionCache = /* @__PURE__ */ new Map();
-var legacyEndpoints = /* @__PURE__ */ new Set();
-async function fetchLatestVersion(endpoint, auth) {
-  const cached = versionCache.get(endpoint);
-  if (cached) return cached;
-  const url = `${BASE_URL2}/models/${endpoint}`;
-  const response = await fetch(url, {
-    headers: { Authorization: `Bearer ${auth}` }
-  });
-  await handleHttpErrors2(response, endpoint);
-  const data = await response.json();
-  if (!data.latest_version?.id) {
-    throw new ProviderError("replicate", endpoint, 404, "No version found for model");
-  }
-  versionCache.set(endpoint, data.latest_version.id);
-  return data.latest_version.id;
-}
-async function submitWithVersion(endpoint, params, auth) {
-  const version = await fetchLatestVersion(endpoint, auth);
-  const response = await fetch(`${BASE_URL2}/predictions`, {
-    method: "POST",
-    headers: authHeaders2(auth),
-    body: JSON.stringify({ version, input: params })
-  });
-  await handleHttpErrors2(response, endpoint);
-  const data = await response.json();
-  return { id: data.id, status: "pending" };
-}
-var replicateAdapter = {
-  name: "replicate",
-  async submit(endpoint, params, auth) {
-    if (legacyEndpoints.has(endpoint)) {
-      return submitWithVersion(endpoint, params, auth);
-    }
-    const modelsUrl = `${BASE_URL2}/models/${endpoint}/predictions`;
-    const response = await fetch(modelsUrl, {
-      method: "POST",
-      headers: authHeaders2(auth),
-      body: JSON.stringify({ input: params })
-    });
-    if (response.status !== 404) {
-      await handleHttpErrors2(response, endpoint);
-      const data = await response.json();
-      return { id: data.id, status: "pending" };
-    }
-    legacyEndpoints.add(endpoint);
-    return submitWithVersion(endpoint, params, auth);
-  },
-  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/adapters/openrouter.ts
-var BASE_URL4 = "https://openrouter.ai/api/v1";
-async function handleHttpErrors4(response, endpoint) {
-  if (response.ok) return;
-  const status = response.status;
-  if (status === 401) {
-    throw new AuthError("openrouter", "OPENROUTER_API_KEY");
-  }
-  if (status === 429) {
-    const retryAfter = response.headers.get("retry-after");
-    const retryMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 6e4;
-    throw new RateLimitError("openrouter", retryMs);
-  }
-  let raw;
-  try {
-    raw = await response.json();
-  } catch {
-    raw = await response.text().catch(() => null);
-  }
-  throw new ProviderError("openrouter", endpoint, status, raw);
-}
-function authHeaders4(auth) {
-  return {
-    Authorization: `Bearer ${auth}`,
-    "Content-Type": "application/json",
-    "X-Title": "getaiapi"
-  };
-}
-var openRouterAdapter = {
-  name: "openrouter",
-  async submit(endpoint, params, auth) {
-    const { prompt, system, temperature, max_tokens, top_p, ...rest } = params;
-    const messages = [];
-    if (system && typeof system === "string") {
-      messages.push({ role: "system", content: system });
-    }
-    messages.push({ role: "user", content: prompt ?? "" });
-    const body = {
-      model: endpoint,
-      messages,
-      ...rest
-    };
-    if (temperature !== void 0) body.temperature = temperature;
-    if (max_tokens !== void 0) body.max_tokens = max_tokens;
-    if (top_p !== void 0) body.top_p = top_p;
-    const url = `${BASE_URL4}/chat/completions`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: authHeaders4(auth),
-      body: JSON.stringify(body)
-    });
-    await handleHttpErrors4(response, endpoint);
-    const data = await response.json();
-    return {
-      id: data.id,
-      status: "completed",
-      output: data
-    };
-  },
-  async poll(taskId) {
-    return {
-      id: taskId,
-      status: "completed"
-    };
-  },
-  parseOutput(raw, outputMapping) {
-    const data = raw;
-    const choices = data.choices;
-    if (!Array.isArray(choices) || choices.length === 0) return [];
-    const content = choices[0].message?.content;
-    if (typeof content !== "string") return [];
-    return [
-      {
-        type: outputMapping.type,
-        content,
-        content_type: outputMapping.content_type ?? "text/plain"
-      }
-    ];
-  }
-};
-
-// 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/storage.ts
-import { randomUUID } from "crypto";
-
-// src/s3-signer.ts
-import { createHmac, createHash } from "crypto";
-function sha256(data) {
-  return createHash("sha256").update(data).digest("hex");
-}
-function hmacSha256(key, data) {
-  return createHmac("sha256", key).update(data).digest();
-}
-function getSigningKey(secretKey, dateStamp, region, service) {
-  const kDate = hmacSha256(`AWS4${secretKey}`, dateStamp);
-  const kRegion = hmacSha256(kDate, region);
-  const kService = hmacSha256(kRegion, service);
-  return hmacSha256(kService, "aws4_request");
-}
-function toAmzDate(date) {
-  const iso = date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  return {
-    amzDate: iso,
-    dateStamp: iso.slice(0, 8)
-  };
-}
-function signS3Request(method, url, headers, body, credentials) {
-  const region = credentials.region ?? "auto";
-  const service = "s3";
-  const parsedUrl = new URL(url);
-  const now = /* @__PURE__ */ new Date();
-  const { amzDate, dateStamp } = toAmzDate(now);
-  const payloadHash = body ? sha256(body) : sha256("");
-  const allHeaders = {
-    ...headers,
-    host: parsedUrl.host,
-    "x-amz-date": amzDate,
-    "x-amz-content-sha256": payloadHash
-  };
-  const lcHeaders = Object.fromEntries(
-    Object.entries(allHeaders).map(([k, v]) => [k.toLowerCase(), v.trim()])
-  );
-  const sortedKeys = Object.keys(lcHeaders).sort();
-  const canonicalHeaders = sortedKeys.map((k) => `${k}:${lcHeaders[k]}`).join("\n") + "\n";
-  const signedHeaders = sortedKeys.join(";");
-  const canonicalRequest = [
-    method,
-    parsedUrl.pathname,
-    parsedUrl.searchParams.toString(),
-    canonicalHeaders,
-    signedHeaders,
-    payloadHash
-  ].join("\n");
-  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
-  const stringToSign = [
-    "AWS4-HMAC-SHA256",
-    amzDate,
-    scope,
-    sha256(canonicalRequest)
-  ].join("\n");
-  const signingKey = getSigningKey(credentials.secretAccessKey, dateStamp, region, service);
-  const signature = createHmac("sha256", signingKey).update(stringToSign).digest("hex");
-  const authorization = `AWS4-HMAC-SHA256 Credential=${credentials.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-  return {
-    url,
-    headers: {
-      ...lcHeaders,
-      authorization
-    }
-  };
-}
-function presignS3Url(url, credentials, options) {
-  const region = credentials.region ?? "auto";
-  const service = "s3";
-  const parsedUrl = new URL(url);
-  const now = /* @__PURE__ */ new Date();
-  const { amzDate, dateStamp } = toAmzDate(now);
-  const expiresIn = options?.expiresIn ?? 3600;
-  const host = parsedUrl.host;
-  const signedHeaders = "host";
-  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
-  const credential = `${credentials.accessKeyId}/${scope}`;
-  const queryParams = new URLSearchParams({
-    "X-Amz-Algorithm": "AWS4-HMAC-SHA256",
-    "X-Amz-Credential": credential,
-    "X-Amz-Date": amzDate,
-    "X-Amz-Expires": String(expiresIn),
-    "X-Amz-SignedHeaders": signedHeaders
-  });
-  const canonicalRequest = [
-    "GET",
-    parsedUrl.pathname,
-    queryParams.toString(),
-    `host:${host}
-`,
-    signedHeaders,
-    "UNSIGNED-PAYLOAD"
-  ].join("\n");
-  const stringToSign = [
-    "AWS4-HMAC-SHA256",
-    amzDate,
-    scope,
-    sha256(canonicalRequest)
-  ].join("\n");
-  const signingKey = getSigningKey(credentials.secretAccessKey, dateStamp, region, service);
-  const signature = createHmac("sha256", signingKey).update(stringToSign).digest("hex");
-  queryParams.set("X-Amz-Signature", signature);
-  return `${parsedUrl.origin}${parsedUrl.pathname}?${queryParams.toString()}`;
-}
-
-// src/storage.ts
-var MAX_PRESIGN_EXPIRES = 604800;
-var storageConfig = null;
-function parseExpiresIn(value) {
-  if (!value) return void 0;
-  const parsed = parseInt(value, 10);
-  if (Number.isNaN(parsed) || parsed <= 0) {
-    throw new StorageError("config", `Invalid R2_PRESIGN_EXPIRES_IN: "${value}". Must be a positive integer.`);
-  }
-  return parsed;
-}
-function configureStorage(config) {
-  if (config) {
-    storageConfig = config;
-    return;
-  }
-  const accountId = process.env.R2_ACCOUNT_ID;
-  const bucketName = process.env.R2_BUCKET_NAME;
-  const accessKeyId = process.env.R2_ACCESS_KEY_ID;
-  const secretAccessKey = process.env.R2_SECRET_ACCESS_KEY;
-  if (!accountId || !bucketName || !accessKeyId || !secretAccessKey) {
-    throw new StorageError(
-      "config",
-      "Missing R2 credentials. Provide a config object or set R2_ACCOUNT_ID, R2_BUCKET_NAME, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY environment variables."
-    );
-  }
-  storageConfig = {
-    accountId,
-    bucketName,
-    accessKeyId,
-    secretAccessKey,
-    publicUrlBase: process.env.R2_PUBLIC_URL,
-    autoUpload: false,
-    mode: process.env.R2_STORAGE_MODE === "presigned" ? "presigned" : void 0,
-    presignExpiresIn: parseExpiresIn(process.env.R2_PRESIGN_EXPIRES_IN)
-  };
-}
-function getStorageConfig() {
-  return storageConfig;
-}
-function getConfig() {
-  if (!storageConfig) {
-    throw new StorageError("config", "Storage not configured. Call configureStorage() first.");
-  }
-  return storageConfig;
-}
-function buildR2Url(config, key) {
-  return `https://${config.accountId}.r2.cloudflarestorage.com/${config.bucketName}/${key}`;
-}
-function buildPublicUrl(config, key) {
-  if (config.publicUrlBase) {
-    const base = config.publicUrlBase.replace(/\/$/, "");
-    return `${base}/${key}`;
-  }
-  return buildR2Url(config, key);
-}
-function detectContentType(input) {
-  if (input instanceof File) return input.type || "application/octet-stream";
-  if (input instanceof Blob) return input.type || "application/octet-stream";
-  return "application/octet-stream";
-}
-async function toBuffer(input) {
-  if (Buffer.isBuffer(input)) return input;
-  if (input instanceof ArrayBuffer) return Buffer.from(input);
-  if (input instanceof Blob) return Buffer.from(await input.arrayBuffer());
-  return Buffer.from(input);
-}
-async function uploadAsset(input, options) {
-  const config = getConfig();
-  const buffer = await toBuffer(input);
-  const maxBytes = options?.maxBytes ?? DEFAULT_MAX_BYTES;
-  if (buffer.length > maxBytes) {
-    throw new StorageError(
-      "upload",
-      `Asset too large (${buffer.length} bytes, max ${maxBytes})`
-    );
-  }
-  const contentType = options?.contentType ?? detectContentType(input);
-  const prefix = options?.prefix ? `${options.prefix.replace(/\/$/, "")}/` : "";
-  const key = options?.key ?? `${prefix}${randomUUID()}`;
-  const r2Url = buildR2Url(config, key);
-  const signed = signS3Request(
-    "PUT",
-    r2Url,
-    { "Content-Type": contentType, "Content-Length": String(buffer.length) },
-    buffer,
-    {
-      accessKeyId: config.accessKeyId,
-      secretAccessKey: config.secretAccessKey
-    }
-  );
-  const response = await fetch(signed.url, {
-    method: "PUT",
-    headers: signed.headers,
-    body: new Uint8Array(buffer)
-  });
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new StorageError("upload", `R2 returned ${response.status}: ${body}`, response.status);
-  }
-  const url = config.mode === "presigned" ? validatedPresign(config, key) : buildPublicUrl(config, key);
-  return {
-    url,
-    key,
-    size_bytes: buffer.length,
-    content_type: contentType
-  };
-}
-function validatedPresign(config, key, expiresIn) {
-  const ttl = expiresIn ?? config.presignExpiresIn ?? 3600;
-  if (ttl > MAX_PRESIGN_EXPIRES) {
-    throw new StorageError(
-      "config",
-      `Presign expiry ${ttl}s exceeds maximum of ${MAX_PRESIGN_EXPIRES}s (7 days).`
-    );
-  }
-  return presignS3Url(buildR2Url(config, key), {
-    accessKeyId: config.accessKeyId,
-    secretAccessKey: config.secretAccessKey
-  }, { expiresIn: ttl });
-}
-function presignAsset(key, options) {
-  const config = getConfig();
-  return validatedPresign(config, key, options?.expiresIn);
-}
-async function deleteAsset(key) {
-  const config = getConfig();
-  const r2Url = buildR2Url(config, key);
-  const signed = signS3Request(
-    "DELETE",
-    r2Url,
-    {},
-    null,
-    {
-      accessKeyId: config.accessKeyId,
-      secretAccessKey: config.secretAccessKey
-    }
-  );
-  const response = await fetch(signed.url, {
-    method: "DELETE",
-    headers: signed.headers
-  });
-  if (!response.ok && response.status !== 404) {
-    const body = await response.text().catch(() => "");
-    throw new StorageError("delete", `R2 returned ${response.status}: ${body}`, response.status);
-  }
-}
-var DEFAULT_PREFIX = "getaiapi-tmp";
-var DEFAULT_MAX_BYTES = 500 * 1024 * 1024;
-function isBinaryValue(value) {
-  return Buffer.isBuffer(value) || value instanceof File || value instanceof Blob || value instanceof ArrayBuffer;
-}
-function isUrl(value) {
-  return typeof value === "string" && (value.startsWith("http://") || value.startsWith("https://"));
-}
-async function fetchAndReupload(url, maxBytes) {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new StorageError("upload", `Failed to fetch URL for re-upload: ${url}`);
-  }
-  const contentLength = response.headers.get("content-length");
-  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
-    throw new StorageError(
-      "upload",
-      `URL content too large (${contentLength} bytes, max ${maxBytes}): ${url}`
-    );
-  }
-  const buffer = Buffer.from(await response.arrayBuffer());
-  if (buffer.length > maxBytes) {
-    throw new StorageError(
-      "upload",
-      `URL content too large (${buffer.length} bytes, max ${maxBytes}): ${url}`
-    );
-  }
-  const contentType = response.headers.get("content-type") ?? "application/octet-stream";
-  const uploaded = await uploadAsset(buffer, { contentType, prefix: DEFAULT_PREFIX });
-  return uploaded.url;
-}
-async function processValue(value, shouldReupload, maxBytes) {
-  if (isBinaryValue(value)) {
-    const uploaded = await uploadAsset(value, { prefix: DEFAULT_PREFIX });
-    return uploaded.url;
-  }
-  if (isUrl(value) && shouldReupload) {
-    return fetchAndReupload(value, maxBytes);
-  }
-  if (Array.isArray(value)) {
-    const results = await Promise.all(
-      value.map((item) => processValue(item, shouldReupload, maxBytes))
-    );
-    return results;
-  }
-  if (value !== null && typeof value === "object" && !(value instanceof Date)) {
-    return processRecord(
-      value,
-      shouldReupload,
-      maxBytes
-    );
-  }
-  return value;
-}
-async function processRecord(obj, shouldReupload, maxBytes) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    result[key] = await processValue(value, shouldReupload, maxBytes);
-  }
-  return result;
-}
-async function processParamsForUpload(params, options) {
-  const config = getStorageConfig();
-  if (!config) return params;
-  const shouldReupload = options?.reupload || config.autoUpload || false;
-  const maxBytes = options?.maxBytes ?? DEFAULT_MAX_BYTES;
-  return processRecord(params, shouldReupload, maxBytes);
-}
-
 // src/gateway.ts
 var adapters = {
   "fal-ai": falAiAdapter,
@@ -2430,7 +1424,7 @@ async function generate(request) {
     metadata.completion_tokens = usage.completion_tokens;
   }
   return {
-    id: randomUUID2(),
+    id: randomUUID(),
     model: model.canonical_name,
     provider: binding.provider,
     status: "completed",
@@ -2477,23 +1471,9 @@ function getModel(name) {
 }
 
 export {
-  GetAIApiError,
-  AuthError,
-  ModelNotFoundError,
-  NoProviderError,
-  ValidationError,
-  ProviderError,
-  TimeoutError,
-  RateLimitError,
-  StorageError,
-  configureAuth,
-  configureStorage,
-  uploadAsset,
-  presignAsset,
-  deleteAsset,
   generate,
   configure,
   listModels,
   getModel
 };
-//# sourceMappingURL=chunk-LZV7KTSS.js.map
+//# sourceMappingURL=chunk-LHDSEV4H.js.map