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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Umit UZ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,106 @@
+# @umituz/react-native-ai-fal-provider
+
+FAL AI provider service for React Native applications. Provides client wrapper, error handling, and React hooks.
+
+## Installation
+
+```bash
+npm install @umituz/react-native-ai-fal-provider @fal-ai/client
+```
+
+## Usage
+
+### Initialize the Client
+
+```typescript
+import { falClientService } from "@umituz/react-native-ai-fal-provider";
+
+falClientService.initialize({
+  apiKey: "YOUR_FAL_API_KEY",
+  maxRetries: 3,
+  defaultTimeoutMs: 300000,
+});
+```
+
+### Using the Hook
+
+```typescript
+import { useFalGeneration } from "@umituz/react-native-ai-fal-provider";
+
+function MyComponent() {
+  const { data, error, isLoading, generate, retry } = useFalGeneration({
+    timeoutMs: 120000,
+    onProgress: (status) => console.log("Progress:", status),
+    onError: (error) => console.log("Error:", error),
+  });
+
+  const handleGenerate = async () => {
+    await generate("fal-ai/flux/dev", {
+      prompt: "A beautiful sunset",
+      image_size: "landscape_16_9",
+    });
+  };
+
+  return (
+    // Your UI
+  );
+}
+```
+
+### Direct Service Usage
+
+```typescript
+import { falClientService } from "@umituz/react-native-ai-fal-provider";
+
+const result = await falClientService.subscribe("fal-ai/flux/dev", {
+  prompt: "A beautiful sunset",
+});
+```
+
+### Error Handling
+
+```typescript
+import { mapFalError, isFalErrorRetryable } from "@umituz/react-native-ai-fal-provider";
+
+try {
+  await falClientService.run("fal-ai/flux/dev", { prompt: "test" });
+} catch (error) {
+  const errorInfo = mapFalError(error);
+  console.log("Error type:", errorInfo.type);
+  console.log("Message key:", errorInfo.messageKey);
+  console.log("Retryable:", errorInfo.retryable);
+}
+```
+
+## API
+
+### falClientService
+
+- `initialize(config)` - Initialize the client with API key
+- `subscribe(endpoint, input, options)` - Subscribe to generation job
+- `run(endpoint, input)` - Run a generation job
+- `submitJob(endpoint, input)` - Submit a job to queue
+- `getJobStatus(endpoint, requestId)` - Get job status
+- `getJobResult(endpoint, requestId)` - Get job result
+- `isInitialized()` - Check if client is initialized
+- `reset()` - Reset the client
+
+### useFalGeneration Hook
+
+- `data` - Generation result
+- `error` - Error info if failed
+- `isLoading` - Loading state
+- `isRetryable` - Whether error is retryable
+- `generate(endpoint, input)` - Start generation
+- `retry()` - Retry last generation
+- `reset()` - Reset state
+
+### Error Utilities
+
+- `mapFalError(error)` - Map error to FalErrorInfo
+- `isFalErrorRetryable(error)` - Check if error is retryable
+- `categorizeFalError(error)` - Get error category
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@umituz/react-native-ai-fal-provider",
+  "version": "1.0.0",
+  "description": "FAL AI provider service for React Native applications - client wrapper, error handling, and utilities",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
+    "version:minor": "npm version minor -m 'chore: release v%s'",
+    "version:major": "npm version major -m 'chore: release v%s'"
+  },
+  "keywords": [
+    "react-native",
+    "fal-ai",
+    "ai",
+    "text-to-image",
+    "text-to-video",
+    "image-to-video",
+    "ai-generation"
+  ],
+  "author": "Umit UZ <umit@umituz.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umituz/react-native-ai-fal-provider"
+  },
+  "peerDependencies": {
+    "@fal-ai/client": ">=1.0.0",
+    "react": ">=18.2.0",
+    "react-native": ">=0.76.0"
+  },
+  "dependencies": {
+    "@fal-ai/client": "^1.2.1"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.57.0",
+    "react": "^18.3.0",
+    "react-native": "^0.76.0",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

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

@@ -0,0 +1,44 @@
+/**
+ * FAL Error Types
+ * Error handling type definitions
+ */
+
+export enum FalErrorType {
+  NETWORK = "network",
+  TIMEOUT = "timeout",
+  API_ERROR = "api_error",
+  VALIDATION = "validation",
+  CONTENT_POLICY = "content_policy",
+  RATE_LIMIT = "rate_limit",
+  AUTHENTICATION = "authentication",
+  QUOTA_EXCEEDED = "quota_exceeded",
+  MODEL_NOT_FOUND = "model_not_found",
+  UNKNOWN = "unknown",
+}
+
+export interface FalErrorCategory {
+  type: FalErrorType;
+  messageKey: string;
+  retryable: boolean;
+}
+
+export interface FalErrorInfo {
+  type: FalErrorType;
+  messageKey: string;
+  retryable: boolean;
+  originalError: string;
+  statusCode?: number;
+}
+
+export interface FalErrorMessages {
+  network?: string;
+  timeout?: string;
+  api_error?: string;
+  validation?: string;
+  content_policy?: string;
+  rate_limit?: string;
+  authentication?: string;
+  quota_exceeded?: string;
+  model_not_found?: string;
+  unknown?: string;
+}

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

@@ -0,0 +1,64 @@
+/**
+ * FAL AI Types
+ * Core type definitions for FAL AI integration
+ */
+
+export interface FalConfig {
+  apiKey: string;
+  baseUrl?: string;
+  maxRetries?: number;
+  baseDelay?: number;
+  maxDelay?: number;
+  defaultTimeoutMs?: number;
+}
+
+export interface FalModel {
+  id: string;
+  name: string;
+  description?: string;
+  endpoint: string;
+  type: FalModelType;
+  pricing?: FalModelPricing;
+  enabled: boolean;
+  order?: number;
+}
+
+export type FalModelType =
+  | "text-to-image"
+  | "text-to-video"
+  | "text-to-voice"
+  | "image-to-video"
+  | "image-to-image";
+
+export interface FalModelPricing {
+  creditsPerGeneration: number;
+  currency?: string;
+}
+
+export interface FalJobInput {
+  [key: string]: unknown;
+}
+
+export interface FalJobResult<T = unknown> {
+  requestId: string;
+  data: T;
+  logs?: FalLogEntry[];
+}
+
+export interface FalLogEntry {
+  message: string;
+  timestamp?: string;
+  level?: "info" | "warn" | "error";
+}
+
+export interface FalQueueStatus {
+  status: "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
+  requestId: string;
+  logs?: FalLogEntry[];
+  queuePosition?: number;
+}
+
+export interface FalSubscribeOptions {
+  onQueueUpdate?: (update: FalQueueStatus) => void;
+  timeoutMs?: number;
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+/**
+ * @umituz/react-native-ai-fal-provider
+ * FAL AI provider service for React Native applications
+ *
+ * Usage:
+ *   import {
+ *     falClientService,
+ *     useFalGeneration,
+ *     mapFalError
+ *   } from '@umituz/react-native-ai-fal-provider';
+ */
+
+// =============================================================================
+// DOMAIN LAYER - Types
+// =============================================================================
+
+export type {
+  FalConfig,
+  FalModel,
+  FalModelType,
+  FalModelPricing,
+  FalJobInput,
+  FalJobResult,
+  FalLogEntry,
+  FalQueueStatus,
+  FalSubscribeOptions,
+} from "./domain/entities/fal.types";
+
+export {
+  FalErrorType,
+} from "./domain/entities/error.types";
+
+export type {
+  FalErrorCategory,
+  FalErrorInfo,
+  FalErrorMessages,
+} from "./domain/entities/error.types";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Services
+// =============================================================================
+
+export { falClientService } from "./infrastructure/services";
+
+// =============================================================================
+// INFRASTRUCTURE LAYER - Utils
+// =============================================================================
+
+export {
+  categorizeFalError,
+  falErrorMapper,
+  mapFalError,
+  isFalErrorRetryable,
+} from "./infrastructure/utils";
+
+// =============================================================================
+// PRESENTATION LAYER - Hooks
+// =============================================================================
+
+export {
+  useFalGeneration,
+} from "./presentation/hooks";
+
+export type {
+  UseFalGenerationOptions,
+  UseFalGenerationResult,
+} from "./presentation/hooks";

package/src/infrastructure/services/fal-client.service.ts

@@ -0,0 +1,146 @@
+/**
+ * FAL Client Service
+ * Wrapper for FAL AI client operations
+ */
+
+import { fal } from "@fal-ai/client";
+import type {
+  FalConfig,
+  FalJobInput,
+  FalSubscribeOptions,
+} from "../../domain/entities/fal.types";
+
+declare const __DEV__: boolean;
+
+const DEFAULT_CONFIG: Partial<FalConfig> = {
+  maxRetries: 3,
+  baseDelay: 1000,
+  maxDelay: 10000,
+  defaultTimeoutMs: 300000,
+};
+
+class FalClientService {
+  private apiKey: string | null = null;
+  private config: FalConfig | null = null;
+  private initialized = false;
+
+  initialize(config: FalConfig): void {
+    this.apiKey = config.apiKey;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+
+    fal.config({
+      credentials: config.apiKey,
+      retry: {
+        maxRetries: this.config.maxRetries ?? 3,
+        baseDelay: this.config.baseDelay ?? 1000,
+        maxDelay: this.config.maxDelay ?? 10000,
+      },
+    });
+
+    this.initialized = true;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[FAL] Client initialized");
+    }
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  getConfig(): FalConfig | null {
+    return this.config;
+  }
+
+  private validateInitialization(): void {
+    if (!this.apiKey || !this.initialized) {
+      throw new Error("FAL client not initialized. Call initialize() first.");
+    }
+  }
+
+  async submitJob(modelEndpoint: string, input: FalJobInput) {
+    this.validateInitialization();
+    return fal.queue.submit(modelEndpoint, { input });
+  }
+
+  async getJobStatus(modelEndpoint: string, requestId: string) {
+    this.validateInitialization();
+    return fal.queue.status(modelEndpoint, { requestId, logs: true });
+  }
+
+  async getJobResult(modelEndpoint: string, requestId: string) {
+    this.validateInitialization();
+    return fal.queue.result(modelEndpoint, { requestId });
+  }
+
+  async subscribe<T = unknown>(
+    modelEndpoint: string,
+    input: FalJobInput,
+    options?: FalSubscribeOptions
+  ): Promise<T> {
+    this.validateInitialization();
+
+    const timeoutMs = options?.timeoutMs ?? this.config?.defaultTimeoutMs ?? 300000;
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[FAL] Subscribe started:", { modelEndpoint, timeoutMs });
+    }
+
+    try {
+      const result = await Promise.race([
+        fal.subscribe(modelEndpoint, {
+          input,
+          onQueueUpdate: (update) => {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              // eslint-disable-next-line no-console
+              console.log("[FAL] Queue update:", { status: update.status });
+            }
+            options?.onQueueUpdate?.(update as never);
+          },
+        }),
+        new Promise<never>((_, reject) => {
+          timeoutId = setTimeout(
+            () => reject(new Error("FAL subscription timeout")),
+            timeoutMs
+          );
+        }),
+      ]);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[FAL] Subscribe completed:", { modelEndpoint });
+      }
+
+      return result as T;
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[FAL] Subscribe error:", {
+          modelEndpoint,
+          error: error instanceof Error ? error.message : error,
+        });
+      }
+      throw error;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+
+  async run<T = unknown>(modelEndpoint: string, input: FalJobInput): Promise<T> {
+    this.validateInitialization();
+    return fal.run(modelEndpoint, { input }) as Promise<T>;
+  }
+
+  reset(): void {
+    this.apiKey = null;
+    this.config = null;
+    this.initialized = false;
+  }
+}
+
+export const falClientService = new FalClientService();

