@umituz/react-native-ai-pruna-provider 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-pruna-provider",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Pruna AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/entities/error.types.ts

@@ -19,12 +19,6 @@ export enum PrunaErrorType {
   UNKNOWN = "unknown",
 }
 
-export interface PrunaErrorCategory {
-  readonly type: PrunaErrorType;
-  readonly messageKey: string;
-  readonly retryable: boolean;
-}
-
 export interface PrunaErrorInfo {
   readonly type: PrunaErrorType;
   readonly messageKey: string;
@@ -35,18 +29,3 @@ export interface PrunaErrorInfo {
   readonly statusCode?: number;
 }
 
-export interface PrunaErrorMessages {
-  network?: string;
-  timeout?: string;
-  api_error?: string;
-  validation?: string;
-  content_policy?: string;
-  rate_limit?: string;
-  authentication?: string;
-  quota_exceeded?: string;
-  model_not_found?: string;
-  file_upload?: string;
-  polling_timeout?: string;
-  invalid_image?: string;
-  unknown?: string;
-}

package/src/exports/domain.ts

@@ -23,9 +23,7 @@ export type {
 
 export { PrunaErrorType } from "../domain/entities/error.types";
 export type {
-  PrunaErrorCategory,
   PrunaErrorInfo,
-  PrunaErrorMessages,
 } from "../domain/entities/error.types";
 
 export type {

package/src/infrastructure/services/pruna-api-client.ts

@@ -12,7 +12,7 @@
  */
 
 import type { PrunaModelId, PrunaPredictionResponse, PrunaFileUploadResponse } from "../../domain/entities/pruna.types";
-import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL } from "./pruna-provider.constants";
+import { PRUNA_BASE_URL, PRUNA_PREDICTIONS_URL, PRUNA_FILES_URL, UPLOAD_CONFIG } from "./pruna-provider.constants";
 import { generationLogCollector } from "../utils/log-collector";
 import { detectMimeType } from "../utils/mime-detection.util";
 import { getExtensionForMime } from "../utils/constants/mime.constants";
@@ -29,6 +29,11 @@ export async function uploadFileToStorage(
   apiKey: string,
   sessionId: string,
 ): Promise<string> {
+  // Guard: empty or whitespace-only input
+  if (!base64Data || !base64Data.trim()) {
+    throw new Error("File data is empty. Provide a base64 string or URL.");
+  }
+
   // Already a URL — return as-is
   if (base64Data.startsWith('http')) {
     generationLogCollector.log(sessionId, TAG, 'File already a URL, skipping upload');
@@ -60,31 +65,43 @@ export async function uploadFileToStorage(
 
   const startTime = Date.now();
 
-  const response = await fetch(PRUNA_FILES_URL, {
-    method: 'POST',
-    headers: { 'apikey': apiKey },
-    body: formData,
-  });
+  // Apply timeout to prevent indefinite hangs
+  const uploadController = new AbortController();
+  const timeoutId = setTimeout(() => uploadController.abort(), UPLOAD_CONFIG.timeoutMs);
 
-  if (!response.ok) {
-    const err = await response.json().catch(() => ({ message: response.statusText }));
-    const errorMessage = (err as { message?: string }).message || `File upload error: ${response.status}`;
-    generationLogCollector.error(sessionId, TAG, `File upload failed: ${errorMessage}`);
-    throw new Error(errorMessage);
-  }
+  try {
+    const response = await fetch(PRUNA_FILES_URL, {
+      method: 'POST',
+      headers: { 'apikey': apiKey },
+      body: formData,
+      signal: uploadController.signal,
+    });
+
+    if (!response.ok) {
+      const err = await response.json().catch(() => ({ message: response.statusText }));
+      const errorMessage = (err as { message?: string }).message || `File upload error: ${response.status}`;
+      generationLogCollector.error(sessionId, TAG, `File upload failed: ${errorMessage}`);
+      throw new Error(errorMessage);
+    }
 
-  const data: PrunaFileUploadResponse = await response.json();
-  const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
+    const data: PrunaFileUploadResponse = await response.json();
+    const fileUrl = data.urls?.get || `${PRUNA_FILES_URL}/${data.id}`;
 
-  const elapsed = Date.now() - startTime;
-  generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms → ${fileUrl}`);
+    const elapsed = Date.now() - startTime;
+    generationLogCollector.log(sessionId, TAG, `File upload completed in ${elapsed}ms → ${fileUrl}`);
 
-  return fileUrl;
+    return fileUrl;
+  } catch (error) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      generationLogCollector.error(sessionId, TAG, `File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+      throw new Error(`File upload timed out after ${UPLOAD_CONFIG.timeoutMs}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeoutId);
+  }
 }
 
-/** @deprecated Use uploadFileToStorage instead */
-export const uploadImageToFiles = uploadFileToStorage;
-
 /**
  * Strip base64 data URI prefix, returning raw base64 string.
  * If input is already a URL, returns it unchanged.
@@ -104,6 +121,7 @@ export async function submitPrediction(
   input: Record<string, unknown>,
   apiKey: string,
   sessionId: string,
+  signal?: AbortSignal,
 ): Promise<PrunaPredictionResponse> {
   generationLogCollector.log(sessionId, TAG, `Submitting prediction for model: ${model}`, {
     inputKeys: Object.keys(input),
@@ -120,11 +138,18 @@ export async function submitPrediction(
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({ input }),
+    signal,
   });
 
   if (!response.ok) {
-    const errorData = await response.json().catch(() => ({ message: response.statusText }));
-    const errorMessage = (errorData as { message?: string }).message || `API error: ${response.status}`;
+    const rawBody = await response.text().catch(() => '');
+    let errorMessage = `API error: ${response.status}`;
+    try {
+      const errObj = JSON.parse(rawBody) as Record<string, unknown>;
+      errorMessage = String(errObj.message || errObj.detail || errObj.error || rawBody) || errorMessage;
+    } catch {
+      if (rawBody) errorMessage = rawBody;
+    }
 
     generationLogCollector.error(sessionId, TAG, `Prediction failed (${response.status}): ${errorMessage}`);
 
@@ -167,15 +192,19 @@ export async function pollForResult(
       throw new Error("Request cancelled by user");
     }
 
-    await new Promise(resolve => setTimeout(resolve, intervalMs));
+    // Wait between polls — skip delay on first attempt for faster response
+    if (i > 0) {
+      await new Promise(resolve => setTimeout(resolve, intervalMs));
 
-    if (signal?.aborted) {
-      throw new Error("Request cancelled by user");
+      if (signal?.aborted) {
+        throw new Error("Request cancelled by user");
+      }
     }
 
     try {
       const statusRes = await fetch(fullPollUrl, {
         headers: { 'apikey': apiKey },
+        signal,
       });
 
       if (!statusRes.ok) {
@@ -226,9 +255,9 @@ export function extractUri(data: PrunaPredictionResponse): string | null {
     data.generation_url ||
     (data.output && typeof data.output === 'object' && !Array.isArray(data.output) ? (data.output as { url: string }).url : null) ||
     (typeof data.output === 'string' ? data.output : null) ||
-    data.data ||
     data.video_url ||
     (Array.isArray(data.output) ? data.output[0] : null) ||
+    data.data ||
     null
   );
 }

package/src/infrastructure/services/pruna-input-builder.ts

@@ -68,11 +68,15 @@ function buildImageEditInput(
   input: Record<string, unknown>,
   sessionId: string,
 ): Record<string, unknown> {
-  // p-image-edit expects images array
+  // p-image-edit expects images array (base64 or HTTPS URLs — file URIs resolved by ai-generation-content)
   let images: string[];
 
   if (Array.isArray(input.images)) {
-    images = (input.images as string[]).map(stripBase64Prefix);
+    const validImages = (input.images as unknown[]).filter((img): img is string => typeof img === 'string');
+    if (validImages.length === 0) {
+      throw new Error("Image array is empty or contains no valid strings for p-image-edit.");
+    }
+    images = validImages.map(stripBase64Prefix);
   } else if (typeof input.image === 'string') {
     images = [stripBase64Prefix(input.image as string)];
   } else if (typeof input.image_url === 'string') {
@@ -92,11 +96,6 @@ function buildImageEditInput(
   if (input.width !== undefined) payload.width = input.width;
   if (input.height !== undefined) payload.height = input.height;
 
-  // reference_image: designates the primary/main image in multi-image edits
-  if (typeof input.reference_image === 'string') {
-    payload.reference_image = stripBase64Prefix(input.reference_image);
-  }
-
   return payload;
 }
 

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

@@ -64,7 +64,7 @@ async function singleSubscribeAttempt<T = unknown>(
     // Notify progress: IN_PROGRESS
     options?.onProgress?.({ progress: -1, status: "IN_PROGRESS" });
 
-    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId, signal);
     let uri = extractUri(response);
 
     // If no immediate result, poll for async result
@@ -112,12 +112,19 @@ async function singleSubscribeAttempt<T = unknown>(
       predictionPromise.finally(() => signal.removeEventListener("abort", handler));
     });
     promises.push(abortPromise);
+    // Prevent unhandled rejection if abort loses the race
+    abortPromise.catch(() => {});
 
     if (signal.aborted) {
       throw new Error("Request cancelled by user");
     }
   }
 
+  // Prevent unhandled rejections for promises that lose the race
+  // (e.g. timeout fires after abort wins → would cause React Native red screen)
+  predictionPromise.catch(() => {});
+  timeoutPromise.catch(() => {});
+
   const resultUrl = await Promise.race(promises) as string;
   const requestId = `pruna_${model}_${Date.now()}`;
 
@@ -205,7 +212,8 @@ export async function handlePrunaSubscription<T = unknown>(
     }
   }
 
-  throw lastError;
+  // Unreachable: loop always returns or throws. TypeScript safety net.
+  throw lastError instanceof Error ? lastError : new Error("Subscription failed after all retry attempts.");
 }
 
 /**
@@ -226,7 +234,7 @@ export async function handlePrunaRun<T = unknown>(
 
   try {
     const modelInput = await buildModelInput(model, input, apiKey, sessionId);
-    const response = await submitPrediction(model, modelInput, apiKey, sessionId);
+    const response = await submitPrediction(model, modelInput, apiKey, sessionId, options?.signal);
 
     let uri = extractUri(response);
 

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

@@ -86,7 +86,11 @@ export class PrunaProvider implements IAIProvider {
     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);
+    try {
+      return await queueOps.submitJob(prunaModel, input, apiKey, sessionId);
+    } finally {
+      generationLogCollector.endSession(sessionId);
+    }
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
@@ -119,6 +123,7 @@ export class PrunaProvider implements IAIProvider {
     const existing = getExistingRequest<T>(key);
     if (existing) {
       generationLogCollector.log(sessionId, TAG, `Dedup hit — returning existing request`);
+      generationLogCollector.endSession(sessionId); // Clean up unused session
       return existing.promise;
     }
 
@@ -147,6 +152,7 @@ export class PrunaProvider implements IAIProvider {
       .catch((error) => {
         const totalElapsed = Date.now() - totalStart;
         generationLogCollector.error(sessionId, TAG, `Generation FAILED in ${totalElapsed}ms: ${error instanceof Error ? error.message : String(error)}`);
+        generationLogCollector.endSession(sessionId); // Clean up session on error
         rejectPromise(error);
       })
       .finally(() => {
@@ -169,14 +175,19 @@ export class PrunaProvider implements IAIProvider {
 
     const signal = options?.signal;
     if (signal?.aborted) {
+      generationLogCollector.endSession(sessionId);
       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 });
+    try {
+      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;
+    } finally {
+      generationLogCollector.endSession(sessionId);
     }
-    return result;
   }
 
   reset(): void {

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

@@ -5,7 +5,8 @@
 
 import type { PrunaModelId } from "../../domain/entities/pruna.types";
 import type { JobSubmission, JobStatus } from "../../domain/types";
-import { submitPrediction, extractUri } from "./pruna-api-client";
+import { submitPrediction, extractUri, resolveUri } from "./pruna-api-client";
+import { PRUNA_BASE_URL } from "./pruna-provider.constants";
 import { buildModelInput } from "./pruna-input-builder";
 import { generationLogCollector } from "../utils/log-collector";
 
@@ -62,7 +63,7 @@ export async function getJobStatus(
   statusUrl: string,
   apiKey: string,
 ): Promise<JobStatus> {
-  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `${PRUNA_BASE_URL}${statusUrl}`;
 
   const response = await fetch(fullUrl, {
     headers: { 'apikey': apiKey },
@@ -83,9 +84,11 @@ export async function getJobStatus(
   }
 
   if (typedData.status === 'failed') {
+    const errorMessage = typedData.error || "Generation failed during processing.";
     return {
       status: "FAILED",
       requestId: statusUrl,
+      logs: [{ message: errorMessage, level: "error" }],
     };
   }
 
@@ -104,7 +107,7 @@ export async function getJobResult<T = unknown>(
   statusUrl: string,
   apiKey: string,
 ): Promise<T> {
-  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `https://api.pruna.ai${statusUrl}`;
+  const fullUrl = statusUrl.startsWith('http') ? statusUrl : `${PRUNA_BASE_URL}${statusUrl}`;
 
   const response = await fetch(fullUrl, {
     headers: { 'apikey': apiKey },
@@ -126,6 +129,5 @@ export async function getJobResult<T = unknown>(
     throw new Error("Result not ready or extraction failed.");
   }
 
-  const resolvedUri = uri.startsWith('/') ? `https://api.pruna.ai${uri}` : uri;
-  return { url: resolvedUri } as T;
+  return { url: resolveUri(uri) } as T;
 }

package/src/infrastructure/services/request-store.ts

@@ -16,8 +16,8 @@ const STORE_KEY = "__PRUNA_PROVIDER_REQUESTS__";
 const TIMER_KEY = "__PRUNA_PROVIDER_CLEANUP_TIMER__";
 type RequestStore = Map<string, ActiveRequest>;
 
-const CLEANUP_INTERVAL = 60000;
-const MAX_REQUEST_AGE = 300000;
+const CLEANUP_INTERVAL = 60_000;
+const MAX_REQUEST_AGE = 3_660_000; // 61 min — must exceed max allowed timeout (1 hour)
 
 function getCleanupTimer(): ReturnType<typeof setInterval> | null {
   const globalObj = globalThis as Record<string, unknown>;

package/src/infrastructure/utils/constants/index.ts

@@ -6,6 +6,7 @@ export {
   MIME_AUDIO_WAV,
   MIME_AUDIO_FLAC,
   MIME_AUDIO_MP4,
+  MIME_APPLICATION_OCTET,
   MIME_DEFAULT,
   MIME_TO_EXTENSION,
   getExtensionForMime,

package/src/infrastructure/utils/constants/mime.constants.ts

@@ -15,7 +15,8 @@ export const MIME_AUDIO_FLAC = 'audio/flac' as const;
 export const MIME_AUDIO_MP4 = 'audio/mp4' as const;
 
 // ── Fallback ────────────────────────────────────────────────
-export const MIME_DEFAULT = MIME_IMAGE_PNG;
+export const MIME_APPLICATION_OCTET = 'application/octet-stream' as const;
+export const MIME_DEFAULT = MIME_APPLICATION_OCTET;
 
 /** Maps MIME type → file extension for upload naming */
 export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
@@ -26,6 +27,7 @@ export const MIME_TO_EXTENSION: Readonly<Record<string, string>> = {
   [MIME_AUDIO_WAV]: 'wav',
   [MIME_AUDIO_FLAC]: 'flac',
   [MIME_AUDIO_MP4]: 'm4a',
+  [MIME_APPLICATION_OCTET]: 'bin',
 };
 
 /**

package/src/infrastructure/utils/log-collector.ts

@@ -25,10 +25,19 @@ interface Session {
 
 let sessionCounter = 0;
 
+/** Max concurrent sessions before auto-evicting oldest */
+const MAX_SESSIONS = 50;
+
 class GenerationLogCollector {
   private sessions = new Map<string, Session>();
 
   startSession(): string {
+    // Evict oldest sessions if limit exceeded
+    if (this.sessions.size >= MAX_SESSIONS) {
+      const oldestKey = this.sessions.keys().next().value;
+      if (oldestKey) this.sessions.delete(oldestKey);
+    }
+
     const id = `pruna_session_${++sessionCounter}_${Date.now()}`;
     this.sessions.set(id, { startTime: Date.now(), entries: [] });
     return id;

package/src/infrastructure/utils/mime-detection.util.ts

@@ -48,7 +48,8 @@ export function detectMimeType(bytes: Uint8Array): string {
       // WEBP at offset 8
       if (bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50) return MIME_IMAGE_WEBP;
     }
-    return MIME_IMAGE_WEBP;
+    // Unknown RIFF subtype (AVI, AIFF, etc.) or insufficient bytes — don't assume WebP
+    return MIME_DEFAULT;
   }
 
   // ── Audio formats ───────────────────────────────────────

package/src/infrastructure/utils/pruna-error-handler.util.ts

@@ -15,6 +15,11 @@ export function mapPrunaError(error: unknown): PrunaErrorInfo {
   const stack = error instanceof Error ? error.stack : undefined;
   const statusCode = (error as Error & { statusCode?: number }).statusCode;
 
+  // AbortError from signal.abort() during fetch — treat as user cancellation
+  if (error instanceof Error && error.name === 'AbortError') {
+    return buildErrorInfo(PrunaErrorType.UNKNOWN, "error.pruna.cancelled", false, originalError, originalErrorName, stack);
+  }
+
   // HTTP status code mapping
   if (statusCode !== undefined) {
     return mapStatusCode(statusCode, originalError, originalErrorName, stack);

package/src/infrastructure/utils/type-guards/index.ts

@@ -27,5 +27,5 @@ export function isValidPrompt(value: unknown): value is string {
 }
 
 export function isValidTimeout(value: unknown): value is number {
-  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 600000;
+  return typeof value === 'number' && Number.isInteger(value) && value >= 1 && value <= 3600000;
 }

package/src/init/createAiProviderInitModule.ts

@@ -35,6 +35,13 @@ export interface AiProviderInitModuleConfig {
    */
   dependsOn?: string[];
 
+  /**
+   * Whether to set Pruna as the active provider after initialization.
+   * When false, registers the provider but doesn't make it active.
+   * @default true
+   */
+  setAsActive?: boolean;
+
   /**
    * Optional callback called after provider is initialized
    */
@@ -51,6 +58,7 @@ export function createAiProviderInitModule(
     getApiKey,
     critical = false,
     dependsOn = ['firebase'],
+    setAsActive = true,
     onInitialized,
   } = config;
 
@@ -58,12 +66,12 @@ export function createAiProviderInitModule(
     name: 'aiProviders',
     critical,
     dependsOn,
-    init: () => {
+    init: async () => {
       try {
         const apiKey = getApiKey();
 
         if (!apiKey) {
-          return Promise.resolve(false);
+          return false;
         }
 
         prunaProvider.initialize({ apiKey });
@@ -71,13 +79,15 @@ export function createAiProviderInitModule(
         if (!providerRegistry.hasProvider(prunaProvider.providerId)) {
           providerRegistry.register(prunaProvider);
         }
-        providerRegistry.setActiveProvider(prunaProvider.providerId);
+        if (setAsActive) {
+          providerRegistry.setActiveProvider(prunaProvider.providerId);
+        }
 
         if (onInitialized) {
           onInitialized();
         }
 
-        return Promise.resolve(true);
+        return true;
       } catch (error) {
         console.error('[AiProviderInitModule] Pruna initialization failed:', error);
         throw error;

package/src/presentation/hooks/use-pruna-generation.ts

@@ -49,8 +49,10 @@ export function usePrunaGeneration<T = unknown>(
   const [error, setError] = useState<PrunaErrorInfo | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
+  const [requestId, setRequestId] = useState<string | null>(null);
 
   const stateManagerRef = useRef<PrunaGenerationStateManager<T> | null>(null);
+  const abortControllerRef = useRef<AbortController | null>(null);
   const optionsRef = useRef(options);
 
   useEffect(() => {
@@ -73,13 +75,13 @@ export function usePrunaGeneration<T = unknown>(
         stateManagerRef.current = null;
       }
 
-      if (prunaProvider.hasRunningRequest()) {
-        try {
-          prunaProvider.cancelCurrentRequest();
-        } catch (error) {
-          console.warn('[usePrunaGeneration] Error cancelling request on unmount:', error);
-        }
+      // Cancel this hook's active request on unmount
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
       }
+      // Also cancel the provider's internal request
+      prunaProvider.cancelCurrentRequest();
     };
   }, []);
 
@@ -88,10 +90,18 @@ export function usePrunaGeneration<T = unknown>(
       const stateManager = stateManagerRef.current;
       if (!stateManager || !stateManager.checkMounted()) return null;
 
+      // Cancel any previous in-flight request from this hook
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+
       stateManager.setLastRequest(model, input);
       setIsLoading(true);
       setError(null);
       setData(null);
+      setRequestId(null);
       stateManager.setCurrentRequestId(null);
       setIsCancelling(false);
 
@@ -104,6 +114,11 @@ export function usePrunaGeneration<T = unknown>(
               stateManager.getCurrentRequestId()
             );
             stateManager.handleQueueUpdate(prunaStatus);
+
+            // Update reactive requestId from queue status
+            if (status.requestId) {
+              setRequestId(status.requestId);
+            }
           },
         });
 
@@ -121,6 +136,10 @@ export function usePrunaGeneration<T = unknown>(
           setIsLoading(false);
           setIsCancelling(false);
         }
+        // Clean up controller reference
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
       }
     },
     []
@@ -137,10 +156,13 @@ export function usePrunaGeneration<T = unknown>(
   }, [generate]);
 
   const cancel = useCallback(() => {
-    if (prunaProvider.hasRunningRequest()) {
+    if (abortControllerRef.current) {
       setIsCancelling(true);
-      prunaProvider.cancelCurrentRequest();
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
     }
+    // Propagate cancel to the provider's internal AbortController
+    prunaProvider.cancelCurrentRequest();
   }, []);
 
   const reset = useCallback(() => {
@@ -149,11 +171,10 @@ export function usePrunaGeneration<T = unknown>(
     setError(null);
     setIsLoading(false);
     setIsCancelling(false);
+    setRequestId(null);
     stateManagerRef.current?.clearLastRequest();
   }, [cancel]);
 
-  const requestId = stateManagerRef.current?.getCurrentRequestId() ?? null;
-
   return {
     data,
     error,