@umituz/react-native-ai-pruna-provider 1.0.42 → 1.0.44

package/package.json

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

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

@@ -22,7 +22,8 @@ import type { LogEntry } from "../utils/log-collector";
 import {
   createRequestKey, getExistingRequest, storeRequest,
   removeRequest, cancelRequest, cancelAllRequests, hasActiveRequests,
-  storeRequestIdMapping, getStatusUrlForRequestId, removeRequestIdMapping,
+  storeRequestIdMapping, storeImmediateResultMapping,
+  getStatusUrlForRequestId, getResponseUrlForRequestId, removeRequestIdMapping,
 } from "./request-store";
 
 export class PrunaProvider implements IAIProvider {
@@ -86,15 +87,26 @@ export class PrunaProvider implements IAIProvider {
     const apiKey = this.validateInit();
     const prunaModel = this.validateModel(model);
     const sessionId = generationLogCollector.startSession();
-    generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() for model: ${model}`);
+    generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() START model: ${model}`);
     try {
       const submission = await queueOps.submitJob(prunaModel, input, apiKey, sessionId);
 
-      // Store requestId -> statusUrl mapping for getJobStatus/getJobResult
-      if (submission.statusUrl) {
+      // Log response type
+      if (submission.responseUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() IMMEDIATE RESULT - requestId: ${submission.requestId}, responseUrl: ${submission.responseUrl.substring(0, 80)}...`);
+        // Store requestId -> responseUrl mapping for immediate results (already complete)
+        storeImmediateResultMapping(submission.requestId, submission.responseUrl, model);
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() Stored immediate result mapping: ${submission.requestId}`);
+      } else if (submission.statusUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() ASYNC JOB - requestId: ${submission.requestId}, statusUrl: ${submission.statusUrl.substring(0, 80)}...`);
+        // Store requestId -> statusUrl mapping for async jobs (requires polling)
         storeRequestIdMapping(submission.requestId, submission.statusUrl, model);
+        generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() Stored async job mapping: ${submission.requestId}`);
+      } else {
+        generationLogCollector.warn(sessionId, 'pruna-provider', `submitJob() WARNING - No responseUrl or statusUrl in submission`);
       }
 
+      generationLogCollector.log(sessionId, 'pruna-provider', `submitJob() COMPLETE - returning submission with requestId: ${submission.requestId}`);
       return submission;
     } finally {
       generationLogCollector.endSession(sessionId);
@@ -104,29 +116,82 @@ export class PrunaProvider implements IAIProvider {
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
     const apiKey = this.validateInit();
     const prunaModel = this.validateModel(model);
+    const sessionId = generationLogCollector.startSession();
+    generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() START - model: ${model}, requestId: ${requestId}`);
 
-    // Look up statusUrl from requestId mapping
-    const statusUrl = getStatusUrlForRequestId(requestId);
-    if (statusUrl) {
-      return queueOps.getJobStatus(prunaModel, statusUrl, apiKey);
-    }
+    try {
+      // Check if this is an immediate result (already completed)
+      const responseUrl = getResponseUrlForRequestId(requestId);
+      if (responseUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() FOUND immediate result for ${requestId} - returning COMPLETED`);
+        generationLogCollector.endSession(sessionId);
+        // Result is already available
+        return {
+          status: "COMPLETED",
+          requestId,
+        };
+      }
+
+      // Look up statusUrl from requestId mapping (async job)
+      const statusUrl = getStatusUrlForRequestId(requestId);
+      if (statusUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() FOUND async job for ${requestId} - polling statusUrl: ${statusUrl.substring(0, 80)}...`);
+        const result = await queueOps.getJobStatus(prunaModel, statusUrl, apiKey);
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() Poll result: ${result.status}`);
+        generationLogCollector.endSession(sessionId);
+        return result;
+      }
 
-    // Fallback: assume requestId is actually a statusUrl (for direct calls with statusUrl)
-    return queueOps.getJobStatus(prunaModel, requestId, apiKey);
+      // Fallback: assume requestId is actually a statusUrl (for direct calls with statusUrl)
+      generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() NO mapping found - treating ${requestId} as statusUrl directly`);
+      const result = await queueOps.getJobStatus(prunaModel, requestId, apiKey);
+      generationLogCollector.log(sessionId, 'pruna-provider', `getJobStatus() Direct poll result: ${result.status}`);
+      generationLogCollector.endSession(sessionId);
+      return result;
+    } catch (error) {
+      generationLogCollector.error(sessionId, 'pruna-provider', `getJobStatus() ERROR: ${error instanceof Error ? error.message : String(error)}`);
+      generationLogCollector.endSession(sessionId);
+      throw error;
+    }
   }
 
   async getJobResult<T = unknown>(model: string, requestId: string): Promise<T> {
     const apiKey = this.validateInit();
     const prunaModel = this.validateModel(model);
+    const sessionId = generationLogCollector.startSession();
+    generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() START - model: ${model}, requestId: ${requestId}`);
 
