Drop in a screenshot and convert it to clean code (HTML/Tailwind/React/Vue)
Python
# pyright: reportUnknownVariableType=false
import json
from typing import Any
from agent.state import ensure_str
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]
value_as_dict = as_dict(value)
if value_as_dict is not None:
return to_serializable(value_as_dict)
return ensure_str(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_function_call_output_payload(output_text: str) -> str:
try:
parsed = json.loads(output_text)
except json.JSONDecodeError:
return (
f"output_chars={len(output_text)} "
f"preview='{truncate_for_log(output_text)}'"
)
if not isinstance(parsed, dict):
return (
f"output_type={type(parsed).__name__} "
f"preview='{truncate_for_log(parsed)}'"
)
if "error" in parsed:
error_text = ensure_str(parsed.get("error"))
return f"error='{truncate_for_log(error_text)}'"
summary_parts: list[str] = []
content_text = ensure_str(parsed.get("content"))
if content_text:
summary_parts.append(f"content='{truncate_for_log(content_text, max_len=80)}'")
details = parsed.get("details")
if isinstance(details, dict):
path = ensure_str(details.get("path"))
diff_text = details.get("diff")
if (not path) and isinstance(diff_text, str) and diff_text:
for line in diff_text.splitlines():
if line.startswith("--- "):
path = line.removeprefix("--- ").strip()
break
if path:
summary_parts.append(f"path={path}")
edits = details.get("edits")
if isinstance(edits, list):
summary_parts.append(f"edits={len(edits)}")
content_length = details.get("contentLength")
if isinstance(content_length, int):
summary_parts.append(f"content_length={content_length}")
first_changed_line = details.get("firstChangedLine")
if isinstance(first_changed_line, int):
summary_parts.append(f"first_changed_line={first_changed_line}")
if isinstance(diff_text, str) and diff_text:
diff_lines = diff_text.count("\n")
summary_parts.append(f"diff_chars={len(diff_text)}")
summary_parts.append(f"diff_lines={diff_lines}")
if not summary_parts:
summary_parts.append(f"keys={sorted(parsed.keys())}")
return " ".join(summary_parts)
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"{summarize_function_call_output_payload(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())}"