@umituz/react-native-ai-generation-content 1.0.6 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.0.6",
+  "version": "1.2.0",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/infrastructure/services/generation-orchestrator.service.ts

@@ -30,6 +30,13 @@ class GenerationOrchestratorService {
   private config: OrchestratorConfig = {};
 
   configure(config: OrchestratorConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] configure() called", {
+        hasPollingConfig: !!config.polling,
+        hasStatusUpdate: !!config.onStatusUpdate,
+      });
+    }
     this.config = { ...this.config, ...config };
   }
 
@@ -40,6 +47,15 @@ class GenerationOrchestratorService {
     const progressTracker = createProgressTracker();
     const startTime = Date.now();
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] Generate started:", {
+        model: request.model,
+        capability: request.capability,
+        provider: provider.providerId,
+      });
+    }
+
     const updateProgress = (
       stage: GenerationProgress["stage"],
       subProgress = 0,
@@ -60,7 +76,10 @@ class GenerationOrchestratorService {
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         // eslint-disable-next-line no-console
-        console.log("[Orchestrator] Job submitted:", submission.requestId);
+        console.log("[Orchestrator] Job submitted:", {
+          requestId: submission.requestId,
+          provider: provider.providerId,
+        });
       }
 
       updateProgress("generating");
@@ -74,6 +93,17 @@ class GenerationOrchestratorService {
 
       updateProgress("completed");
 
+      const duration = Date.now() - startTime;
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[Orchestrator] Generate completed:", {
+          requestId: submission.requestId,
+          duration: `${duration}ms`,
+          success: true,
+        });
+      }
+
       return {
         success: true,
         data: result,
@@ -84,7 +114,7 @@ class GenerationOrchestratorService {
           capability: request.capability,
           startTime,
           endTime: Date.now(),
-          duration: Date.now() - startTime,
+          duration,
         },
       };
     } catch (error) {
@@ -116,6 +146,15 @@ class GenerationOrchestratorService {
     requestId: string,
     onProgress?: (progress: GenerationProgress) => void,
   ): Promise<T> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] pollForResult() started", {
+        provider: provider.providerId,
+        model,
+        requestId,
+      });
+    }
+
     const config = {
       ...DEFAULT_POLLING_CONFIG,
       ...this.config.polling,
@@ -126,6 +165,14 @@ class GenerationOrchestratorService {
     for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
       await createPollingDelay(attempt, config);
 
+      if (typeof __DEV__ !== "undefined" && __DEV__ && attempt % 5 === 0) {
+        // eslint-disable-next-line no-console
+        console.log("[Orchestrator] pollForResult() attempt", {
+          attempt,
+          maxAttempts: config.maxAttempts,
+        });
+      }
+
       try {
         const status = await provider.getJobStatus(model, requestId);
 
@@ -134,6 +181,13 @@ class GenerationOrchestratorService {
         this.updateProgressFromStatus(status, attempt, config, onProgress);
 
         if (status.status === "COMPLETED") {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            // eslint-disable-next-line no-console
+            console.log("[Orchestrator] pollForResult() job COMPLETED", {
+              requestId,
+              attempt,
+            });
+          }
           return provider.getJobResult<T>(model, requestId);
         }
 
@@ -191,20 +245,41 @@ class GenerationOrchestratorService {
   }
 
   private getProvider(): IAIProvider {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] getProvider() called");
+    }
+
     const provider = providerRegistry.getActiveProvider();
 
     if (!provider) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Orchestrator] No active provider found!");
+      }
       throw new Error(
         "No active AI provider. Register and set a provider first.",
       );
     }
 
     if (!provider.isInitialized()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Orchestrator] Provider not initialized:", provider.providerId);
+      }
       throw new Error(
         `Provider ${provider.providerId} is not initialized.`,
       );
     }
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Orchestrator] getProvider() returning:", {
+        providerId: provider.providerId,
+        isInitialized: provider.isInitialized(),
+      });
+    }
+
     return provider;
   }
 }

package/src/infrastructure/services/provider-registry.service.ts

@@ -52,10 +52,33 @@ class ProviderRegistry {
   }
 
   getActiveProvider(): IAIProvider | null {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ProviderRegistry] getActiveProvider() called", {
+        activeProviderId: this.activeProviderId,
+        registeredProviders: Array.from(this.providers.keys()),
+      });
+    }
+
     if (!this.activeProviderId) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.warn("[ProviderRegistry] No active provider set!");
