@synsci/cli-darwin-x64 1.1.89 → 1.1.90

package/bin/skills/scientific-schematics/scripts/generate_schematic_ai.py

@@ -81,9 +81,10 @@ def _load_env_file():
 class ScientificSchematicGenerator:
     """Generate scientific schematics using AI with smart iterative refinement.
 
-    Uses Gemini 3 Pro for quality review to determine if regeneration is needed.
-    Multiple passes only occur if the generated schematic doesn't meet the
-    quality threshold for the target document type.
+    Uses Nano Banana Pro (with Nano Banana Standard fallback) for generation
+    and Gemini 3.1 Pro for quality review. Multiple passes only occur if the
+    generated schematic doesn't meet the quality threshold for the target
+    document type.
     """
 
     # Quality thresholds by document type (score out of 10)
@@ -167,11 +168,15 @@ LAYOUT:
         self.verbose = verbose
         self._last_error = None  # Track last error for better reporting
         self.base_url = "https://openrouter.ai/api/v1"
+        # Image generation models in priority order (fallback if primary fails)
         # Nano Banana Pro - Google's advanced image generation model
-        # https://openrouter.ai/google/gemini-3-pro-image-preview
-        self.image_model = "google/gemini-3-pro-image-preview"
-        # Gemini 3 Pro for quality review - excellent vision and reasoning
-        self.review_model = "google/gemini-3-pro"
+        self.image_models = [
+            "google/gemini-3-pro-image-preview",  # Nano Banana Pro (best quality)
+            "google/gemini-2.5-flash-image",       # Nano Banana Standard (fallback)
+        ]
+        self.image_model = self.image_models[0]
+        # Gemini 3.1 Pro for quality review - excellent vision and reasoning
+        self.review_model = "google/gemini-3.1-pro-preview"
 
     def _log(self, message: str):
         """Log message if verbose mode is enabled."""
@@ -336,76 +341,99 @@ LAYOUT:
         base64_data = base64.b64encode(image_data).decode("utf-8")
         return f"data:{mime_type};base64,{base64_data}"
 
-    def generate_image(self, prompt: str) -> Optional[bytes]:
-        """
-        Generate an image using Nano Banana Pro.
-
-        Args:
-            prompt: Description of the diagram to generate
-
-        Returns:
-            Image bytes or None if generation failed
-        """
-        self._last_error = None  # Reset error
-
-        messages = [{"role": "user", "content": prompt}]
+    def _diagnose_response(self, response: Dict[str, Any], model: str):
+        """Print diagnostic info when image extraction fails."""
+        print(f"  [diagnostic] Model: {model}")
+        if "error" in response:
+            print(f"  [diagnostic] API error: {response['error']}")
+        if "choices" in response and response["choices"]:
+            msg = response["choices"][0].get("message", {})
+            print(f"  [diagnostic] Message keys: {list(msg.keys())}")
+            finish = response["choices"][0].get("finish_reason", "unknown")
+            print(f"  [diagnostic] Finish reason: {finish}")
+            content = msg.get("content", "")
+            if isinstance(content, str):
+                preview = content[:300] + "..." if len(content) > 300 else content
+                if preview:
+                    print(f"  [diagnostic] Content: {preview}")
+            elif isinstance(content, list):
+                print(f"  [diagnostic] Content is list with {len(content)} items:")
+                for i, item in enumerate(content[:5]):
+                    if isinstance(item, dict):
+                        print(f"    Item {i}: type={item.get('type')}, keys={list(item.keys())}")
+            images = msg.get("images", [])
+            if images:
+                print(f"  [diagnostic] Images field: {len(images)} items")
+            reasoning = msg.get("reasoning", "")
+            if reasoning:
+                preview = reasoning[:200] + "..." if len(reasoning) > 200 else reasoning
+                print(f"  [diagnostic] Reasoning: {preview}")
+        else:
+            print(f"  [diagnostic] Response keys: {list(response.keys())}")
+            # Show raw response preview (truncated)
+            raw = json.dumps(response)[:500]
+            print(f"  [diagnostic] Raw response: {raw}")
 
+    def _try_generate_with_model(self, model: str, messages: List[Dict[str, Any]]) -> Optional[bytes]:
+        """Try to generate an image with a specific model. Returns image bytes or None."""
         try:
-            response = self._make_request(model=self.image_model, messages=messages, modalities=["image", "text"])
+            response = self._make_request(model=model, messages=messages, modalities=["image", "text"])
 