-    // Look up statusUrl from requestId mapping
-    const statusUrl = getStatusUrlForRequestId(requestId);
-    if (statusUrl) {
-      return queueOps.getJobResult<T>(prunaModel, statusUrl, apiKey);
-    }
+    try {
+      // Check if this is an immediate result (already completed)
+      const responseUrl = getResponseUrlForRequestId(requestId);
+      if (responseUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() FOUND immediate result for ${requestId} - returning url: ${responseUrl.substring(0, 80)}...`);
+        generationLogCollector.endSession(sessionId);
+        // Return the immediate result
+        return { url: responseUrl } as T;
+      }
+
+      // Look up statusUrl from requestId mapping (async job)
+      const statusUrl = getStatusUrlForRequestId(requestId);
+      if (statusUrl) {
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() FOUND async job for ${requestId} - fetching from statusUrl: ${statusUrl.substring(0, 80)}...`);
+        const result = await queueOps.getJobResult<T>(prunaModel, statusUrl, apiKey);
+        generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() Fetch complete`);
+        generationLogCollector.endSession(sessionId);
+        return result;
+      }
 
-    // Fallback: assume requestId is actually a statusUrl (for direct calls with statusUrl)
-    return queueOps.getJobResult<T>(prunaModel, requestId, apiKey);
+      // Fallback: assume requestId is actually a statusUrl (for direct calls with statusUrl)
+      generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() NO mapping found - treating ${requestId} as statusUrl directly`);
+      const result = await queueOps.getJobResult<T>(prunaModel, requestId, apiKey);
+      generationLogCollector.log(sessionId, 'pruna-provider', `getJobResult() Direct fetch complete`);
+      generationLogCollector.endSession(sessionId);
+      return result;
+    } catch (error) {
+      generationLogCollector.error(sessionId, 'pruna-provider', `getJobResult() ERROR: ${error instanceof Error ? error.message : String(error)}`);
+      generationLogCollector.endSession(sessionId);
+      throw error;
+    }
   }
 
   async subscribe<T = unknown>(

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

@@ -16,7 +16,7 @@ const STORE_KEY = "__PRUNA_PROVIDER_REQUESTS__";
 const TIMER_KEY = "__PRUNA_PROVIDER_CLEANUP_TIMER__";
 const REQUEST_ID_KEY = "__PRUNA_PROVIDER_REQUEST_IDS__";
 type RequestStore = Map<string, ActiveRequest>;
-type RequestIdMap = Map<string, { statusUrl: string; model: string }>;
+type RequestIdMap = Map<string, { statusUrl?: string; responseUrl?: string; model: string }>;
 
 const CLEANUP_INTERVAL = 60_000;
 const MAX_REQUEST_AGE = 3_660_000; // 61 min — must exceed max allowed timeout (1 hour)
@@ -151,7 +151,11 @@ function getRequestIdMap(): RequestIdMap {
 }
 
 export function storeRequestIdMapping(requestId: string, statusUrl: string, model: string): void {
-  getRequestIdMap().set(requestId, { statusUrl, model });
+  getRequestIdMap().set(requestId, { statusUrl, model, responseUrl: undefined });
+}
+
+export function storeImmediateResultMapping(requestId: string, responseUrl: string, model: string): void {
+  getRequestIdMap().set(requestId, { statusUrl: undefined, model, responseUrl });
 }
 
 export function getStatusUrlForRequestId(requestId: string): string | undefined {
@@ -159,6 +163,11 @@ export function getStatusUrlForRequestId(requestId: string): string | undefined
   return mapping?.statusUrl;
 }
 
+export function getResponseUrlForRequestId(requestId: string): string | undefined {
+  const mapping = getRequestIdMap().get(requestId);
+  return mapping?.responseUrl;
+}
+
 export function getModelForRequestId(requestId: string): string | undefined {
   const mapping = getRequestIdMap().get(requestId);
   return mapping?.model;