fix responses api issue

README.md

@@ -15,10 +15,51 @@ license: gpl-3.0
 
 An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
 
-# development
+## Run locally
+
+Environment variables:
+
+- `OPENAI_API_KEY` (required for comparisons)
+- `LOGIN_PASSWORD` (required to access the UI; username is `bnh`)
+- `OVERRIDE_HEADER` (optional header for B&H API calls)
+- `LOG_LEVEL` (optional; default `INFO`, set to `DEBUG` for verbose logs)
+
+Commands:
+
+```bash
+cd ~/repos/demo
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+
+# Set your environment variables
+export OPENAI_API_KEY=sk-...
+export LOGIN_PASSWORD=your-password
+export LOG_LEVEL=DEBUG
+
+# Run the app
+python app.py
+```
+
+The app will start at `http://127.0.0.1:7860`. Log in with username `bnh` and your `LOGIN_PASSWORD`.
+
+## Troubleshooting
+
+- Full tracebacks are surfaced in the UI if an error occurs during comparison.
+- The console also shows rich tracebacks and structured logs. Increase verbosity with `LOG_LEVEL=DEBUG`.
+- Common issues:
+	- Missing `OPENAI_API_KEY` → the app will raise a clear error indicating it is not set.
+	- Invalid SKU input → the app requires numeric SKUs and will show a validation error.
+	- Network issues to B&H or OpenAI → retries are limited; check connectivity and try again.
+
+## Dev helpers
+
+Quick smoke tests without launching the server:
+
 ```bash
-cd ~/repos/huggingface
-code .
-source .env
-hf upload bandh-webops/demo ./ --exclude '.*'
+# Validate OpenAI missing-key error path
+python scripts/test_openai_error.py
+
+# Show UI-layer traceback formatting using an invalid SKU
+python scripts/smoke_test.py
 ```

app.py

@@ -1,14 +1,28 @@
 import os
 import json
 import http.client
+import logging
 import traceback
-import re
 import gradio as gr
 
 from dotenv import load_dotenv
 from openai import OpenAI
-from pydantic import BaseModel, Field
+import openai
+from pydantic import BaseModel, Field, ValidationError
 from typing import List, Literal, Dict, Any
+from rich.traceback import install as install_rich_traceback
+
+
+# Enable rich tracebacks in the console for better debugging
+install_rich_traceback(show_locals=True)
+
+# Basic logging configuration
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL, logging.INFO),
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+)
+logger = logging.getLogger(__name__)
 
 
 # Define the Pydantic model for camera specifications with free-form specs
@@ -25,7 +39,7 @@ class SimpleComparisonSummary(BaseModel):
 # Initialize the OpenAI client
 # Make sure you have the OPENAI_API_KEY environment variable set or pass it directly
 load_dotenv()
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"), timeout=60.0, max_retries=2)
 override_header = os.getenv("OVERRIDE_HEADER")
 login_password = os.getenv("LOGIN_PASSWORD")
 