package/src/infrastructure/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Services Index
+ * Exports all infrastructure services
+ */
+
+export { falClientService } from "./fal-client.service";

package/src/infrastructure/utils/error-categorizer.ts

@@ -0,0 +1,131 @@
+/**
+ * FAL Error Categorizer
+ * Classifies FAL AI errors for handling
+ */
+
+import { FalErrorType, type FalErrorCategory } from "../../domain/entities/error.types";
+
+const NETWORK_PATTERNS = [
+  "network",
+  "fetch",
+  "connection",
+  "econnrefused",
+  "enotfound",
+  "timeout",
+  "etimedout",
+];
+
+const VALIDATION_PATTERNS = [
+  "validation",
+  "invalid",
+  "unprocessable",
+  "422",
+  "bad request",
+  "400",
+];
+
+const CONTENT_POLICY_PATTERNS = [
+  "content_policy",
+  "content policy",
+  "policy violation",
+  "not allowed",
+  "nsfw",
+  "inappropriate",
+];
+
+const RATE_LIMIT_PATTERNS = ["rate limit", "too many requests", "429", "quota"];
+
+const AUTH_PATTERNS = [
+  "unauthorized",
+  "401",
+  "forbidden",
+  "403",
+  "api key",
+  "authentication",
+  "invalid credentials",
+];
+
+const QUOTA_PATTERNS = [
+  "quota exceeded",
+  "insufficient credits",
+  "billing",
+  "payment required",
+  "402",
+];
+
+const MODEL_NOT_FOUND_PATTERNS = [
+  "model not found",
+  "endpoint not found",
+  "404",
+  "not found",
+];
+
+class FalErrorClassifier {
+  categorize(error: unknown): FalErrorCategory {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorString = errorMessage.toLowerCase();
+    const errorName = error instanceof Error ? error.constructor.name : "";
+
+    if (this.matchesPatterns(errorString, NETWORK_PATTERNS)) {
+      return { type: FalErrorType.NETWORK, messageKey: "network", retryable: true };
+    }
+
+    if (errorString.includes("timeout") || errorString.includes("timed out")) {
+      return { type: FalErrorType.TIMEOUT, messageKey: "timeout", retryable: true };
+    }
+
+    if (this.matchesPatterns(errorString, VALIDATION_PATTERNS)) {
+      return { type: FalErrorType.VALIDATION, messageKey: "validation", retryable: false };
+    }
+
+    if (this.matchesPatterns(errorString, CONTENT_POLICY_PATTERNS)) {
+      return { type: FalErrorType.CONTENT_POLICY, messageKey: "content_policy", retryable: false };
+    }
+
+    if (this.matchesPatterns(errorString, RATE_LIMIT_PATTERNS)) {
+      return { type: FalErrorType.RATE_LIMIT, messageKey: "rate_limit", retryable: true };
+    }
+
+    if (this.matchesPatterns(errorString, AUTH_PATTERNS)) {
+      return { type: FalErrorType.AUTHENTICATION, messageKey: "authentication", retryable: false };
+    }
+
+    if (this.matchesPatterns(errorString, QUOTA_PATTERNS)) {
+      return { type: FalErrorType.QUOTA_EXCEEDED, messageKey: "quota_exceeded", retryable: false };
+    }
+
+    if (this.matchesPatterns(errorString, MODEL_NOT_FOUND_PATTERNS)) {
+      return { type: FalErrorType.MODEL_NOT_FOUND, messageKey: "model_not_found", retryable: false };
+    }
+
+    if (this.isApiError(errorString, errorName)) {
+      const retryable = !this.isInternalServerError(errorString);
+      return { type: FalErrorType.API_ERROR, messageKey: "api_error", retryable };
+    }
+
+    return { type: FalErrorType.UNKNOWN, messageKey: "unknown", retryable: false };
+  }
+
+  private matchesPatterns(errorString: string, patterns: string[]): boolean {
+    return patterns.some((pattern) => errorString.includes(pattern));
+  }
+
+  private isApiError(errorString: string, errorName: string): boolean {
+    return (
+      errorString.includes("api error") ||
+      errorName.toLowerCase() === "apierror" ||
+      ["502", "503", "504"].some((code) => errorString.includes(code)) ||
+      this.isInternalServerError(errorString)
+    );
+  }
+
+  private isInternalServerError(errorString: string): boolean {
+    return errorString.includes("internal server error") || errorString.includes("500");
+  }
+}
+
+const classifier = new FalErrorClassifier();
+
+export const categorizeFalError = (error: unknown): FalErrorCategory => {
+  return classifier.categorize(error);
+};

