Drop in a screenshot and convert it to clean code (HTML/Tailwind/React/Vue)
Python
logging
Abi Raja17f460d48200
diff --git a/backend/agent/providers/openai.py b/backend/agent/providers/openai.pyindex 92275301..073d2096 100644--- a/backend/agent/providers/openai.py+++ b/backend/agent/providers/openai.py@@ -1,8 +1,11 @@# pyright: reportUnknownVariableType=falseimport copyimport json+import osimport uuidfrom dataclasses import dataclass, field+from datetime import datetime+from html import escapefrom typing import Any, Dict, Listfrom openai import AsyncOpenAI@@ -59,6 +62,311 @@ def _get_event_attr(event: Any, key: str, default: Any = None) -> Any:return default+def _truncate_for_log(value: Any, max_len: int = 120) -> str:+ text = ensure_str(value).replace("\n", "\\n")+ if len(text) <= max_len:+ return text+ return f"{text[:max_len]}..."+++def _as_dict(value: Any) -> Dict[str, Any] | None:+ if isinstance(value, dict):+ return value++ model_dump = getattr(value, "model_dump", None)+ if callable(model_dump):+ dumped = model_dump()+ if isinstance(dumped, dict):+ return dumped++ to_dict = getattr(value, "to_dict", None)+ if callable(to_dict):+ dumped = to_dict()+ if isinstance(dumped, dict):+ return dumped++ dict_method = getattr(value, "dict", None)+ if callable(dict_method):+ dumped = dict_method()+ if isinstance(dumped, dict):+ return dumped++ raw_dict = getattr(value, "__dict__", None)+ if isinstance(raw_dict, dict):+ normalized = {k: v for k, v in raw_dict.items() if not k.startswith("_")}+ if normalized:+ return normalized++ return None+++def _to_serializable(value: Any) -> Any:+ if value is None or isinstance(value, (bool, int, float, str)):+ return value++ if isinstance(value, dict):+ return {ensure_str(k): _to_serializable(v) for k, v in value.items()}++ if isinstance(value, (list, tuple)):+ return [_to_serializable(v) for v in value]++ as_dict = _as_dict(value)+ if as_dict is not None:+ return _to_serializable(as_dict)++ return ensure_str(value)+++def _truncate_nested_strings(value: Any, max_len: int = 400) -> Any:+ if isinstance(value, str):+ if len(value) <= max_len:+ return value+ return f"{value[:max_len]}... (truncated {len(value) - max_len} chars)"+ if isinstance(value, list):+ return [_truncate_nested_strings(v, max_len=max_len) for v in value]+ if isinstance(value, dict):+ return {+ ensure_str(k): _truncate_nested_strings(v, max_len=max_len)+ for k, v in value.items()+ }+ return value+++def _summarize_content_part(part: Any) -> str:+ part_dict = _as_dict(part)+ if part_dict is None:+ return f"{type(part).__name__}"++ part_type = part_dict.get("type", "unknown")++ if part_type in ("input_text", "text", "output_text", "summary_text"):+ text = ensure_str(part_dict.get("text", ""))+ return (+ f"{part_type}(chars={len(text)} "+ f"preview='{_truncate_for_log(text, max_len=80)}')"+ )++ if part_type in ("input_image", "image_url"):+ image_url_value: Any = part_dict.get("image_url", "")+ detail: str | None = None+ if isinstance(image_url_value, dict):+ detail = ensure_str(image_url_value.get("detail", ""))+ image_url_value = image_url_value.get("url", "")+ else:+ detail = ensure_str(part_dict.get("detail", ""))++ url_text = ensure_str(image_url_value)+ detail_text = detail or "-"+ return (+ f"{part_type}(detail={detail_text} "+ f"url='{_truncate_for_log(url_text, max_len=80)}')"+ )++ return f"{part_type}(keys={sorted(part_dict.keys())})"+++def _summarize_responses_input_item(index: int, item: Any) -> str:+ item_dict = _as_dict(item)+ if item_dict is None:+ return f"{index:02d} item_type={type(item).__name__}"++ if "role" in item_dict:+ role = ensure_str(item_dict.get("role", "unknown"))+ content = item_dict.get("content", "")+ if isinstance(content, str):+ return (+ f"{index:02d} role={role} content=str chars={len(content)} "+ f"preview='{_truncate_for_log(content)}'"+ )+ if isinstance(content, list):+ part_summaries = [+ _summarize_content_part(part)+ for part in content+ ]+ return (+ f"{index:02d} role={role} content_parts={len(content)} "+ f"[{'; '.join(part_summaries)}]"+ )+ return (+ f"{index:02d} role={role} content_type={type(content).__name__}"+ )++ item_type = ensure_str(item_dict.get("type", "unknown"))++ if item_type in ("function_call", "custom_tool_call"):+ raw_args = (+ item_dict.get("input")+ if item_type == "custom_tool_call"+ else item_dict.get("arguments")+ )+ args_text = ensure_str(raw_args or "")+ call_id = item_dict.get("call_id") or item_dict.get("id")+ return (+ f"{index:02d} type={item_type} name={item_dict.get('name')} "+ f"call_id={call_id} args_chars={len(args_text)} "+ f"preview='{_truncate_for_log(args_text)}'"+ )++ if item_type == "function_call_output":+ output_text = ensure_str(item_dict.get("output", ""))+ return (+ f"{index:02d} type=function_call_output call_id={item_dict.get('call_id')} "+ f"output_chars={len(output_text)} "+ f"preview='{_truncate_for_log(output_text)}'"+ )++ if item_type == "message":+ role = ensure_str(item_dict.get("role", "unknown"))+ content = item_dict.get("content", [])+ if isinstance(content, list):+ part_summaries = [+ _summarize_content_part(part)+ for part in content+ ]+ return (+ f"{index:02d} type=message role={role} parts={len(content)} "+ f"[{'; '.join(part_summaries)}]"+ )+ return (+ f"{index:02d} type=message role={role} "+ f"content_type={type(content).__name__}"+ )++ if item_type == "reasoning":+ summary = item_dict.get("summary")+ if isinstance(summary, list):+ summary_parts = [+ _summarize_content_part(part)+ for part in summary+ ]+ return (+ f"{index:02d} type=reasoning summary_parts={len(summary)} "+ f"[{'; '.join(summary_parts)}]"+ )+ return (+ f"{index:02d} type=reasoning summary_type={type(summary).__name__}"+ )++ return f"{index:02d} type={item_type} keys={sorted(item_dict.keys())}"+++def _log_openai_turn_input(+ model: Llm,+ turn_index: int,+ input_items: List[Any],+) -> None:+ model_name = get_openai_api_name(model)+ print(+ f"[OPENAI TURN INPUT] model={model_name} "+ f"turn={turn_index} items={len(input_items)}"+ )+ for index, item in enumerate(input_items):+ print(+ f"[OPENAI TURN INPUT] "+ f"{_summarize_responses_input_item(index, item)}"+ )+++def _is_openai_turn_input_console_enabled() -> bool:+ value = os.environ.get("OPENAI_TURN_INPUT_CONSOLE", "")+ return value.strip().lower() in {"1", "true", "yes", "on"}+++def _render_openai_turn_input_html(+ model_name: str,+ report_id: str,+ turns: List[Dict[str, Any]],+) -> str:+ html_parts = [+ "<!DOCTYPE html>",+ "<html lang='en'>",+ "<head>",+ " <meta charset='UTF-8' />",+ " <meta name='viewport' content='width=device-width, initial-scale=1.0' />",+ " <title>OpenAI Turn Input Report</title>",+ " <style>",+ " body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; margin: 24px; color: #111827; }",+ " h1, h2, h3 { margin: 0 0 12px; }",+ " .meta { margin-bottom: 18px; color: #4b5563; }",+ " .turn { border: 1px solid #d1d5db; border-radius: 8px; padding: 14px; margin-bottom: 16px; }",+ " table { width: 100%; border-collapse: collapse; margin-top: 8px; }",+ " th, td { border: 1px solid #e5e7eb; padding: 8px; vertical-align: top; text-align: left; }",+ " th { background: #f9fafb; }",+ " code, pre { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 12px; }",+ " details { margin-top: 10px; }",+ " pre { background: #0b1020; color: #d1d5db; padding: 12px; border-radius: 8px; overflow: auto; max-height: 420px; }",+ " </style>",+ "</head>",+ "<body>",+ f" <h1>OpenAI Turn Input Report</h1>",+ f" <div class='meta'>report_id={escape(report_id)} | model={escape(model_name)} | turns={len(turns)}</div>",+ ]++ for turn in turns:+ turn_index = turn.get("turn_index")+ items = turn.get("items", [])+ html_parts.append(" <section class='turn'>")+ html_parts.append(+ f" <h2>Turn {turn_index} (items={len(items)})</h2>"+ )+ html_parts.append(" <table>")+ html_parts.append(+ " <thead><tr><th style='width:70px'>Index</th><th>Summary</th></tr></thead>"+ )+ html_parts.append(" <tbody>")+ for item in items:+ item_index = item.get("index")+ summary = ensure_str(item.get("summary", ""))+ html_parts.append(+ f" <tr><td>{item_index:02d}</td><td><code>{escape(summary)}</code></td></tr>"+ )+ html_parts.append(" </tbody>")+ html_parts.append(" </table>")++ for item in items:+ item_index = item.get("index")+ payload = item.get("payload")+ payload_json = json.dumps(payload, indent=2, ensure_ascii=False, sort_keys=True)+ html_parts.append(" <details>")+ html_parts.append(+ f" <summary>Item {item_index:02d} payload</summary>"+ )+ html_parts.append(f" <pre>{escape(payload_json)}</pre>")+ html_parts.append(" </details>")+ html_parts.append(" </section>")++ html_parts.extend(["</body>", "</html>"])+ return "\n".join(html_parts)+++def _write_openai_turn_input_html_report(+ model: Llm,+ report_id: str,+ turns: List[Dict[str, Any]],+) -> str | None:+ try:+ logs_path = os.environ.get("LOGS_PATH", os.getcwd())+ logs_directory = os.path.join(logs_path, "run_logs")+ os.makedirs(logs_directory, exist_ok=True)++ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ model_name = get_openai_api_name(model).replace("/", "_")+ filename = f"openai_turn_inputs_{model_name}_{timestamp}_{report_id[:8]}.html"+ filepath = os.path.join(logs_directory, filename)++ html_content = _render_openai_turn_input_html(+ model_name=model_name,+ report_id=report_id,+ turns=turns,+ )+ with open(filepath, "w") as f:+ f.write(html_content)+ return filepath+ except Exception as e:+ print(f"[OPENAI TURN INPUT] Failed to write HTML report: {e}")+ return None++def _copy_schema(schema: Dict[str, Any]) -> Dict[str, Any]:return copy.deepcopy(schema)@@ -416,11 +724,35 @@ class OpenAIProviderSession(ProviderSession):self._model = modelself._tools = toolsself._total_usage = TokenUsage()+ self._turn_index = 0+ self._turn_input_report_id = uuid.uuid4().hex+ self._turn_input_reports: List[Dict[str, Any]] = []self._input_items: List[Dict[str, Any]] = [_convert_message_to_responses_input(message) for message in prompt_messages]async def stream_turn(self, on_event: EventSink) -> ProviderTurn:+ self._turn_index += 1+ if _is_openai_turn_input_console_enabled():+ _log_openai_turn_input(self._model, self._turn_index, self._input_items)+ turn_items: List[Dict[str, Any]] = []+ for index, item in enumerate(self._input_items):+ summary = _summarize_responses_input_item(index, item)+ payload = _truncate_nested_strings(_to_serializable(item))+ turn_items.append(+ {+ "index": index,+ "summary": summary,+ "payload": payload,+ }+ )+ self._turn_input_reports.append(+ {+ "turn_index": self._turn_index,+ "items": turn_items,+ }+ )+params: Dict[str, Any] = {"model": get_openai_api_name(self._model),"input": self._input_items,@@ -475,4 +807,11 @@ class OpenAIProviderSession(ProviderSession):f"cache_read={u.cache_read} cache_write={u.cache_write} "f"total={u.total}{cache_hit_rate_str}{cost_str}")+ report_path = _write_openai_turn_input_html_report(+ model=self._model,+ report_id=self._turn_input_report_id,+ turns=self._turn_input_reports,+ )+ if report_path:+ print(f"[OPENAI TURN INPUT] HTML report: {report_path}")await self._client.close()diff --git a/backend/routes/generate_code.py b/backend/routes/generate_code.pyindex 8fc969ca..86e4d011 100644--- a/backend/routes/generate_code.py+++ b/backend/routes/generate_code.py@@ -75,6 +75,9 @@ from ws.constants import APP_ERROR_WEB_SOCKET_CODE # type: ignorerouter = APIRouter()+# Temporary debug override to focus on OpenAI prompt caching behavior.+FORCE_OPENAI_SINGLE_VARIANT = True+@dataclassclass PipelineContext:@@ -366,6 +369,14 @@ class ModelSelectionStage:) -> List[Llm]:"""Select appropriate models based on available API keys"""try:+ if FORCE_OPENAI_SINGLE_VARIANT and input_mode != "video":+ if not openai_api_key:+ raise Exception("OpenAI API key required for single-variant debug mode")+ variant_models = [Llm.GPT_5_2_CODEX_HIGH]+ print("Variant models:")+ print(f"Variant 1: {variant_models[0].value}")+ return variant_models+num_variants = 2 if generation_type == "update" else NUM_VARIANTSvariant_models = self._get_variant_models(generation_type,@@ -698,11 +709,14 @@ class StatusBroadcastMiddleware(Middleware):assert context.extracted_params is not Noneis_video_mode = context.extracted_params.input_mode == "video"is_update = context.extracted_params.generation_type == "update"- num_variants = (- NUM_VARIANTS_VIDEO- if is_video_mode- else 2 if is_update else NUM_VARIANTS- )+ if FORCE_OPENAI_SINGLE_VARIANT and not is_video_mode:+ num_variants = 1+ else:+ num_variants = (+ NUM_VARIANTS_VIDEO+ if is_video_mode+ else 2 if is_update else NUM_VARIANTS+ )# Tell frontend how many variants we're usingawait context.send_message("variantCount", str(num_variants), 0)