@umituz/react-native-ai-pruna-provider 1.0.0

package/src/infrastructure/services/pruna-provider-subscription.ts

@@ -0,0 +1,262 @@
+/**
+ * Pruna Provider Subscription Handlers
+ * Handles subscribe and run methods with retry, timeout, and cancellation
+ *
+ * Retry strategy for subscribe:
+ * - Retries on: network errors, timeouts, server errors (5xx)
+ * - NO retry on: auth, validation, quota, user cancellation
+ * - Max 1 retry (2 total attempts) with 3s delay
+ */
+
+import type { PrunaModelId } from "../../domain/entities/pruna.types";
+import type { SubscribeOptions, RunOptions } from "../../domain/types";
+import { DEFAULT_PRUNA_CONFIG } from "./pruna-provider.constants";
+import { submitPrediction, extractUri, resolveUri, pollForResult } from "./pruna-api-client";
+import { buildModelInput } from "./pruna-input-builder";
+import { generationLogCollector } from "../utils/log-collector";
+
+const TAG = 'pruna-subscription';
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function isRetryableError(error: unknown): boolean {
+  if (error instanceof Error && error.message.includes("cancelled by user")) return false;
+
+  // Check HTTP status code if attached
+  const statusCode = (error as Error & { statusCode?: number }).statusCode;
+  if (statusCode !== undefined) {
+    if (statusCode >= 500 && statusCode <= 504) return true;
+    return false; // 4xx are not retryable
+  }
+
+  // Generic Error — check message patterns
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("network")) return true;
+    if (msg.includes("timeout") || msg.includes("timed out")) return true;
+    if (msg.includes("fetch")) return true;
+    if (msg.includes("econnrefused") || msg.includes("enotfound")) return true;
+  }
+
+  return false;
+}
+
+// ─── Single Subscribe Attempt ───────────────────────────────────────────────
+
+async function singleSubscribeAttempt<T = unknown>(
+  model: PrunaModelId,
+  input: Record<string, unknown>,
+  apiKey: string,
+  sessionId: string,
+  options: SubscribeOptions<T> | undefined,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<{ result: T; requestId: string }> {
+  if (signal?.aborted) {
+    throw new Error("Request cancelled by user");
+  }
+
+  // Build model-specific input
+  const modelInput = await buildModelInput(model, input, apiKey, sessionId);
+
+  // Race between prediction and timeout
+  const predictionPromise = (async (): Promise<string> => {
+    // Notify progress: IN_PROGRESS
+    options?.onProgress?.({ progress: -1, status: "IN_PROGRESS" });
+
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+    let uri = extractUri(response);
+
+    // If no immediate result, poll for async result
+    if (!uri && (response.get_url || response.status_url)) {
+      const pollUrl = (response.get_url || response.status_url)!;
+
+      generationLogCollector.log(sessionId, TAG, 'No immediate result — starting async polling...');
+      options?.onQueueUpdate?.({
+        status: "IN_QUEUE",
+        requestId: pollUrl,
+      });
+
+      uri = await pollForResult(
+        pollUrl,
+        apiKey,
+        sessionId,
+        DEFAULT_PRUNA_CONFIG.maxPollAttempts,
+        DEFAULT_PRUNA_CONFIG.pollIntervalMs,
+        signal,
+      );
+    }
+
+    if (!uri) {
+      throw new Error("Empty result from Pruna AI. Please try again.");
+    }
+
+    return resolveUri(uri);
+  })();
+
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`Pruna subscription timeout after ${timeoutMs}ms for model ${model}`));
+    }, timeoutMs);
+
+    // Cleanup timeout if prediction finishes first
+    predictionPromise.finally(() => clearTimeout(timeoutId));
+  });
+
+  const promises: Promise<unknown>[] = [predictionPromise, timeoutPromise];
+
+  if (signal) {
+    const abortPromise = new Promise<never>((_, reject) => {
+      const handler = () => reject(new Error("Request cancelled by user"));
+      signal.addEventListener("abort", handler, { once: true });
+      predictionPromise.finally(() => signal.removeEventListener("abort", handler));
+    });
+    promises.push(abortPromise);
+
+    if (signal.aborted) {
+      throw new Error("Request cancelled by user");
+    }
+  }
+
+  const resultUrl = await Promise.race(promises) as string;
+  const requestId = `pruna_${model}_${Date.now()}`;
+
+  // Notify progress: COMPLETED
+  options?.onProgress?.({ progress: 100, status: "COMPLETED" });
+  options?.onQueueUpdate?.({
+    status: "COMPLETED",
+    requestId,
+  });
+
+  // Wrap result in expected format
+  // Pruna returns a URL string — wrap in a structure similar to FAL's response
+  const result = { url: resultUrl } as T;
+
+  return { result, requestId };
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Handle Pruna subscription with timeout, cancellation, and retry.
+ */
+export async function handlePrunaSubscription<T = unknown>(
+  model: PrunaModelId,
+  input: Record<string, unknown>,
+  apiKey: string,
+  sessionId: string,
+  options?: SubscribeOptions<T>,
+  signal?: AbortSignal,
+): Promise<{ result: T; requestId: string }> {
+  const overallStart = Date.now();
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_PRUNA_CONFIG.defaultTimeoutMs;
+  const maxRetries = DEFAULT_PRUNA_CONFIG.subscribeMaxRetries;
+  const retryDelay = DEFAULT_PRUNA_CONFIG.subscribeRetryDelayMs;
+
+  generationLogCollector.log(sessionId, TAG, `Starting subscription for model: ${model}`, {
+    timeoutMs,
+    maxRetries,
+    inputKeys: Object.keys(input),
+  });
+
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 3600000) {
+    throw new Error(
+      `Invalid timeout: ${timeoutMs}ms. Must be a positive integer between 1 and 3600000ms (1 hour)`
+    );
+  }
+
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0) {
+      generationLogCollector.warn(sessionId, TAG, `Retry ${attempt}/${maxRetries} after ${retryDelay}ms delay...`);
+      await new Promise(resolve => setTimeout(resolve, retryDelay));
+
+      if (signal?.aborted) {
+        throw new Error("Request cancelled by user");
+      }
+    }
+
+    try {
+      generationLogCollector.log(sessionId, TAG, `Attempt ${attempt + 1}/${maxRetries + 1} starting...`);
+
+      const result = await singleSubscribeAttempt<T>(
+        model, input, apiKey, sessionId, options, signal, timeoutMs,
+      );
+
+      const totalElapsed = Date.now() - overallStart;
+      const suffix = attempt > 0 ? ` (succeeded on retry ${attempt})` : '';
+      generationLogCollector.log(sessionId, TAG, `Subscription completed in ${totalElapsed}ms${suffix}. Request ID: ${result.requestId}`);
+
+      return result;
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (attempt < maxRetries && isRetryableError(error)) {
+        generationLogCollector.warn(sessionId, TAG, `Attempt ${attempt + 1} failed (retryable): ${message}`);
+        continue;
+      }
+
+      const totalElapsed = Date.now() - overallStart;
+      const retryInfo = attempt > 0 ? ` after ${attempt + 1} attempts` : '';
+      generationLogCollector.error(sessionId, TAG, `Subscription FAILED in ${totalElapsed}ms${retryInfo}: ${message}`);
+      throw error instanceof Error ? error : new Error(message);
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Handle Pruna run (no retry — direct execution)
+ */
+export async function handlePrunaRun<T = unknown>(
+  model: PrunaModelId,
+  input: Record<string, unknown>,
+  apiKey: string,
+  sessionId: string,
+  options?: RunOptions,
+): Promise<T> {
+  const runTag = 'pruna-run';
+  const startTime = Date.now();
+  generationLogCollector.log(sessionId, runTag, `Starting run for model: ${model}`);
+
+  options?.onProgress?.({ progress: -1, status: "IN_PROGRESS" as const });
+
+  try {
+    const modelInput = await buildModelInput(model, input, apiKey, sessionId);
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+
+    let uri = extractUri(response);
+
+    // Poll if needed
+    if (!uri && (response.get_url || response.status_url)) {
+      const pollUrl = (response.get_url || response.status_url)!;
+      uri = await pollForResult(
+        pollUrl,
+        apiKey,
+        sessionId,
+        DEFAULT_PRUNA_CONFIG.maxPollAttempts,
+        DEFAULT_PRUNA_CONFIG.pollIntervalMs,
+        options?.signal,
+      );
+    }
+
+    if (!uri) {
+      throw new Error("Empty result from Pruna AI. Please try again.");
+    }
+
+    const resultUrl = resolveUri(uri);
+    const elapsed = Date.now() - startTime;
+    generationLogCollector.log(sessionId, runTag, `Run completed in ${elapsed}ms`);
+
+    options?.onProgress?.({ progress: 100, status: "COMPLETED" as const });
+    return { url: resultUrl } as T;
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    generationLogCollector.error(sessionId, runTag, `Run FAILED after ${elapsed}ms for model ${model}: ${message}`);
+    throw error instanceof Error ? error : new Error(message);
+  }
+}

package/src/infrastructure/services/pruna-provider.constants.ts

@@ -0,0 +1,83 @@
+/**
+ * Pruna Provider Constants
+ * Configuration and capability definitions for Pruna AI provider
+ *
+ * Retry Strategy:
+ * ┌──────────────────────────────────────────────────┐
+ * │ FILE UPLOAD (Pruna /v1/files)                    │
+ * │ Timeout: 30s / attempt                           │
+ * │ Retries: 2 (3 total attempts)                    │
+ * │ Backoff: 1s → 2s (exponential)                   │
+ * │ Retries on: network, timeout                     │
+ * ├──────────────────────────────────────────────────┤
+ * │ PREDICTION (Pruna /v1/predictions)               │
+ * │ Timeout: caller-defined (120s image / 300s video)│
+ * │ Retries: 1 (2 total attempts)                    │
+ * │ Backoff: 3s (fixed — server needs recovery time) │
+ * │ Retries on: network, timeout, server (5xx)       │
+ * │ NO retry: auth, validation, quota, cancel        │
+ * ├──────────────────────────────────────────────────┤
+ * │ POLLING (async result polling)                   │
+ * │ Interval: 3s                                     │
+ * │ Max attempts: 120 (~6 min)                       │
+ * │ Retries on: non-ok responses (skip & continue)   │
+ * └──────────────────────────────────────────────────┘
+ */
+
+import type { ProviderCapabilities } from "../../domain/types";
+
+export const PRUNA_BASE_URL = 'https://api.pruna.ai';
+export const PRUNA_PREDICTIONS_URL = `${PRUNA_BASE_URL}/v1/predictions`;
+export const PRUNA_FILES_URL = `${PRUNA_BASE_URL}/v1/files`;
+
+export const DEFAULT_PRUNA_CONFIG = {
+  /** Prediction retry — retries the entire prediction call on transient failures */
+  maxRetries: 1,
+  baseDelay: 1000,
+  maxDelay: 10000,
+
+  /** Subscribe defaults */
+  defaultTimeoutMs: 360_000,
+
+  /** Polling configuration */
+  pollIntervalMs: 3_000,
+  maxPollAttempts: 120,
+
+  /** Subscribe retry */
+  subscribeMaxRetries: 1,
+  subscribeRetryDelayMs: 3_000,
+} as const;
+
+export const UPLOAD_CONFIG = {
+  /** Timeout per individual upload attempt */
+  timeoutMs: 30_000,
+  /** Max retries (2 = 3 total attempts) */
+  maxRetries: 2,
+  /** Initial backoff delay (doubles each retry) */
+  baseDelayMs: 1_000,
+} as const;
+
+export const PRUNA_CAPABILITIES: ProviderCapabilities = {
+  imageFeatures: [] as const,
+  videoFeatures: [] as const,
+  textToImage: true,
+  textToVideo: false,
+  imageToVideo: true,
+  textToVoice: false,
+  textToText: false,
+};
+
+/** Valid Pruna model IDs */
+export const VALID_PRUNA_MODELS = ['p-video', 'p-image', 'p-image-edit'] as const;
+
+/** Default values for p-video model */
+export const P_VIDEO_DEFAULTS = {
+  duration: 5,
+  resolution: '720p' as const,
+  fps: 24,
+  draft: false,
+  promptUpsampling: true,
+} as const;
+
+/** Default aspect ratio for all models */
+export const DEFAULT_ASPECT_RATIO = '16:9' as const;

package/src/infrastructure/services/pruna-provider.ts

@@ -0,0 +1,211 @@
+/**
+ * Pruna Provider - Implements IAIProvider interface
+ * Each subscribe/run call creates an isolated log session via sessionId.
+ *
+ * Pruna AI models:
+ *   p-image:      text-to-image
+ *   p-image-edit: image-to-image
+ *   p-video:      image-to-video
+ */
+
+import type {
+  IAIProvider, AIProviderConfig, JobSubmission, JobStatus, SubscribeOptions,
+  RunOptions, ProviderCapabilities, ImageFeatureType, VideoFeatureType,
+  ImageFeatureInputData, VideoFeatureInputData,
+} from "../../domain/types";
+import type { PrunaModelId } from "../../domain/entities/pruna.types";
+import { DEFAULT_PRUNA_CONFIG, PRUNA_CAPABILITIES, VALID_PRUNA_MODELS } from "./pruna-provider.constants";
+import { handlePrunaSubscription, handlePrunaRun } from "./pruna-provider-subscription";
+import * as queueOps from "./pruna-queue-operations";
+import { generationLogCollector } from "../utils/log-collector";
+import type { LogEntry } from "../utils/log-collector";
+import {
+  createRequestKey, getExistingRequest, storeRequest,
+  removeRequest, cancelRequest, cancelAllRequests, hasActiveRequests,
+} from "./request-store";
+
+export class PrunaProvider implements IAIProvider {
+  readonly providerId = "pruna";
+  readonly providerName = "Pruna AI";
+
+  private apiKey: string | null = null;
+  private initialized = false;
+  private lastRequestKey: string | null = null;
+
+  initialize(config: AIProviderConfig): void {
+    this.apiKey = config.apiKey;
+    this.initialized = true;
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  getCapabilities(): ProviderCapabilities {
+    return PRUNA_CAPABILITIES;
+  }
+
+  isFeatureSupported(_feature: ImageFeatureType | VideoFeatureType): boolean {
+    return false;
+  }
+
+  getImageFeatureModel(_feature: ImageFeatureType): string {
+    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
+  }
+
+  buildImageFeatureInput(_feature: ImageFeatureType, _data: ImageFeatureInputData): Record<string, unknown> {
+    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
+  }
+
+  getVideoFeatureModel(_feature: VideoFeatureType): string {
+    throw new Error("Feature-specific models not supported. Use main app's feature implementations.");
+  }
+
+  buildVideoFeatureInput(_feature: VideoFeatureType, _data: VideoFeatureInputData): Record<string, unknown> {
+    throw new Error("Feature-specific input building not supported. Use main app's feature implementations.");
+  }
+
+  private validateInit(): string {
+    if (!this.apiKey || !this.initialized) {
+      throw new Error("Pruna provider not initialized. Call initialize() first.");
+    }
+    return this.apiKey;
+  }
+
+  private validateModel(model: string): PrunaModelId {
+    if (!VALID_PRUNA_MODELS.includes(model as PrunaModelId)) {
+      throw new Error(
+        `Invalid Pruna model: "${model}". Valid models: ${VALID_PRUNA_MODELS.join(', ')}`
+      );
+    }
+    return model as PrunaModelId;
+  }
+
+  async submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+    const apiKey = this.validateInit();
+    const prunaModel = this.validateModel(model);
+    const sessionId = generationLogCollector.startSession();
+    generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() for model: ${model}`);
+    return queueOps.submitJob(prunaModel, input, apiKey, sessionId);
+  }
+
+  async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
+    const apiKey = this.validateInit();
+    const prunaModel = this.validateModel(model);
+    return queueOps.getJobStatus(prunaModel, requestId, apiKey);
+  }
+
+  async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
+    const apiKey = this.validateInit();
+    const prunaModel = this.validateModel(model);
+    return queueOps.getJobResult<T>(prunaModel, requestId, apiKey);
+  }
+
+  async subscribe<T = unknown>(
+    model: string,
+    input: Record<string, unknown>,
+    options?: SubscribeOptions<T>,
+  ): Promise<T> {
+    const TAG = 'pruna-provider';
+    const totalStart = Date.now();
+    const apiKey = this.validateInit();
+    const prunaModel = this.validateModel(model);
+
+    const sessionId = generationLogCollector.startSession();
+    generationLogCollector.log(sessionId, TAG, `subscribe() called for model: ${model}`);
+
+    const key = createRequestKey(model, input);
+
+    const existing = getExistingRequest<T>(key);
+    if (existing) {
+      generationLogCollector.log(sessionId, TAG, `Dedup hit — returning existing request`);
+      return existing.promise;
+    }
+
+    const abortController = new AbortController();
+
+    let resolvePromise!: (value: T) => void;
+    let rejectPromise!: (error: unknown) => void;
+    const promise = new Promise<T>((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+
+    this.lastRequestKey = key;
+    storeRequest(key, { promise, abortController, createdAt: Date.now() });
+
+    handlePrunaSubscription<T>(prunaModel, input, apiKey, sessionId, options, abortController.signal)
+      .then((res) => {
+        const totalElapsed = Date.now() - totalStart;
+        generationLogCollector.log(sessionId, TAG, `Generation SUCCESS in ${totalElapsed}ms`);
+        const result = res.result;
+        if (result && typeof result === 'object') {
+          Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+        }
+        resolvePromise(result);
+      })
+      .catch((error) => {
+        const totalElapsed = Date.now() - totalStart;
+        generationLogCollector.error(sessionId, TAG, `Generation FAILED in ${totalElapsed}ms: ${error instanceof Error ? error.message : String(error)}`);
+        rejectPromise(error);
+      })
+      .finally(() => {
+        try {
+          removeRequest(key);
+        } catch (cleanupError) {
+          generationLogCollector.warn(sessionId, TAG, `Error removing request: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+        }
+      });
+
+    return promise;
+  }
+
+  async run<T = unknown>(model: string, input: Record<string, unknown>, options?: RunOptions): Promise<T> {
+    const apiKey = this.validateInit();
+    const prunaModel = this.validateModel(model);
+
+    const sessionId = generationLogCollector.startSession();
+    generationLogCollector.log(sessionId, 'pruna-provider', `run() for model: ${model}`);
+
+    const signal = options?.signal;
+    if (signal?.aborted) {
+      throw new Error("Request cancelled by user");
+    }
+
+    const result = await handlePrunaRun<T>(prunaModel, input, apiKey, sessionId, options);
+    if (result && typeof result === 'object') {
+      Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+    }
+    return result;
+  }
+
+  reset(): void {
+    cancelAllRequests();
+    this.lastRequestKey = null;
+    this.apiKey = null;
+    this.initialized = false;
+  }
+
+  cancelCurrentRequest(): void {
+    if (this.lastRequestKey) {
+      cancelRequest(this.lastRequestKey);
+      this.lastRequestKey = null;
+    }
+  }
+
+  hasRunningRequest(): boolean {
+    return hasActiveRequests();
+  }
+
+  getSessionLogs(sessionId?: string): LogEntry[] {
+    if (!sessionId) return [];
+    return generationLogCollector.getEntries(sessionId);
+  }
+
+  endLogSession(sessionId?: string): LogEntry[] {
+    if (!sessionId) return [];
+    return generationLogCollector.endSession(sessionId);
+  }
+}
+
+export const prunaProvider = new PrunaProvider();