package/src/infrastructure/utils/error-mapper.ts

@@ -0,0 +1,68 @@
+/**
+ * FAL Error Mapper
+ * Maps FAL errors to user-friendly information
+ */
+
+import type { FalErrorInfo, FalErrorMessages } from "../../domain/entities/error.types";
+import { categorizeFalError } from "./error-categorizer";
+
+const DEFAULT_MESSAGE_PREFIX = "fal.errors";
+
+class FalErrorMapper {
+  private messagePrefix = DEFAULT_MESSAGE_PREFIX;
+  private customMessages?: FalErrorMessages;
+
+  setMessagePrefix(prefix: string): void {
+    this.messagePrefix = prefix;
+  }
+
+  setCustomMessages(messages: FalErrorMessages): void {
+    this.customMessages = messages;
+  }
+
+  mapToErrorInfo(error: unknown): FalErrorInfo {
+    const category = categorizeFalError(error);
+    const originalError = error instanceof Error ? error.message : String(error);
+
+    const messageKey = this.customMessages?.[category.messageKey as keyof FalErrorMessages]
+      ? category.messageKey
+      : `${this.messagePrefix}.${category.messageKey}`;
+
+    return {
+      type: category.type,
+      messageKey,
+      retryable: category.retryable,
+      originalError,
+      statusCode: this.extractStatusCode(originalError),
+    };
+  }
+
+  isRetryable(error: unknown): boolean {
+    const category = categorizeFalError(error);
+    return category.retryable;
+  }
+
+  getErrorType(error: unknown) {
+    return categorizeFalError(error).type;
+  }
+
+  private extractStatusCode(errorString: string): number | undefined {
+    const codes = ["400", "401", "402", "403", "404", "422", "429", "500", "502", "503", "504"];
+    for (const code of codes) {
+      if (errorString.includes(code)) {
+        return parseInt(code, 10);
+      }
+    }
+    return undefined;
+  }
+}
+
+export const falErrorMapper = new FalErrorMapper();
+
+export const mapFalError = (error: unknown): FalErrorInfo => {
+  return falErrorMapper.mapToErrorInfo(error);
+};
+
+export const isFalErrorRetryable = (error: unknown): boolean => {
+  return falErrorMapper.isRetryable(error);
+};