-            # Debug: print response structure if verbose
-            if self.verbose:
-                self._log(f"Response keys: {response.keys()}")
-                if "error" in response:
-                    self._log(f"API Error: {response['error']}")
-                if "choices" in response and response["choices"]:
-                    msg = response["choices"][0].get("message", {})
-                    self._log(f"Message keys: {msg.keys()}")
-                    # Show content preview without printing huge base64 data
-                    content = msg.get("content", "")
-                    if isinstance(content, str):
-                        preview = content[:200] + "..." if len(content) > 200 else content
-                        self._log(f"Content preview: {preview}")
-                    elif isinstance(content, list):
-                        self._log(f"Content is list with {len(content)} items")
-                        for i, item in enumerate(content[:3]):
-                            if isinstance(item, dict):
-                                self._log(f"  Item {i}: type={item.get('type')}")
-
-            # Check for API errors in response
+            # Check for API errors in response body
             if "error" in response:
                 error_msg = response["error"]
                 if isinstance(error_msg, dict):
                     error_msg = error_msg.get("message", str(error_msg))
-                self._last_error = f"API Error: {error_msg}"
-                print(f"✗ {self._last_error}")
+                print(f"  ✗ {model}: API error — {error_msg}")
                 return None
 
             image_data = self._extract_image_from_response(response)
             if image_data:
-                self._log(f"✓ Generated image ({len(image_data)} bytes)")
-            else:
-                self._last_error = "No image data in API response - model may not support image generation"
-                self._log(f"✗ {self._last_error}")
-                # Additional debug info when image extraction fails
-                if self.verbose and "choices" in response:
-                    msg = response["choices"][0].get("message", {})
-                    self._log(f"Full message structure: {json.dumps({k: type(v).__name__ for k, v in msg.items()})}")
-
-            return image_data
+                self._log(f"✓ Generated image with {model} ({len(image_data)} bytes)")
+                return image_data
+
+            # Image extraction failed — print diagnostics
+            print(f"  ✗ {model}: No image data in response")
+            self._diagnose_response(response, model)
+            return None
+
         except RuntimeError as e:
-            self._last_error = str(e)
-            self._log(f"✗ Generation failed: {self._last_error}")
+            print(f"  ✗ {model}: {str(e)}")
             return None
         except Exception as e:
-            self._last_error = f"Unexpected error: {str(e)}"
-            self._log(f"✗ Generation failed: {self._last_error}")
-            import traceback
-
+            print(f"  ✗ {model}: Unexpected error — {str(e)}")
             if self.verbose:
+                import traceback
                 traceback.print_exc()
             return None
 
+    def generate_image(self, prompt: str) -> Optional[bytes]:
+        """
+        Generate an image using available image models with automatic fallback.
+
+        Tries each model in priority order. If the primary model fails or returns
+        no image data, falls back to the next model.
+
+        Args:
+            prompt: Description of the diagram to generate
+
+        Returns:
+            Image bytes or None if all models failed
+        """
+        self._last_error = None
+
+        messages = [{"role": "user", "content": prompt}]
+
+        for model in self.image_models:
+            self._log(f"Trying {model}...")
+            image_data = self._try_generate_with_model(model, messages)
+            if image_data:
+                self.image_model = model  # Track which model succeeded
+                return image_data
+
+        self._last_error = f"All image models failed: {', '.join(self.image_models)}"
+        return None
+
     def review_image(
         self, image_path: str, original_prompt: str, iteration: int, doc_type: str = "default", max_iterations: int = 2
     ) -> Tuple[str, float, bool]:
@@ -625,6 +653,8 @@ Generate a publication-quality scientific diagram that meets all the guidelines
         print(f"Document Type: {doc_type}")
         print(f"Quality Threshold: {threshold}/10")
         print(f"Max Iterations: {iterations}")
+        print(f"Image Models: {' → '.join(self.image_models)}")
+        print(f"Review Model: {self.review_model}")
         print(f"Output: {output_path}")
         print(f"{'=' * 60}\n")
 
@@ -649,7 +679,7 @@ Generate a publication-quality scientific diagram that meets all the guidelines
             print(f"✓ Saved: {iter_path}")
 
             # Review image using Gemini 3 Pro
-            print("Reviewing image with Gemini 3 Pro...")
+            print(f"Reviewing image with {self.review_model}...")
             critique, score, needs_improvement = self.review_image(str(iter_path), user_prompt, i, doc_type, iterations)
             print(f"✓ Score: {score}/10 (threshold: {threshold}/10)")
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synsci/cli-darwin-x64",
-  "version": "1.1.89",
+  "version": "1.1.90",
   "os": [
     "darwin"
   ],