add history endpoint

browser_env/browser_use_runner.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import os
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any
 from urllib import error, request
 
 from browser_use import Agent, Browser, ChatOpenAI
@@ -36,6 +37,7 @@ async def run_browser_task(task):
         return {
             "success": True,
             "result": history.final_result(),
+            "history": _extract_history_events(history),
             "browser_view": browser_view_url,
         }
     except Exception as err:
@@ -47,6 +49,90 @@ async def run_browser_task(task):
             pass
 
 
+def _to_jsonable(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(key): _to_jsonable(val) for key, val in value.items()}
+    if isinstance(value, (list, tuple, set)):
+        return [_to_jsonable(item) for item in value]
+
+    for method_name in ("model_dump", "dict", "to_dict"):
+        method = getattr(value, method_name, None)
+        if callable(method):
+            try:
+                dumped = method()
+                return _to_jsonable(dumped)
+            except Exception:
+                pass
+
+    return str(value)
+
+
+def _call_history_items(history: Any, attr_name: str) -> list[Any]:
+    method = getattr(history, attr_name, None)
+    if not callable(method):
+        return []
+
+    try:
+        raw: Any = method()
+    except Exception:
+        return []
+
+    if raw is None:
+        return []
+    if isinstance(raw, list):
+        return raw
+    if isinstance(raw, (str, bytes, dict)):
+        return [raw]
+
+    try:
+        return list(raw)
+    except TypeError:
+        return [raw]
+    except Exception:
+        return [raw]
+
+
+
+
+def _extract_history_events(history: Any) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+
+    def append_many(kind: str, items: list[Any]) -> None:
+        if not items:
+            return
+        for item in items:
+            normalized = _to_jsonable(item)
+            payload = normalized if isinstance(normalized, dict) else {"value": normalized}
+            content = normalized if isinstance(normalized, str) else json.dumps(normalized, ensure_ascii=False)
+            events.append(
+                {
+                    "step": len(events) + 1,
+                    "kind": kind,
+                    "content": content,
+                    "data": payload,
+                }
+            )
+
+    append_many("thought", _call_history_items(history, "model_thoughts"))
+    append_many("action", _call_history_items(history, "model_actions"))
+    append_many("error", _call_history_items(history, "errors"))
+
+    if events:
+        return events
+
+    fallback = _to_jsonable(history)
+    return [
+        {
+            "step": 1,
+            "kind": "system",
+            "content": fallback if isinstance(fallback, str) else json.dumps(fallback, ensure_ascii=False),
+            "data": fallback if isinstance(fallback, dict) else {"value": fallback},
+        }
+    ]
+
+
 class BrowserUseRPCHandler(BaseHTTPRequestHandler):
     def do_GET(self):
         if self.path != "/health":