package/src/infrastructure/utils/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Utils Index
+ * Exports all utility functions
+ */
+
+export { categorizeFalError } from "./error-categorizer";
+export { falErrorMapper, mapFalError, isFalErrorRetryable } from "./error-mapper";

package/src/presentation/hooks/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Hooks Index
+ * Exports all React hooks
+ */
+
+export { useFalGeneration } from "./use-fal-generation";
+export type {
+  UseFalGenerationOptions,
+  UseFalGenerationResult,
+} from "./use-fal-generation";

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

@@ -0,0 +1,86 @@
+/**
+ * useFalGeneration Hook
+ * React hook for FAL AI generation operations
+ */
+
+import { useState, useCallback, useRef } from "react";
+import { falClientService } from "../../infrastructure/services/fal-client.service";
+import { mapFalError, isFalErrorRetryable } from "../../infrastructure/utils/error-mapper";
+import type { FalJobInput, FalQueueStatus } from "../../domain/entities/fal.types";
+import type { FalErrorInfo } from "../../domain/entities/error.types";
+
+export interface UseFalGenerationOptions {
+  timeoutMs?: number;
+  onProgress?: (status: FalQueueStatus) => void;
+  onError?: (error: FalErrorInfo) => void;
+}
+
+export interface UseFalGenerationResult<T> {
+  data: T | null;
+  error: FalErrorInfo | null;
+  isLoading: boolean;
+  isRetryable: boolean;
+  generate: (modelEndpoint: string, input: FalJobInput) => Promise<T | null>;
+  retry: () => Promise<T | null>;
+  reset: () => void;
+}
+
+export function useFalGeneration<T = unknown>(
+  options?: UseFalGenerationOptions
+): UseFalGenerationResult<T> {
+  const [data, setData] = useState<T | null>(null);
+  const [error, setError] = useState<FalErrorInfo | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const lastRequestRef = useRef<{ endpoint: string; input: FalJobInput } | null>(null);
+
+  const generate = useCallback(
+    async (modelEndpoint: string, input: FalJobInput): Promise<T | null> => {
+      lastRequestRef.current = { endpoint: modelEndpoint, input };
+      setIsLoading(true);
+      setError(null);
+      setData(null);
+
+      try {
+        const result = await falClientService.subscribe<T>(modelEndpoint, input, {
+          timeoutMs: options?.timeoutMs,
+          onQueueUpdate: options?.onProgress,
+        });
+
+        setData(result);
+        return result;
+      } catch (err) {
+        const errorInfo = mapFalError(err);
+        setError(errorInfo);
+        options?.onError?.(errorInfo);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [options]
+  );
+
+  const retry = useCallback(async (): Promise<T | null> => {
+    if (!lastRequestRef.current) return null;
+    const { endpoint, input } = lastRequestRef.current;
+    return generate(endpoint, input);
+  }, [generate]);
+
+  const reset = useCallback(() => {
+    setData(null);
+    setError(null);
+    setIsLoading(false);
+    lastRequestRef.current = null;
+  }, []);
+
+  return {
+    data,
+    error,
+    isLoading,
+    isRetryable: error ? isFalErrorRetryable(error.originalError) : false,
+    generate,
+    retry,
+    reset,
+  };
+}