dhisana 0.0.1.dev270__py3-none-any.whl → 0.0.1.dev271__py3-none-any.whl

dhisana/utils/generate_structured_output_internal.py

@@ -320,6 +320,9 @@ async def _get_structured_output_with_web_search(
     Handles structured output with web search using Google search and URL scraping tools.
     Works with both OpenAI and Azure OpenAI.
     """
+    logging.info(f"[WebSearch] Starting web search structured output: model={model}, effort={effort}")
+    logging.debug(f"[WebSearch] Prompt length: {len(prompt)} chars")
+    
     tools = [SEARCH_GOOGLE_TOOL, FETCH_URL_CONTENT_TOOL]
     
     system_content = (
@@ -342,6 +345,7 @@ async def _get_structured_output_with_web_search(
     
     while tool_iteration < max_tool_iterations:
         tool_iteration += 1
+        logging.info(f"[WebSearch] Tool iteration {tool_iteration}/{max_tool_iterations}, conversation_history length: {len(conversation_history)}")
         
         # Build request with current conversation history
         request = {
@@ -358,7 +362,9 @@ async def _get_structured_output_with_web_search(
         # Retry logic for rate limits
         for attempt in range(2):
             try:
+                logging.debug(f"[WebSearch] Sending request attempt {attempt + 1}")
                 completion = await client_async.responses.create(**request)
+                logging.info(f"[WebSearch] Response received, output items: {len(completion.output) if completion and completion.output else 0}")
                 break
             except (RateLimitError, OpenAIError) as e:
                 is_rl = (
@@ -368,99 +374,127 @@ async def _get_structured_output_with_web_search(
                 )
                 if attempt == 0 and is_rl:
                     wait_time = 20 + random.uniform(0, 2.0)
-                    logging.warning(f"Rate-limit hit (429). Waiting {wait_time:.2f}s then retrying.")
+                    logging.warning(f"[WebSearch] Rate-limit hit (429). Waiting {wait_time:.2f}s then retrying.")
                     await asyncio.sleep(wait_time)
                     continue
-                logging.error(f"OpenAI API error: {e}")
-                raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
+                logging.error(f"[WebSearch] OpenAI API error: {e}")
+                raise HTTPException(status_code=502, detail=f"Error communicating with the OpenAI API: {str(e)}")
         
         if not completion:
+            logging.error("[WebSearch] No completion returned after retries")
             raise HTTPException(status_code=502, detail="OpenAI request failed.")
         
         # Check for function tool calls in the response
         tool_calls = []
         for item in (completion.output or []):
             item_type = getattr(item, "type", None)
+            logging.debug(f"[WebSearch] Output item type: {item_type}")
             if item_type == "function_call":
                 tool_calls.append(item)
         
         if not tool_calls:
             # No tool calls, we have the final response
+            logging.info(f"[WebSearch] No tool calls in iteration {tool_iteration}, returning final response")
             break
         
-        # Add the model's complete output to conversation history (includes function_call items)
-        # Per OpenAI docs: "input_list += response.output"
-        for item in (completion.output or []):
-            conversation_history.append(item)
-        
         # Execute tool calls and add results to conversation history
-        logging.info(f"Processing {len(tool_calls)} web search tool call(s) in iteration {tool_iteration}")
+        # Note: With store=False, we can't append raw output items (they have IDs that Azure
+        # can't resolve). We must create clean dicts with only the required fields.
+        logging.info(f"[WebSearch] Processing {len(tool_calls)} web search tool call(s) in iteration {tool_iteration}")
         
         for tc in tool_calls:
             func_name = getattr(tc, "name", "")
             call_id = getattr(tc, "call_id", "")
             args_str = getattr(tc, "arguments", "{}")
             
+            logging.info(f"[WebSearch] Tool call: {func_name}, call_id: {call_id}, args: {args_str[:200]}...")
+            
             try:
                 args = json.loads(args_str) if args_str else {}
-            except json.JSONDecodeError:
+            except json.JSONDecodeError as e:
+                logging.warning(f"[WebSearch] Failed to parse tool arguments: {e}")
                 args = {}
             
+            # Add the function_call to conversation history as a clean dict (no id field)
+            # Per OpenAI docs: function_call items need type, call_id, name, arguments
+            conversation_history.append({
+                "type": "function_call",
+                "call_id": call_id,
+                "name": func_name,
+                "arguments": args_str,
+            })
+            
             # Execute the tool
             tool_result = await _execute_web_search_tool(func_name, args, tool_config)
             
-            # Add tool result to conversation history (only function_call_output, not function_call)
+            # Add tool result to conversation history
             conversation_history.append({
                 "type": "function_call_output",
                 "call_id": call_id,
                 "output": tool_result,
             })
             
-            logging.info(f"Executed web search tool {func_name}, result length: {len(tool_result)}")
+            logging.info(f"[WebSearch] Executed tool {func_name}, result length: {len(tool_result)}")
+    
+    logging.info(f"[WebSearch] Tool loop completed after {tool_iteration} iteration(s)")
     
     # Parse and return the final response
-    return _parse_completion_response(completion, response_format, cache_key)
+    result, status = _parse_completion_response(completion, response_format, cache_key)
+    logging.info(f"[WebSearch] Parse result status: {status}")
+    return result, status
 
 
 def _parse_completion_response(completion, response_format: BaseModel, cache_key: str):
     """Parse completion response and return structured output."""
+    logging.debug(f"[ParseResponse] Parsing completion, has output: {bool(completion and completion.output)}")
+    
     if completion and completion.output and len(completion.output) > 0:
+        logging.debug(f"[ParseResponse] Output items count: {len(completion.output)}")
         raw_text = None
         for out in completion.output:
+            logging.debug(f"[ParseResponse] Checking output item type: {out.type}")
             if out.type == "message" and out.content:
                 for content_item in out.content:
                     if hasattr(content_item, "text"):
                         raw_text = content_item.text
+                        logging.debug(f"[ParseResponse] Found text content, length: {len(raw_text) if raw_text else 0}")
                         break
                     else:
-                        logging.warning("request refused: %s", str(content_item))
+                        logging.warning("[ParseResponse] Request refused: %s", str(content_item))
                         return "Request refused.", "FAIL"
                 if raw_text:
                     break
 
         if not raw_text or not raw_text.strip():
+            logging.warning("[ParseResponse] No text returned (possibly refusal or empty response)")
             return "No text returned (possibly refusal or empty response)", "FAIL"
 
+        logging.debug(f"[ParseResponse] Raw text (first 500 chars): {raw_text[:500] if raw_text else 'None'}...")
+        
         try:
             parsed_obj = response_format.parse_raw(raw_text)
             cache_output_tools.cache_output(
                 "get_structured_output_internal", cache_key, parsed_obj.json()
             )
+            logging.info("[ParseResponse] Successfully parsed response")
             return parsed_obj, "SUCCESS"
 
-        except Exception:
-            logging.warning("ERROR: Could not parse JSON from model output.")
+        except Exception as e:
+            logging.warning(f"[ParseResponse] Could not parse JSON from model output: {e}")
             try:
                 fixed_json = repair_json(raw_text)
                 parsed_obj = response_format.parse_raw(fixed_json)
                 cache_output_tools.cache_output(
                     "get_structured_output_internal", cache_key, parsed_obj.json()
                 )
+                logging.info("[ParseResponse] Successfully parsed response after JSON repair")
                 return parsed_obj, "SUCCESS"
             except Exception as e2:
-                logging.warning("JSON repair failed: %s", str(e2))
+                logging.warning(f"[ParseResponse] JSON repair also failed: {e2}")
+                logging.debug(f"[ParseResponse] Raw text that failed parsing: {raw_text[:1000] if raw_text else 'None'}...")
                 return raw_text, "FAIL"
     else:
+        logging.warning("[ParseResponse] No output returned from completion")
         return "No output returned", "FAIL"
 
 

{dhisana-0.0.1.dev270.dist-info → dhisana-0.0.1.dev271.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev270
+Version: 0.0.1.dev271
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev270.dist-info → dhisana-0.0.1.dev271.dist-info}/RECORD

@@ -45,7 +45,7 @@ dhisana/utils/generate_flow.py,sha256=QMn6bWo0nH0fBvy2Ebub1XfH5udnVAqsPsbIqCtQPX
 dhisana/utils/generate_leads_salesnav.py,sha256=FG7q6GSm9IywZ9TgQnn5_N3QNfiI-Qk2gaO_3GS99nY,12236
 dhisana/utils/generate_linkedin_connect_message.py,sha256=QxsxDiT-3eQOqAAbW13d0HGJXV36WYPvC-7Zsw_2VTI,10208
 dhisana/utils/generate_linkedin_response_message.py,sha256=mWoSs5p2JSTIoFZFGm86x1kgs67J7dHPvGKZPzcdGdU,14569
-dhisana/utils/generate_structured_output_internal.py,sha256=G9eqgT5SYI60rlOi6qQTndtsUpaLDuNM509limO8Zfs,31061
+dhisana/utils/generate_structured_output_internal.py,sha256=gJ6Bdwz2VexL505crMOgYYHOhmZo0MCghRoDkLP62WM,33654
 dhisana/utils/google_custom_search.py,sha256=5rQ4uAF-hjFpd9ooJkd6CjRvSmhZHhqM0jfHItsbpzk,10071
 dhisana/utils/google_oauth_tools.py,sha256=ReG5lCpXL3_e_s0yn6ai4U7B4-feOWHJVtbv_c0g0rE,28525
 dhisana/utils/google_workspace_tools.py,sha256=fuV0UcvAqF9drLzj7-p6D5zh7d5jMXl1jNJTICk4XOo,50224
@@ -95,8 +95,8 @@ dhisana/workflow/agent.py,sha256=esv7_i_XuMkV2j1nz_UlsHov_m6X5WZZiZm_tG4OBHU,565
 dhisana/workflow/flow.py,sha256=xWE3qQbM7j2B3FH8XnY3zOL_QXX4LbTW4ArndnEYJE0,1638
 dhisana/workflow/task.py,sha256=HlWz9mtrwLYByoSnePOemBUBrMEcj7KbgNjEE1oF5wo,1830
 dhisana/workflow/test.py,sha256=E7lRnXK0PguTNzyasHytLzTJdkqIPxG5_4qk4hMEeKc,3399
-dhisana-0.0.1.dev270.dist-info/METADATA,sha256=P7vlLN7X5NZFyM-Wzgqrdo20B69wmKjLpQWxlF-WS4o,1190
-dhisana-0.0.1.dev270.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dhisana-0.0.1.dev270.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
-dhisana-0.0.1.dev270.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
-dhisana-0.0.1.dev270.dist-info/RECORD,,
+dhisana-0.0.1.dev271.dist-info/METADATA,sha256=t746AJjraGpmdydXXdzST-85-XvYPv2WueN1RfXINm8,1190
+dhisana-0.0.1.dev271.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dhisana-0.0.1.dev271.dist-info/entry_points.txt,sha256=jujxteZmNI9EkEaK-pOCoWuBujU8TCevdkfl9ZcKHek,49
+dhisana-0.0.1.dev271.dist-info/top_level.txt,sha256=NETTHt6YifG_P7XtRHbQiXZlgSFk9Qh9aR-ng1XTf4s,8
+dhisana-0.0.1.dev271.dist-info/RECORD,,