@@ -47,9 +61,9 @@ def compare_cameras(model_name: str, prompt: str, camera1_specs: CameraSpecs, ca
 
     # Map verbosity and reasoning level to Responses API parameters
     verbosity_map = {
-        "Low": (600, "Keep the response concise and focused on essentials."),
-        "Medium": (1200, "Provide a balanced level of detail."),
-        "High": (2000, "Be thorough and include more detail and nuance."),
+        "Low": (1200, "Keep the response concise and focused on essentials."),
+        "Medium": (2400, "Provide a balanced level of detail."),
+        "High": (3600, "Be thorough and include more detail and nuance."),
     }
     max_tokens, verbosity_hint = verbosity_map.get(verbosity, (600, "Keep the response concise."))
 
@@ -57,101 +71,182 @@ def compare_cameras(model_name: str, prompt: str, camera1_specs: CameraSpecs, ca
     reasoning_effort = reasoning_map.get(reasoning_level, "low")
 
     try:
-        response = client.responses.create(
-            model=model_name,
-            input=[
-                {"role": "system", "content": [{"type": "text", "text": "You are a helpful assistant that compares camera specifications and outputs JSON. " + verbosity_hint}]},
-                {"role": "user", "content": [{"type": "text", "text": prompt}]},
-            ],
-            response_format={
-                "type": "json_schema",
-                "json_schema": {
-                    "name": "SimpleComparisonSummary",
-                    "schema": SimpleComparisonSummary.model_json_schema(),
-                    "strict": True,
-                },
-            },
-            max_output_tokens=max_tokens,
-            reasoning={"effort": reasoning_effort},
-        )
-
+        if not os.getenv("OPENAI_API_KEY"):
+            raise RuntimeError("OPENAI_API_KEY is not set. Please set it in your environment or .env file.")
+        logger.debug("Preparing request to OpenAI: model=%s, verbosity=%s, reasoning=%s", model_name, verbosity, reasoning_level)
+
+        # Responses API - use parse helper with Pydantic response_format (modern SDKs)
+        def supports_reasoning_param(model: str) -> bool:
+            name = (model or "").lower()
+            # Heuristic: known reasoning families and names often disallow temperature but allow `reasoning`
+            return any(key in name for key in ["o3", "o4", "reasoning", "gpt-5"])  # keep heuristic broad
+
+        def supports_temperature_param(model: str) -> bool:
+            name = (model or "").lower()
+            # Heuristic: avoid temperature for explicit reasoning models
+            if supports_reasoning_param(name):
+                return False
+            # Otherwise allow temperature by default
+            return True
+
+        def build_params(max_toks: int) -> Dict[str, Any]:
+            params: Dict[str, Any] = {
+                "model": model_name,
+                "instructions": "You are a helpful assistant that compares camera specifications and outputs JSON. " + verbosity_hint,
+                "input": [
+                    {"role": "user", "content": [{"type": "input_text", "text": prompt}]},
+                ],
+                "text_format": SimpleComparisonSummary,
+                "max_output_tokens": max_toks,
+            }
+            if supports_reasoning_param(model_name):
+                params["reasoning"] = {"effort": reasoning_effort}
+            if supports_temperature_param(model_name):
+                params["temperature"] = 0.0
+            return params
+
+        def do_parse(max_toks: int):
+            params = build_params(max_toks)
+            try:
+                return client.responses.parse(**params)
+            except openai.APIStatusError as e:
+                # Retry automatically if server reports unsupported parameters
+                msg = (getattr(e, "response", None) and getattr(e.response, "json", lambda: {})()) or {}
+                err_msg = None
+                try:
+                    err_msg = (msg or {}).get("error", {}).get("message")
+                except Exception:
+                    err_msg = None
+
+                # Fallback: inspect exception text
+                err_text = str(e)
+                def mentions(word: str) -> bool:
+                    return (err_msg and word in err_msg) or (word in err_text)
+
+                mutated = False
+                if "temperature" in params and (mentions("temperature") and mentions("Unsupported parameter")):
+                    logger.info("Model %s does not support temperature; retrying without it", model_name)
+                    params.pop("temperature", None)
+                    mutated = True
+                if "reasoning" in params and (mentions("reasoning") and mentions("Unsupported parameter")):
+                    logger.info("Model %s does not support reasoning param; retrying without it", model_name)
+                    params.pop("reasoning", None)
+                    mutated = True
+
+                if mutated:
+                    return client.responses.parse(**params)
+                raise
+
+        # First attempt
         try:
-            json_text = response.output_text  # type: ignore
+            response = do_parse(max_tokens)
+        except ValidationError:
+            # Likely truncated/invalid JSON; retry once with a higher token cap
+            logger.warning("ValidationError parsing JSON; retrying with higher max_output_tokens")
+            response = do_parse(max(4096, max_tokens * 2))
+
+        logger.debug("Received response from OpenAI (Responses API parse)")
+        # Try to extract parsed object from any output content part
+        parsed_obj = None
+        try:
+            outputs = getattr(response, "output", [])
+            for item in outputs or []:
+                content = getattr(item, "content", None)
+                if not content:
+                    continue
+                for part in content:
+                    p = getattr(part, "parsed", None)
+                    if p is not None:
+                        parsed_obj = p
+                        break
+                if parsed_obj is not None:
+                    break
         except Exception:
-            # Fallback to explicit path
-            json_text = response.output[0].content[0].text  # type: ignore
-
-        summary_data = json.loads(json_text)
-        return SimpleComparisonSummary(**summary_data)
-    except Exception as e:
-        # Let the GUI render the detailed error, but keep a concise log here
-        print(f"OpenAI comparison error: {e}")
+            logger.debug("Direct parsed extraction failed; will try alternative access paths.")
+
+        if isinstance(parsed_obj, SimpleComparisonSummary):
+            return parsed_obj
+        if isinstance(parsed_obj, dict):
+            return SimpleComparisonSummary(**parsed_obj)
+
+        # Fallback: parse from output_text if available
+        output_text = getattr(response, "output_text", None)
+        if isinstance(output_text, str) and output_text.strip():
+            try:
+                summary_data = json.loads(output_text)
+                return SimpleComparisonSummary(**summary_data)
+            except Exception:
+                logger.exception("Failed to parse output_text as JSON for SimpleComparisonSummary")
+
+        raise RuntimeError("Failed to extract parsed JSON from OpenAI response.")
+    except Exception:
+        logger.exception("Error while comparing cameras via OpenAI API")
+        # Re-raise so the UI layer can display full traceback
         raise
 
-def _normalize_sku(raw: str) -> str:
-    """Extract only digits from a SKU like '1394217-REG' -> '1394217'."""
-    sku = re.sub(r"\D", "", str(raw or "").strip())
-    if not sku:
-        raise ValueError("SKU must contain digits; e.g., '1394217' or '1394217-REG'.")
-    return sku
-
-
-def load_specs_data(sku_no):
-    conn = http.client.HTTPSConnection("www.bhphotovideo.com")
+def load_specs_data(sku_no: str) -> bytes:
+  if not sku_no or not str(sku_no).strip().isdigit():
+      raise ValueError(f"Invalid SKU '{sku_no}'. Please enter a numeric SKU.")
 
-    # Many users paste SKUs like '1394217-REG'. Keep only digits and send numeric skuNo.
-    normalized = _normalize_sku(sku_no)
-    payload_obj = {
-            "params": {
-                    "itemList": [{"skuNo": int(normalized), "itemSource": "REG"}],
-                    "channels": ["specifications", "priceInfo"],
-            }
-    }
-    payload = json.dumps(payload_obj)
+  conn = http.client.HTTPSConnection("www.bhphotovideo.com", timeout=15)
 
-    headers = {
-            'accept': "application/json, text/plain, */*",
-            'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36",
-            'Content-Type': "application/json",
-            'x-waf-known': override_header
-            }
+  payload = (
+      "{\"params\":{\"itemList\":[{\"skuNo\":" + str(sku_no) + ",\"itemSource\":\"REG\"}],\"channels\":[\"specifications\", \"priceInfo\"]}}"
+  )
 
-    conn.request("POST", "/api/item/p/product-details?from=cli&aperture=1&cliReqId=d8b489d2-125a-46e0-94c9-0d731d9601fd-cli-11", payload, headers)
-    res = conn.getresponse()
-    data = res.read()
-    if res.status != 200:
-        # Surface HTTP errors to the UI with a helpful snippet of the body
-        try:
-            snippet = data.decode("utf-8", "ignore")[:500]
-        except Exception:
-            snippet = "<binary body>"
-        raise RuntimeError(f"B&H API request failed: HTTP {res.status} {res.reason}. Body: {snippet}")
-    return data
-
-def extract_group_details(data):
-  data_dict = json.loads(data)
-
-  groups_data = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('groups', [])
-  short_description = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('core', {}).get('shortDescription')
-  details_url = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('core', {}).get('detailsUrl')
-  main_image_url = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('mainImage', {}).get('listing', {}).get('url')
-  price = data_dict.get('data', [{}])[0].get('priceInfo', {}).get('items', [{}])[0].get('price', {}).get('price')
-
-  groups_data.append({"price" : price});
-
-
-  # Create a dictionary with the extracted data
-  extracted_data = {
-      "model": short_description,
-      "price": price,
-      "details_url": details_url,
-      "main_image_url": main_image_url,
-      "details_url": details_url,
-      "main_image_url": main_image_url,
-      "specs": groups_data
+  headers = {
+      'accept': "application/json, text/plain, */*",
+      'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36",
+      'Content-Type': "application/json",
   }
+  # Only include this optional header if provided
+  if override_header:
+      headers['x-waf-known'] = override_header
+
+  try:
+      conn.request(
+          "POST",
+          "/api/item/p/product-details?from=cli&aperture=1&cliReqId=d8b489d2-125a-46e0-94c9-0d731d9601fd-cli-11",
+          payload,
+          headers,
+      )
+      res = conn.getresponse()
+      status = res.status
+      data = res.read()
+      logger.debug("B&H response status=%s, %s bytes", status, len(data) if data else 0)
+      if status < 200 or status >= 300:
+          preview = (data[:500] if data else b"").decode("utf-8", errors="ignore")
+          raise RuntimeError(f"B&H API returned HTTP {status}. Body preview: {preview}")
+      return data
+  except Exception:
+      logger.exception("Failed to load specs for SKU %s", sku_no)
+      raise
+
+def extract_group_details(data: bytes):
+    try:
+        data_dict = json.loads(data)
+    except Exception:
+        logger.exception("Failed to parse JSON from B&H response")
+        raise
+
+    groups_data = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('groups', [])
+    short_description = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('core', {}).get('shortDescription')
+    details_url = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('core', {}).get('detailsUrl')
+    main_image_url = data_dict.get('data', [{}])[0].get('specifications', {}).get('items', [{}])[0].get('item', {}).get('mainImage', {}).get('listing', {}).get('url')
+    price = data_dict.get('data', [{}])[0].get('priceInfo', {}).get('items', [{}])[0].get('price', {}).get('price')
+
+    groups_data.append({"price": price})
+
+    # Create a dictionary with the extracted data
+    extracted_data = {
+        "model": short_description,
+        "price": price,
+        "details_url": details_url,
+        "main_image_url": main_image_url,
+        "specs": groups_data,
+    }
 
-  return extracted_data
+    return extracted_data
 
 
 model_list = ["gpt-5-nano", "gpt-5-mini", "gpt-5"]
@@ -173,9 +268,9 @@ Maintain the prescribed section order: Which Is Right for You, Main Differences,
 def compare_cameras_gui(model_name, verbosity, reasoning_level, prompt, sku1, sku2):
     """
     Gradio interface function to compare cameras based on SKU numbers and model name.
-    Shows detailed error output (message + traceback) in the Markdown output on failure.
     """
     try:
+        logger.info("Fetching product specs for SKUs: %s, %s", sku1, sku2)
         data_a = load_specs_data(sku1)
         data_b = load_specs_data(sku2)
 
@@ -187,34 +282,20 @@ def compare_cameras_gui(model_name, verbosity, reasoning_level, prompt, sku1, sk
 
         summary = compare_cameras(model_name, prompt, camera_a, camera_b, verbosity=verbosity, reasoning_level=reasoning_level)
 
-        # If we got here, summary should be a model object
+        # Format the output for display in Gradio using more standard markdown syntax
         output_text = f"""
 ## Product Comparison Summary
 {summary.summary}
 """
         return output_text
-
-    except Exception as e:
-        # Return rich debugging information directly to the Markdown output
-        tb = traceback.format_exc()
-        try:
-            s1 = _normalize_sku(sku1)
-        except Exception:
-            s1 = str(sku1)
-        try:
-            s2 = _normalize_sku(sku2)
-        except Exception:
-            s2 = str(sku2)
-        helpful_hint = (
-            "Tip: Enter SKUs with or without '-REG' (e.g., '1394217-REG' or '1394217'). "
-            "We automatically normalize to digits: "
-            f"'{s1}' and '{s2}'."
-        )
+    except Exception:
+        # Surface full traceback in the UI for easier debugging
+        err = traceback.format_exc()
+        logger.error("An error occurred during comparison. Returning traceback to UI.\n%s", err)
         return (
-            f"### Error\n"
-            f"- Message: {e}\n\n"
-            f"{helpful_hint}\n\n"
-            f"<details><summary>Traceback</summary>\n\n````text\n{tb}\n````\n\n</details>"
+            "Encountered an error while generating the comparison. "
+            "Here is the full traceback to help diagnose the issue:\n\n"
+            f"```text\n{err}\n```"
         )
 
 
@@ -270,5 +351,4 @@ if __name__ == "__main__":
     # Launch the interface
     # Disable Gradio's experimental SSR to avoid svelte-i18n initial locale errors in server-side rendering
     # Also hide the "Use via API" link explicitly
-    # show_error=True will also display a toast with the message, in addition to our Markdown output.
-    demo.launch(auth=authenticate, share=False, ssr_mode=False, show_api=False, show_error=True)
+    demo.launch(auth=authenticate, share=False, ssr_mode=False, show_api=False)

requirements-dev.txt

@@ -52,7 +52,7 @@ numpy==1.24.4 ; python_full_version < '3.9'
 numpy==2.0.2 ; python_full_version == '3.9.*'
 numpy==2.2.6 ; python_full_version == '3.10.*'
 numpy==2.3.2 ; python_full_version >= '3.11'
-openai==1.100.2
+openai>=1.100.2,<2
 orjson==3.10.15 ; python_full_version < '3.9'
 orjson==3.11.2 ; python_full_version >= '3.9'
 packaging==25.0

requirements.txt

@@ -160,7 +160,7 @@ numpy==2.3.2 ; python_full_version >= '3.11'
     # via
     #   gradio
     #   pandas
-openai==1.100.2
+openai>=1.100.2,<2
     # via huggingface
 orjson==3.10.15 ; python_full_version < '3.9'
     # via gradio

scripts/smoke_test.py

@@ -0,0 +1,8 @@
+import os
+os.environ.setdefault("LOG_LEVEL", "DEBUG")
+
+from app import compare_cameras_gui
+
+# Force an error by passing an invalid SKU
+result = compare_cameras_gui("gpt-5-nano", "Low", "Minimal", "test", "abc", "123")
+print(result)

scripts/test_openai_error.py

@@ -0,0 +1,15 @@
+import os
+from app import CameraSpecs, compare_cameras
+
+# Ensure no API key to force the error path
+os.environ.pop("OPENAI_API_KEY", None)
+
+cam_a = CameraSpecs(model="Test A", specs=[{"key": "value"}])
+cam_b = CameraSpecs(model="Test B", specs=[{"key": "value"}])
+
+try:
+    compare_cameras("gpt-5-nano", "Test prompt", cam_a, cam_b)
+except Exception as e:
+    import traceback
+    print("Captured exception from compare_cameras; full traceback below:\n")
+    print(traceback.format_exc())