Skip to content

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.py
index 92275301..073d2096 100644
--- a/backend/agent/providers/openai.py
+++ b/backend/agent/providers/openai.py
@@ -1,8 +1,11 @@
# pyright: reportUnknownVariableType=false
import copy
import json
+import os
import uuid
from dataclasses import dataclass, field
+from datetime import datetime
+from html import escape
from typing import Any, Dict, List
from 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 = model
self._tools = tools
self._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.py
index 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: ignore
router = APIRouter()
+# Temporary debug override to focus on OpenAI prompt caching behavior.
+FORCE_OPENAI_SINGLE_VARIANT = True
+
@dataclass
class 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_VARIANTS
variant_models = self._get_variant_models(
generation_type,
@@ -698,11 +709,14 @@ class StatusBroadcastMiddleware(Middleware):
assert context.extracted_params is not None
is_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 using
await context.send_message("variantCount", str(num_variants), 0)