Update app.py

app.py

@@ -353,45 +353,55 @@ def build_knowledge_base(
     return status, kb
 
 
-def normalize_openai_content(raw_content: Any) -> str:
+def extract_text_from_response(resp: Any) -> str:
     """
-    Normalize OpenAI message.content into a plain string.
-    Handles cases where content is:
-    - string
-    - list of parts (with .text or ['text'])
-    - dict
-    - None
+    Extract plain text from the Responses API result.
+    We assume structure like:
+        resp.output -> list of output items
+        each item.content -> list of content parts with .text or ['text']
     """
-    if raw_content is None:
+    if resp is None:
         return ""
 
-    # Simple string
-    if isinstance(raw_content, str):
-        return raw_content.strip()
-
-    # List of parts
-    if isinstance(raw_content, list):
-        parts: List[str] = []
-        for p in raw_content:
-            text_piece = ""
-            if isinstance(p, dict):
-                text_piece = p.get("text") or ""
-            else:
-                # object with .text or fallback to str
-                text_piece = getattr(p, "text", "") or ""
-            if not text_piece:
-                text_piece = str(p)
-            parts.append(text_piece)
-        return "\n".join(parts).strip()
+    texts: List[str] = []
+
+    # New Responses API usually has resp.output
+    output = getattr(resp, "output", None) or getattr(resp, "data", None)
+    if output is None:
+        # Fallback to just stringifying
+        return str(resp)
+
+    if not isinstance(output, (list, tuple)):
+        output = [output]
 
-    # Dict or something else: best-effort stringify
-    if isinstance(raw_content, dict):
-        text_piece = raw_content.get("text")
-        if isinstance(text_piece, str):
-            return text_piece.strip()
-        return str(raw_content)
+    for item in output:
+        content = getattr(item, "content", None)
+        if content is None and isinstance(item, dict):
+            content = item.get("content")
+        if content is None:
+            continue
+
+        if not isinstance(content, (list, tuple)):
+            content = [content]
+
+        for part in content:
+            # Part might be object with .text
+            txt = getattr(part, "text", None)
+            if isinstance(txt, str) and txt.strip():
+                texts.append(txt)
+                continue
 
-    return str(raw_content).strip()
+            # Or dict-like
+            if isinstance(part, dict):
+                t = part.get("text")
+                if isinstance(t, str) and t.strip():
+                    texts.append(t)
+                    continue
+
+            # Fallback, stringify
+            texts.append(str(part))
+
+    return "\n".join(texts).strip()
 
 
 def chat_with_rag(
@@ -403,7 +413,7 @@ def chat_with_rag(
 ):
     """
     history_pairs: list of [user_str, assistant_str] pairs for the UI Chatbot.
-    We'll rebuild OpenAI messages from this each time.
+    We'll rebuild conversation history for the Responses API each time.
     """
     user_message = (user_message or "").strip()
     api_key = (api_key or "").strip()
@@ -423,15 +433,20 @@ def chat_with_rag(
 
     client = OpenAI(api_key=api_key)
 
-    # Assemble messages for OpenAI
-    messages: List[Dict[str, str]] = []
+    # Build input for Responses API
+    input_messages: List[Dict[str, Any]] = []
 
     combined_system = (
         DEFAULT_SYSTEM_PROMPT.strip()
         + "\n\n---\n\nUser System Instructions:\n"
         + system_prompt.strip()
     )
-    messages.append({"role": "system", "content": combined_system})
+    input_messages.append(
+        {
+            "role": "system",
+            "content": [{"type": "input_text", "text": combined_system}],
+        }
+    )
 
     if context:
         context_block = (
@@ -440,28 +455,47 @@ def chat_with_rag(
             "If the answer is not supported by the context, say you don’t know.\n\n"
             f"{context}"
         )
-        messages.append({"role": "system", "content": context_block})
+        input_messages.append(
+            {
+                "role": "system",
+                "content": [{"type": "input_text", "text": context_block}],
+            }
+        )
 
     # Rebuild conversation history from pairs (last few turns)
     recent_pairs = history_pairs[-5:] if history_pairs else []
     for u, a in recent_pairs:
-        messages.append({"role": "user", "content": u})
-        messages.append({"role": "assistant", "content": a})
+        input_messages.append(
+            {
+                "role": "user",
+                "content": [{"type": "input_text", "text": u}],
+            }
+        )
+        input_messages.append(
+            {
+                "role": "assistant",
+                "content": [{"type": "output_text", "text": a}],
+            }
+        )
 
     # Current user message
-    messages.append({"role": "user", "content": user_message})
+    input_messages.append(
+        {
+            "role": "user",
+            "content": [{"type": "input_text", "text": user_message}],
+        }
+    )
 
-    # Call OpenAI GPT-5 using max_completion_tokens ONLY (no temperature)
+    # Call OpenAI GPT-5 via Responses API
     try:
-        resp = client.chat.completions.create(
+        resp = client.responses.create(
             model=CHAT_MODEL,
-            messages=messages,
-            max_completion_tokens=900,  # GPT-5-compatible param
+            input=input_messages,
+            # no temperature, no token params -> avoid unsupported parameter errors
         )
-        raw_content = resp.choices[0].message.content
-        answer = normalize_openai_content(raw_content)
-        if not answer:
-            answer = "⚠️ Model returned an empty response. This may be a transient issue with the API."
+        answer = extract_text_from_response(resp)
+        if not answer.strip():
+            answer = "⚠️ Model returned an empty response object. This may be an API issue."
     except Exception as e:
         answer = f"⚠️ OpenAI API error: {e}"