+      }
       return null;
     }
-    return this.providers.get(this.activeProviderId) ?? null;
+
+    const provider = this.providers.get(this.activeProviderId) ?? null;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ProviderRegistry] getActiveProvider() returning", {
+        providerId: provider?.providerId,
+        isInitialized: provider?.isInitialized(),
+      });
+    }
+
+    return provider;
   }
 
   getProvider(providerId: string): IAIProvider | null {

package/src/infrastructure/utils/error-classifier.util.ts

@@ -5,6 +5,8 @@
 
 import { AIErrorType, type AIErrorInfo } from "../../domain/entities";
 
+declare const __DEV__: boolean;
+
 const NETWORK_ERROR_PATTERNS = [
   "network",
   "timeout",
@@ -60,18 +62,38 @@ function getStatusCode(error: unknown): number | undefined {
   return undefined;
 }
 
+function logClassification(info: AIErrorInfo): AIErrorInfo {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[ErrorClassifier] Classified as:", {
+      type: info.type,
+      messageKey: info.messageKey,
+      retryable: info.retryable,
+    });
+  }
+  return info;
+}
+
 export function classifyError(error: unknown): AIErrorInfo {
   const message = error instanceof Error ? error.message : String(error);
   const statusCode = getStatusCode(error);
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[ErrorClassifier] Classifying error:", {
+      message: message.slice(0, 100),
+      statusCode,
+    });
+  }
+
   if (statusCode === 429 || matchesPatterns(message, RATE_LIMIT_PATTERNS)) {
-    return {
+    return logClassification({
       type: AIErrorType.RATE_LIMIT,
       messageKey: "error.rateLimit",
       retryable: true,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
   if (
@@ -79,65 +101,65 @@ export function classifyError(error: unknown): AIErrorInfo {
     statusCode === 403 ||
     matchesPatterns(message, AUTH_ERROR_PATTERNS)
   ) {
-    return {
+    return logClassification({
       type: AIErrorType.AUTHENTICATION,
       messageKey: "error.authentication",
       retryable: false,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
   if (matchesPatterns(message, CONTENT_POLICY_PATTERNS)) {
-    return {
+    return logClassification({
       type: AIErrorType.CONTENT_POLICY,
       messageKey: "error.contentPolicy",
       retryable: false,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
   if (matchesPatterns(message, NETWORK_ERROR_PATTERNS)) {
-    return {
+    return logClassification({
       type: AIErrorType.NETWORK,
       messageKey: "error.network",
       retryable: true,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
   if (
     (statusCode && statusCode >= 500) ||
     matchesPatterns(message, SERVER_ERROR_PATTERNS)
   ) {
-    return {
+    return logClassification({
       type: AIErrorType.SERVER,
       messageKey: "error.server",
       retryable: true,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
   if (message.toLowerCase().includes("timeout")) {
-    return {
+    return logClassification({
       type: AIErrorType.TIMEOUT,
       messageKey: "error.timeout",
       retryable: true,
       originalError: error,
       statusCode,
-    };
+    });
   }
 
-  return {
+  return logClassification({
     type: AIErrorType.UNKNOWN,
     messageKey: "error.unknown",
     retryable: false,
     originalError: error,
     statusCode,
-  };
+  });
 }
 
 export function isTransientError(error: unknown): boolean {

package/src/infrastructure/utils/result-validator.util.ts

@@ -3,6 +3,8 @@
  * Validates AI generation job results
  */
 
+declare const __DEV__: boolean;
+
 export interface ResultValidation {
   isValid: boolean;
   hasError: boolean;
@@ -98,12 +100,24 @@ export function validateResult(
   const hasError =
     hasInternalServerError || (isEmpty && !hasOutput && !allowEmpty);
 
-  return {
+  const validation: ResultValidation = {
     isValid: !hasError && (hasOutput || allowEmpty),
     hasError,
     errorMessage: hasError && errorValue ? String(errorValue) : undefined,
     hasOutput,
   };
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[ResultValidator] Validation result:", {
+      isValid: validation.isValid,
+      hasOutput: validation.hasOutput,
+      hasError: validation.hasError,
+      checkedFields: outputFields.join(", "),
+    });
+  }
+
+  return validation;
 }
 
 /**