package/src/infrastructure/services/pruna-queue-operations.ts

@@ -0,0 +1,131 @@
+/**
+ * Pruna Queue Operations - Direct Pruna API queue interactions
+ * No silent fallbacks - throws descriptive errors on unexpected responses
+ */
+
+import type { PrunaModelId } from "../../domain/entities/pruna.types";
+import type { JobSubmission, JobStatus } from "../../domain/types";
+import { submitPrediction, extractUri } from "./pruna-api-client";
+import { buildModelInput } from "./pruna-input-builder";
+import { generationLogCollector } from "../utils/log-collector";
+
+const TAG = 'pruna-queue';
+
+/**
+ * Submit job to Pruna queue
+ * @throws {Error} if prediction fails or response is missing required data
+ */
+export async function submitJob(
+  model: PrunaModelId,
+  input: Record<string, unknown>,
+  apiKey: string,
+  sessionId: string,
+): Promise<JobSubmission> {
+  generationLogCollector.log(sessionId, TAG, `Submitting job for model: ${model}`);
+
+  const modelInput = await buildModelInput(model, input, apiKey, sessionId);
+  const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+
+  // If we got an immediate result, return it with a generated request ID
+  const uri = extractUri(response);
+  if (uri) {
+    const requestId = `pruna_immediate_${Date.now()}`;
+    return {
+      requestId,
+      statusUrl: undefined,
+      responseUrl: uri,
+    };
+  }
+
+  // Async result — return polling URL
+  const pollUrl = response.get_url || response.status_url;
+  if (!pollUrl) {
+    throw new Error(
+      `Pruna prediction response missing both result and polling URL for model ${model}.`
+    );
+  }
+
+  const requestId = `pruna_async_${Date.now()}`;
+  return {
+    requestId,
+    statusUrl: pollUrl,
+    responseUrl: undefined,
+  };
+}
+
+/**
+ * Get job status from Pruna polling URL
+ * @throws {Error} if polling URL is invalid or response is unexpected
+ */
+export async function getJobStatus(
+  _model: PrunaModelId,
+  statusUrl: string,
+  apiKey: string,
+): Promise<JobStatus> {
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+
+  const response = await fetch(fullUrl, {
+    headers: { 'apikey': apiKey },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Pruna status check failed: HTTP ${response.status}`);
+  }
+
+  const data = await response.json();
+  const typedData = data as { status?: string; error?: string };
+
+  if (typedData.status === 'succeeded' || typedData.status === 'completed') {
+    return {
+      status: "COMPLETED",
+      requestId: statusUrl,
+    };
+  }
+
+  if (typedData.status === 'failed') {
+    return {
+      status: "FAILED",
+      requestId: statusUrl,
+    };
+  }
+
+  return {
+    status: "IN_PROGRESS",
+    requestId: statusUrl,
+  };
+}
+
+/**
+ * Get job result from Pruna polling URL
+ * @throws {Error} if result is not ready or extraction fails
+ */
+export async function getJobResult<T = unknown>(
+  _model: PrunaModelId,
+  statusUrl: string,
+  apiKey: string,
+): Promise<T> {
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+
+  const response = await fetch(fullUrl, {
+    headers: { 'apikey': apiKey },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Pruna result fetch failed: HTTP ${response.status}`);
+  }
+
+  const data = await response.json();
+  const typedData = data as { status?: string; error?: string };
+
+  if (typedData.status === 'failed') {
+    throw new Error(typedData.error || "Generation failed.");
+  }
+
+  const uri = extractUri(data as Record<string, unknown>);
+  if (!uri) {
+    throw new Error("Result not ready or extraction failed.");
+  }
+
+  const resolvedUri = uri.startsWith('/') ? `https://api.pruna.ai${uri}` : uri;
+  return { url: resolvedUri } as T;
+}