@umituz/web-ai 1.0.2 → 1.0.4

package/dist/hooks/index.cjs

@@ -2627,39 +2627,814 @@ var FalProvider = class extends BaseProvider {
   }
 };
 
-// src/providers/pruna/pruna-generate.ts
-var prunaCorePromise = null;
-async function loadPrunaCore() {
-  if (!prunaCorePromise) {
-    const specifier = "@umituz/pruna-provider/core";
-    prunaCorePromise = import(specifier);
+// src/providers/pruna/client/core/constants/limits.ts
+var DEFAULT_ASPECT_RATIO = "16:9";
+var P_VIDEO_DEFAULTS = {
+  duration: 5,
+  resolution: "720p",
+  fps: 24,
+  draft: false,
+  promptUpsampling: true
+};
+var POLL_DEFAULTS = {
+  intervalMs: 3e3,
+  maxAttempts: 120,
+  maxIntervalMs: 1e4,
+  backoffBase: 1.5,
+  jitterPercent: 0.1
+};
+var DEFAULT_DEDUPLICATOR_TTL_MS = 3e4;
+var DEDUPLICATOR_CLEANUP_GRACE_MS = 100;
+
+// src/providers/pruna/client/core/constants/network.ts
+var HTTPS_PREFIX = "https://";
+var HTTP_PREFIX = "http://";
+var BASE64_MARKER = "base64,";
+var PRUNA_BASE_URL = "https://api.pruna.ai";
+var PRUNA_PREDICTIONS_URL = `${PRUNA_BASE_URL}/v1/predictions`;
+var PRUNA_FILES_URL = `${PRUNA_BASE_URL}/v1/files`;
+var AUTH_FAILURE_STATUSES = [401, 403];
+var MIN_API_KEY_LENGTH = 1;
+var MAX_API_KEY_LENGTH = 256;
+
+// src/providers/pruna/client/core/constants/mime-types.ts
+var MIME_PNG = "image/png";
+var MIME_JPEG = "image/jpeg";
+var MIME_WEBP = "image/webp";
+var DEFAULT_IMAGE_MIME = MIME_PNG;
+var MIME_FILE_EXTENSION = {
+  [MIME_PNG]: "png",
+  [MIME_JPEG]: "jpg",
+  [MIME_WEBP]: "webp"
+};
+var IMAGE_SIGNATURES = {
+  PNG: [137, 80],
+  JPEG: [255, 216],
+  WEBP_RIFF: [82, 73]
+};
+
+// src/providers/pruna/client/core/errors/cancellation-error.ts
+var CANCELLATION_MESSAGE = "Request cancelled by user";
+var CancellationError = class extends Error {
+  constructor(message = CANCELLATION_MESSAGE) {
+    super(message);
+    this.name = "CancellationError";
   }
-  return prunaCorePromise;
+};
+function isCancellationError(value) {
+  return value instanceof CancellationError;
 }
-async function* generateWithPruna(request, apiKey, signal, onProgress) {
-  const prunaCore = await loadPrunaCore();
-  if (prunaCore.generateWithPruna) {
-    yield* prunaCore.generateWithPruna(request, apiKey, signal, onProgress);
-    return;
-  }
-  if (!prunaCore.submitPrediction || !prunaCore.pollForResult) {
-    throw new Error("@umituz/pruna-provider/core does not export required functions");
-  }
-  const modelId = request.model || (request.image ? "p-image-edit" : "p-image");
-  const prediction = await prunaCore.submitPrediction(modelId, request, apiKey, signal, onProgress);
-  if (prediction.output && typeof prediction.output === "object" && "url" in prediction.output) {
-    yield {
-      stage: "predicting",
-      result: { url: prediction.output.url, model: modelId }
+
+// src/providers/pruna/client/core/errors/authentication-error.ts
+var AUTHENTICATION_MESSAGE = "Authentication failed. Please check your API key.";
+var AuthenticationError = class extends Error {
+  constructor(message = AUTHENTICATION_MESSAGE) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/timeout-error.ts
+var TIMEOUT_MESSAGE = "Generation timed out. Maximum polling attempts reached.";
+var TimeoutError = class extends Error {
+  constructor(message = TIMEOUT_MESSAGE) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/providers/pruna/client/core/errors/validation-error.ts
+var ValidationError2 = class extends Error {
+  field;
+  reason;
+  receivedValue;
+  constructor(context) {
+    super(`Invalid ${context.field}: ${context.reason}`);
+    this.name = "ValidationError";
+    this.field = context.field;
+    this.reason = context.reason;
+    this.receivedValue = context.receivedValue;
+  }
+};
+
+// src/providers/pruna/client/core/utils/base64.ts
+var globalScope = globalThis;
+var hasBuffer = typeof globalScope.Buffer?.from === "function";
+function base64ToBytes(raw) {
+  if (hasBuffer) {
+    const bufferFactory = globalScope.Buffer;
+    if (!bufferFactory) {
+      throw new Error("Buffer unavailable despite detection flag");
+    }
+    const buf = bufferFactory.from(raw, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const decoded = atob(raw);
+  return Uint8Array.from(decoded, (char) => char.charCodeAt(0));
+}
+
+// src/providers/pruna/client/core/utils/mime-detector.ts
+var MIN_SIGNATURE_BYTES = 2;
+function matchesSignature(bytes, signature) {
+  if (bytes.length < signature.length) return false;
+  return signature.every((value, index) => bytes[index] === value);
+}
+function detectImageMime(bytes) {
+  if (bytes.length < MIN_SIGNATURE_BYTES) return DEFAULT_IMAGE_MIME;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.PNG)) return MIME_PNG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.JPEG)) return MIME_JPEG;
+  if (matchesSignature(bytes, IMAGE_SIGNATURES.WEBP_RIFF)) return MIME_WEBP;
+  return DEFAULT_IMAGE_MIME;
+}
+
+// src/providers/pruna/client/core/utils/api-error-parser.ts
+async function parseApiError(response, fallback) {
+  const payload = await response.json().catch(() => ({ message: response.statusText }));
+  const message = payload.message ?? `${fallback}: ${response.status}`;
+  const error = new Error(message);
+  error.statusCode = response.status;
+  return error;
+}
+
+// src/providers/pruna/client/core/protocol/http-status.ts
+function isAuthFailureStatus(status) {
+  return AUTH_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/job-status.ts
+var TERMINAL_SUCCESS_STATUSES = ["succeeded", "completed"];
+var TERMINAL_FAILURE_STATUSES = ["failed"];
+function isTerminalSuccessStatus(status) {
+  if (!status) return false;
+  return TERMINAL_SUCCESS_STATUSES.includes(status);
+}
+function isTerminalFailureStatus(status) {
+  if (!status) return false;
+  return TERMINAL_FAILURE_STATUSES.includes(status);
+}
+
+// src/providers/pruna/client/core/protocol/abort-signal-classifier.ts
+function isAbortError(err) {
+  if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true;
+  if (err instanceof Error && err.name === "AbortError") return true;
+  return false;
+}
+
+// src/providers/pruna/client/core/protocol/pruna-url-builder.ts
+function isAbsoluteHttpUrl(value) {
+  return value.startsWith(HTTPS_PREFIX) || value.startsWith(HTTP_PREFIX);
+}
+function isHttpsUrl(value) {
+  return value.startsWith(HTTPS_PREFIX);
+}
+function buildPrunaApiUrl(pathOrUrl) {
+  if (isAbsoluteHttpUrl(pathOrUrl)) return pathOrUrl;
+  return `${PRUNA_BASE_URL}${pathOrUrl}`;
+}
+function buildFileUrlById(fileId) {
+  return `${PRUNA_FILES_URL}/${fileId}`;
+}
+
+// src/providers/pruna/client/core/math/exponential-backoff.ts
+function calculateExponentialBackoff2(inputs) {
+  const {
+    attempt,
+    baseIntervalMs,
+    maxIntervalMs = POLL_DEFAULTS.maxIntervalMs,
+    jitterPercent = POLL_DEFAULTS.jitterPercent,
+    growthBase = POLL_DEFAULTS.backoffBase
+  } = inputs;
+  const safeAttempt = Math.max(0, attempt);
+  const safeBase = Math.max(0, baseIntervalMs);
+  const exponentialDelay = Math.min(safeBase * Math.pow(growthBase, safeAttempt), maxIntervalMs);
+  const jitter = exponentialDelay * jitterPercent * Math.random();
+  return exponentialDelay + jitter;
+}
+
+// src/providers/pruna/client/core/utils/uri-resolver.ts
+var uriCache = /* @__PURE__ */ new WeakMap();
+function stripBase64Prefix(image) {
+  if (isHttpsUrl(image)) return image;
+  const base64Index = image.indexOf(BASE64_MARKER);
+  return base64Index !== -1 ? image.slice(base64Index + BASE64_MARKER.length) : image;
+}
+function readOutput(output) {
+  if (typeof output === "string") return output;
+  if (Array.isArray(output) && output.length > 0) return output[0] ?? null;
+  if (output !== null && typeof output === "object" && "url" in output) {
+    return output.url;
+  }
+  return null;
+}
+function extractUri(data) {
+  const cached = uriCache.get(data);
+  if (cached !== void 0) return cached;
+  if (!isTerminalSuccessStatus(data.status)) {
+    uriCache.set(data, null);
+    return null;
+  }
+  const result = data.generation_url ?? readOutput(data.output) ?? data.video_url ?? data.data ?? null;
+  uriCache.set(data, result);
+  return result;
+}
+function resolveUri(uri) {
+  return uri.startsWith("/") ? `${PRUNA_BASE_URL}${uri}` : uri;
+}
+
+// src/providers/pruna/client/core/services/pruna-client.service.ts
+function buildFileExtension(mime) {
+  return MIME_FILE_EXTENSION[mime] ?? "bin";
+}
+async function uploadImage(base64OrUrl, apiKey, onProgress) {
+  if (isHttpsUrl(base64OrUrl)) return base64OrUrl;
+  if (base64OrUrl.startsWith(HTTP_PREFIX)) {
+    throw new Error("Only HTTPS URLs are supported for security.");
+  }
+  onProgress?.("uploading");
+  const raw = stripBase64Prefix(base64OrUrl);
+  let bytes;
+  try {
+    bytes = base64ToBytes(raw);
+  } catch {
+    throw new Error("Invalid image format. Provide base64 or a valid HTTPS URL.");
+  }
+  const mime = detectImageMime(bytes);
+  const buffer = bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const blob = new Blob([buffer], { type: mime });
+  const formData = new FormData();
+  formData.append("content", blob, `upload.${buildFileExtension(mime)}`);
+  const res = await fetch(PRUNA_FILES_URL, {
+    method: "POST",
+    headers: { apikey: apiKey },
+    body: formData
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "File upload error");
+  }
+  const data = await res.json();
+  return data.urls?.get ?? buildFileUrlById(data.id ?? "");
+}
+async function submitPrediction(model, input, apiKey, signal, onProgress) {
+  onProgress?.("predicting");
+  const res = await fetch(PRUNA_PREDICTIONS_URL, {
+    method: "POST",
+    headers: {
+      apikey: apiKey,
+      Model: model,
+      "Try-Sync": "true",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ input }),
+    signal
+  });
+  if (!res.ok) {
+    throw await parseApiError(res, "API error");
+  }
+  return res.json();
+}
+var GenerationFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GenerationFailedError";
+  }
+};
+async function attemptPoll(fullUrl, apiKey, signal) {
+  let res;
+  try {
+    res = await fetch(fullUrl, { headers: { apikey: apiKey }, signal });
+  } catch (err) {
+    if (isAbortError(err)) throw new CancellationError();
+    return { outcome: "transient-failure" };
+  }
+  if (!res.ok) {
+    if (isAuthFailureStatus(res.status)) throw new AuthenticationError();
+    return { outcome: "transient-failure" };
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalSuccessStatus(data.status)) {
+    const uri = extractUri(data);
+    if (uri) return { outcome: "succeeded", uri: resolveUri(uri) };
+    return { outcome: "transient-failure" };
+  }
+  if (isTerminalFailureStatus(data.status)) {
+    throw new GenerationFailedError(data.error ?? "Generation failed during processing.");
+  }
+  return { outcome: "continue" };
+}
+async function pollForResult(pollUrl, apiKey, maxAttempts = POLL_DEFAULTS.maxAttempts, intervalMs = POLL_DEFAULTS.intervalMs, signal, onProgress) {
+  const fullUrl = isAbsoluteHttpUrl(pollUrl) ? pollUrl : buildPrunaApiUrl(pollUrl);
+  const controller = new AbortController();
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+  try {
+    for (let i = 0; i < maxAttempts; i++) {
+      if (signal?.aborted) throw new CancellationError();
+      const delay = calculateExponentialBackoff2({ attempt: i, baseIntervalMs: intervalMs });
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      if (signal?.aborted) throw new CancellationError();
+      onProgress?.("polling", i + 1);
+      const result = await attemptPoll(fullUrl, apiKey, controller.signal);
+      if (result.outcome === "succeeded" && result.uri) {
+        return result.uri;
+      }
+    }
+    throw new TimeoutError();
+  } finally {
+    signal?.removeEventListener("abort", onExternalAbort);
+    controller.abort();
+  }
+}
+
+// src/providers/pruna/client/core/math/comparison-hash.ts
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+      acc[key] = sortKeysDeep(record[key]);
+      return acc;
+    }, {});
+  }
+  return value;
+}
+function hashValue(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  try {
+    return JSON.stringify(sortKeysDeep(value));
+  } catch {
+    return String(value);
+  }
+}
+function compositeHash(...values) {
+  return values.map(hashValue).join("|");
+}
+
+// src/providers/pruna/client/core/math/cache-key-derivation.ts
+function deriveGenerationCacheKey(apiKey, input) {
+  return `${apiKey}:${compositeHash(input)}`;
+}
+
+// src/providers/pruna/client/core/validation/api-key-validator.ts
+function assertValidApiKey(apiKey) {
+  if (typeof apiKey !== "string") {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must be a string",
+      receivedValue: typeof apiKey
+    });
+  }
+  if (apiKey.length < MIN_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: "must not be empty",
+      receivedValue: apiKey
+    });
+  }
+  if (apiKey.length > MAX_API_KEY_LENGTH) {
+    throw new ValidationError2({
+      field: "apiKey",
+      reason: `exceeds maximum length of ${MAX_API_KEY_LENGTH}`,
+      receivedValue: apiKey.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/image-source-validator.ts
+function classifyImageSource(source) {
+  if (source.startsWith(HTTPS_PREFIX)) return "https-url";
+  if (source.startsWith(HTTP_PREFIX)) return "http-url";
+  if (source.includes(BASE64_MARKER) || /^[A-Za-z0-9+/=]+$/.test(source)) return "base64";
+  return "unknown";
+}
+function assertSecureImageSource(image, fieldName = "image") {
+  if (typeof image !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof image
+    });
+  }
+  const kind = classifyImageSource(image);
+  if (kind === "http-url") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "HTTP URLs are not supported; use HTTPS or a base64 data URI",
+      receivedValue: image
+    });
+  }
+  if (kind === "unknown") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be an HTTPS URL or a base64 data URI",
+      receivedValue: typeof image
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/aspect-ratio-validator.ts
+var SUPPORTED_ASPECT_RATIOS = [
+  "16:9",
+  "9:16",
+  "1:1",
+  "4:3",
+  "3:4",
+  "3:2",
+  "2:3"
+];
+function isSupportedAspectRatio(value) {
+  return typeof value === "string" && SUPPORTED_ASPECT_RATIOS.includes(value);
+}
+function assertValidAspectRatio(value, fieldName = "aspect_ratio") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedAspectRatio(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_ASPECT_RATIOS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/resolution-validator.ts
+var SUPPORTED_RESOLUTIONS = ["720p", "1080p"];
+function isSupportedResolution(value) {
+  return typeof value === "string" && SUPPORTED_RESOLUTIONS.includes(value);
+}
+function assertValidResolution(value, fieldName = "resolution") {
+  if (value === void 0 || value === null) return;
+  if (!isSupportedResolution(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be one of ${SUPPORTED_RESOLUTIONS.join(", ")}`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/duration-validator.ts
+var MIN_VIDEO_DURATION_SECONDS = 1;
+var MAX_VIDEO_DURATION_SECONDS = 30;
+function isValidDuration(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= MIN_VIDEO_DURATION_SECONDS && value <= MAX_VIDEO_DURATION_SECONDS && Number.isInteger(value);
+}
+function assertValidDuration(value, fieldName = "duration") {
+  if (value === void 0 || value === null) return;
+  if (!isValidDuration(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer between ${MIN_VIDEO_DURATION_SECONDS} and ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/prompt-validator.ts
+var MIN_PROMPT_LENGTH = 1;
+var MAX_PROMPT_LENGTH = 4e3;
+function assertValidPrompt(value, fieldName = "prompt") {
+  if (typeof value !== "string") {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must be a string",
+      receivedValue: typeof value
+    });
+  }
+  if (value.trim().length < MIN_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: "must not be empty or whitespace-only",
+      receivedValue: value
+    });
+  }
+  if (value.length > MAX_PROMPT_LENGTH) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `exceeds maximum length of ${MAX_PROMPT_LENGTH} characters`,
+      receivedValue: value.length
+    });
+  }
+}
+
+// src/providers/pruna/client/core/validation/seed-validator.ts
+var MIN_SEED = -2147483648;
+var MAX_SEED = 2147483647;
+function isValidSeed(value) {
+  return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= MIN_SEED && value <= MAX_SEED;
+}
+function assertValidSeed(value, fieldName = "seed") {
+  if (value === void 0 || value === null) return;
+  if (!isValidSeed(value)) {
+    throw new ValidationError2({
+      field: fieldName,
+      reason: `must be an integer in [${MIN_SEED}, ${MAX_SEED}]`,
+      receivedValue: value
+    });
+  }
+}
+
+// src/providers/pruna/client/core/protocol/input-type-guard.ts
+function isTextToImageInput(input) {
+  return input.model === "p-image";
+}
+function isImageToImageInput(input) {
+  return input.model === "p-image-edit";
+}
+function isImageToVideoInput(input) {
+  return input.model === "p-video";
+}
+
+// src/providers/pruna/client/core/utils/request-deduplicator.ts
+var RequestDeduplicator2 = class {
+  pendingRequests = /* @__PURE__ */ new Map();
+  ttl;
+  constructor(ttl = DEFAULT_DEDUPLICATOR_TTL_MS) {
+    this.ttl = ttl;
+  }
+  execute(key, fn) {
+    const existing = this.pendingRequests.get(key);
+    if (existing) {
+      if (Date.now() - existing.timestamp < this.ttl) {
+        return existing.promise;
+      }
+      this.pendingRequests.delete(key);
+    }
+    const promise = fn().finally(() => {
+      setTimeout(() => {
+        this.pendingRequests.delete(key);
+      }, DEDUPLICATOR_CLEANUP_GRACE_MS);
+    });
+    this.pendingRequests.set(key, { promise, timestamp: Date.now() });
+    return promise;
+  }
+  clear() {
+    this.pendingRequests.clear();
+  }
+  size() {
+    this.purgeExpired();
+    return this.pendingRequests.size;
+  }
+  purgeExpired() {
+    const now = Date.now();
+    for (const [key, value] of this.pendingRequests) {
+      if (now - value.timestamp >= this.ttl) {
+        this.pendingRequests.delete(key);
+      }
+    }
+  }
+};
+var globalDeduplicator = new RequestDeduplicator2();
+
+// src/providers/pruna/client/generation/builders/text-to-image.builder.ts
+var TextToImageInputBuilder = class {
+  model = "p-image";
+  build(input, _context) {
+    const payload = {
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-image.builder.ts
+var ImageToImageInputBuilder = class {
+  model = "p-image-edit";
+  build(input, _context) {
+    const payload = {
+      images: [stripBase64Prefix(input.image)],
+      prompt: input.prompt,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO
+    };
+    if (input.seed !== void 0) {
+      payload.seed = input.seed;
+    }
+    return Promise.resolve(payload);
+  }
+};
+
+// src/providers/pruna/client/generation/builders/image-to-video.builder.ts
+var ImageToVideoInputBuilder = class {
+  model = "p-video";
+  async build(input, context) {
+    if (context.signal?.aborted) {
+      throw new CancellationError();
+    }
+    const fileUrl = await uploadImage(
+      input.image,
+      context.apiKey,
+      context.onProgress
+    );
+    return {
+      image: fileUrl,
+      prompt: input.prompt,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      fps: P_VIDEO_DEFAULTS.fps,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft,
+      aspect_ratio: input.aspect_ratio ?? DEFAULT_ASPECT_RATIO,
+      prompt_upsampling: P_VIDEO_DEFAULTS.promptUpsampling
     };
-    return;
   }
-  const pollUrl = prediction.status_url || prediction.generation_url;
+};
+
+// src/providers/pruna/client/generation/builders/model-input-builder.ts
+var ModelInputBuilderRegistry = class {
+  builders = /* @__PURE__ */ new Map();
+  register(builder) {
+    this.builders.set(builder.model, builder);
+    return this;
+  }
+  resolve(model) {
+    const builder = this.builders.get(model);
+    if (!builder) {
+      throw new Error(`No input builder registered for model: ${model}`);
+    }
+    return builder;
+  }
+};
+
+// src/providers/pruna/client/generation/builders/builder-factory.ts
+function createDefaultBuilderRegistry() {
+  return new ModelInputBuilderRegistry().register(new TextToImageInputBuilder()).register(new ImageToImageInputBuilder()).register(new ImageToVideoInputBuilder());
+}
+
+// src/providers/pruna/client/generation/services/generation.service.ts
+var builderRegistry = createDefaultBuilderRegistry();
+function validateGenerateInput(input) {
+  assertValidPrompt(input.prompt, `${input.model}.prompt`);
+  assertValidAspectRatio(input.aspect_ratio, `${input.model}.aspect_ratio`);
+  if (isTextToImageInput(input)) {
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToImageInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidSeed(input.seed, `${input.model}.seed`);
+  } else if (isImageToVideoInput(input)) {
+    assertSecureImageSource(input.image, `${input.model}.image`);
+    assertValidDuration(input.duration, `${input.model}.duration`);
+    assertValidResolution(input.resolution, `${input.model}.resolution`);
+  }
+}
+async function generate(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  validateGenerateInput(input);
+  const { signal, onProgress, useCache = true } = options;
+  if (useCache) {
+    const cacheKey = deriveGenerationCacheKey(apiKey, input);
+    return globalDeduplicator.execute(
+      cacheKey,
+      () => generateInternal(apiKey, input, { signal, onProgress })
+    );
+  }
+  return generateInternal(apiKey, input, { signal, onProgress });
+}
+async function generateInternal(apiKey, input, options) {
+  const { signal, onProgress } = options;
+  const builder = builderRegistry.resolve(input.model);
+  const modelInput = await builder.build(input, { apiKey, signal, onProgress });
+  const response = await submitPrediction(input.model, modelInput, apiKey, signal, onProgress);
+  const syncUri = extractUri(response);
+  if (syncUri) {
+    return { url: resolveUri(syncUri), model: input.model };
+  }
+  const pollUrl = response.get_url ?? response.status_url;
   if (!pollUrl) {
-    throw new Error("Pruna prediction response missing polling URL");
+    throw new Error("Pruna API returned no result and no polling URL.");
   }
-  const resultUrl = await prunaCore.pollForResult(pollUrl, apiKey, 60, 2e3, signal, onProgress);
-  yield { stage: "polling", result: { url: resultUrl, model: modelId } };
+  const url = await pollForResult(
+    pollUrl,
+    apiKey,
+    POLL_DEFAULTS.maxAttempts,
+    POLL_DEFAULTS.intervalMs,
+    signal,
+    onProgress
+  );
+  return { url, model: input.model };
+}
+async function generateImageThenVideo(apiKey, input, options = {}) {
+  assertValidApiKey(apiKey);
+  assertValidPrompt(input.prompt, "text-to-video.prompt");
+  assertValidAspectRatio(input.aspect_ratio, "text-to-video.aspect_ratio");
+  assertValidDuration(input.duration, "text-to-video.duration");
+  assertValidResolution(input.resolution, "text-to-video.resolution");
+  const { signal, onProgress } = options;
+  const aspectRatio = input.aspect_ratio ?? DEFAULT_ASPECT_RATIO;
+  onProgress?.("predicting", 1);
+  const imageResult = await generate(
+    apiKey,
+    { model: "p-image", prompt: input.prompt, aspect_ratio: aspectRatio },
+    { signal }
+  );
+  onProgress?.("predicting", 2);
+  return generate(
+    apiKey,
+    {
+      model: "p-video",
+      prompt: input.prompt,
+      image: imageResult.url,
+      duration: input.duration ?? P_VIDEO_DEFAULTS.duration,
+      resolution: input.resolution ?? P_VIDEO_DEFAULTS.resolution,
+      aspect_ratio: aspectRatio,
+      draft: input.draft ?? P_VIDEO_DEFAULTS.draft
+    },
+    { signal, onProgress }
+  );
+}
+
+// src/providers/pruna/pruna-generate.ts
+async function* generateWithPruna(request, apiKey, signal, onProgress) {
+  const stages = [];
+  let notify = null;
+  let done = false;
+  const wake = () => {
+    const fn = notify;
+    if (fn) {
+      notify = null;
+      fn();
+    }
+  };
+  const handleProgress = (stage) => {
+    stages.push({ stage });
+    onProgress?.(stage);
+    wake();
+  };
+  const promise = (async () => {
+    try {
+      const model = request.model ?? (request.image ? "p-image-edit" : "p-image");
+      if (model === "p-video" && !request.image && request.prompt) {
+        const videoRes = await generateImageThenVideo(
+          apiKey,
+          {
+            prompt: request.prompt,
+            duration: request.duration ?? 5,
+            aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "16:9"
+          },
+          { signal, onProgress: handleProgress }
+        );
+        stages.push({
+          stage: "polling",
+          result: { url: videoRes.url, model: "p-video" }
+        });
+        return;
+      }
+      const input = {
+        model,
+        prompt: request.prompt ?? "",
+        aspect_ratio: request.aspectRatio ?? request.aspect_ratio ?? "1:1",
+        ...request.image ? { image: request.image } : {},
+        ...request.duration ? { duration: request.duration } : {},
+        ...request.resolution ? { resolution: request.resolution } : {},
+        ...request.seed !== void 0 ? { seed: request.seed } : {}
+      };
+      const res = await generate(apiKey, input, {
+        signal,
+        onProgress: handleProgress
+      });
+      stages.push({
+        stage: "polling",
+        result: { url: res.url, model: res.model }
+      });
+    } catch (err) {
+      stages.push({
+        stage: "processing",
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    } finally {
+      done = true;
+      wake();
+    }
+  })();
+  while (!done || stages.length > 0) {
+    if (stages.length === 0 && !done) {
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = null;
+    }
+    while (stages.length > 0) {
+      const nextStage = stages.shift();
+      if (!nextStage) continue;
+      yield nextStage;
+      if (nextStage.error) {
+        throw nextStage.error;
+      }
+    }
+  }
+  await promise;
 }
 
 // src/providers/pruna/pruna.provider.ts
@@ -4970,7 +5745,7 @@ function useText(options = {}, deps) {
     (request, onChunk) => engine instanceof ProviderFactory ? engine.chatStream(request, { onChunk }) : engine.stream(request, { onChunk }),
     [engine]
   );
-  const generate = react.useCallback(
+  const generate2 = react.useCallback(
     (prompt, config) => runWithState(async (signal) => {
       const response = await run(buildRequest(prompt, config, signal));
       setResult(response.text);
@@ -5026,7 +5801,7 @@ function useText(options = {}, deps) {
     isLoading,
     error,
     result,
-    generate,
+    generate: generate2,
     generateJSON,
     stream,
     cancel,
@@ -5412,7 +6187,7 @@ function useGroq(options = {}, deps) {
     },
     [getOrCreateAbortController]
   );
-  const generate = react.useCallback(
+  const generate2 = react.useCallback(
     (prompt, config) => runWithState(async () => {
       const response = await textGeneration.generateCompletion(prompt, {
         model: stableConfig.model,
@@ -5484,7 +6259,7 @@ function useGroq(options = {}, deps) {
     isLoading,
     error,
     result,
-    generate,
+    generate: generate2,
     generateJSON,
     stream,
     cancel,
@@ -5492,15 +6267,133 @@ function useGroq(options = {}, deps) {
     clearError
   };
 }
+function isAbortError2(err) {
+  if (!(err instanceof Error)) return false;
+  if (err.name === "AbortError") return true;
+  if (err instanceof DOMException && err.code === DOMException.ABORT_ERR) return true;
+  return isCancellationError(err);
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function useAsyncAction(executor, options = {}) {
+  const [result, setResult] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const abortRef = react.useRef(null);
+  const executorRef = react.useRef(executor);
+  const optionsRef = react.useRef(options);
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    executorRef.current = executor;
+    optionsRef.current = options;
+  });
+  react.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      abortRef.current?.abort();
+      abortRef.current = null;
+    };
+  }, []);
+  const run = react.useCallback(
+    async (input) => {
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+      try {
+        const value = await executorRef.current(input, controller.signal);
+        if (!mountedRef.current) return null;
+        setResult(value);
+        optionsRef.current.onSuccess?.(value);
+        return value;
+      } catch (err) {
+        if (isAbortError2(err)) {
+          if (mountedRef.current) {
+            optionsRef.current.onCancelled?.();
+          }
+          return null;
+        }
+        if (!mountedRef.current) return null;
+        const normalized = toError(err);
+        setError(normalized);
+        optionsRef.current.onError?.(normalized);
+        return null;
+      } finally {
+        if (mountedRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    []
+  );
+  const cancel = react.useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+  }, []);
+  const reset = react.useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    setResult(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return react.useMemo(
+    () => ({ result, isLoading, error, run, cancel, reset }),
+    [result, isLoading, error, run, cancel, reset]
+  );
+}
+
+// src/hooks/usePrunaGeneration.ts
+function usePrunaGeneration(apiKey, options = {}) {
+  return useAsyncAction(
+    (input, signal) => generate(apiKey, input, { signal, onProgress: options.onProgress }),
+    options
+  );
+}
+
+// src/hooks/usePrunaProxy.ts
+function createProxyExecutor(proxyUrl, executorOptions) {
+  return async (input, signal) => {
+    executorOptions.onProgress?.("uploading");
+    const res = await fetch(proxyUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(input),
+      signal
+    });
+    if (!res.ok) {
+      const payload = await res.json().catch(() => ({ message: res.statusText }));
+      throw new Error(payload.message ?? `Proxy error: ${res.status}`);
+    }
+    return res.json();
+  };
+}
+function usePrunaProxy(options) {
+  const { proxyUrl, onProgress, onSuccess, onError } = options;
+  return useAsyncAction(
+    createProxyExecutor(proxyUrl, { onProgress }),
+    { onSuccess, onError }
+  );
+}
 
+exports.CancellationError = CancellationError;
+exports.GENERATION_COSTS = CREDIT_COSTS;
+exports.calculateCreditCost = calculateContentCreditCost;
 exports.useAIContent = useAIContent;
 exports.useAIGeneration = useAIGeneration;
+exports.useAsyncAction = useAsyncAction;
 exports.useBlogGenerator = useBlogGenerator;
 exports.useCacheStats = useCacheStats;
 exports.useChat = useChat;
 exports.useContentWizard = useContentWizard;
 exports.useGroq = useGroq;
 exports.useImageWizard = useImageWizard;
+exports.usePrunaGeneration = usePrunaGeneration;
+exports.usePrunaProxy = usePrunaProxy;
 exports.useSocialContentGenerator = useSocialContentGenerator;
 exports.useText = useText;
 exports.useVideoWizard = useVideoWizard;