@tea-agent/loop-agent 0.44.0-next.12 → 0.44.0-next.13

package/dist/worker/console/chat/browser-content.js

@@ -0,0 +1,74 @@
+import { Readability } from "@mozilla/readability";
+import { parseHTML } from "linkedom";
+import TurndownService from "turndown";
+/** Clone the current DOM and materialize live form properties without changing the page. */
+export async function captureBrowserHtml(locator) {
+    return locator.evaluate((root) => {
+        const clone = root.cloneNode(true);
+        const originalFields = [root, ...root.querySelectorAll("input,textarea,select")];
+        const clonedFields = [clone, ...clone.querySelectorAll("input,textarea,select")];
+        originalFields.forEach((field, index) => {
+            const copy = clonedFields[index];
+            if (!copy)
+                return;
+            if (field instanceof HTMLInputElement) {
+                copy.setAttribute("value", field.type === "password" ? "" : field.value);
+                copy.toggleAttribute("checked", field.checked);
+            }
+            else if (field instanceof HTMLTextAreaElement)
+                copy.textContent = field.value;
+            else if (field instanceof HTMLSelectElement) {
+                Array.from(copy.querySelectorAll("option")).forEach((option, optionIndex) => option.toggleAttribute("selected", field.options[optionIndex]?.selected ?? false));
+            }
+        });
+        return clone.outerHTML;
+    });
+}
+export function browserHtmlToMarkdown(html, url, mode = "page") {
+    if (html.length > 1_000_000)
+        throw new Error("CONTENT_TOO_LARGE: request a smaller region/ref (HTML limit 1M characters)");
+    const { document } = parseHTML(`<!doctype html><html><body>${html}</body></html>`);
+    document.querySelectorAll("head,script,style,noscript,[hidden],input[type=hidden]").forEach((node) => node.remove());
+    for (const field of document.querySelectorAll("input,textarea,select")) {
+        const type = field.getAttribute("type");
+        const value = type === "password" ? "[password omitted]"
+            : type === "checkbox" || type === "radio" ? (field.hasAttribute("checked") ? "[x]" : "[ ]")
+                : field.localName === "select" ? Array.from(field.querySelectorAll("option[selected]"), (option) => option.textContent).join(", ")
+                    : field.getAttribute("value") ?? field.textContent ?? "";
+        const replacement = document.createElement("span");
+        if (type === "checkbox" || type === "radio")
+            replacement.setAttribute("data-loop-checked", field.hasAttribute("checked") ? "true" : "false");
+        replacement.textContent = `${field.getAttribute("aria-label") ?? field.getAttribute("name") ?? ""}: ${value} `;
+        field.replaceWith(replacement);
+    }
+    for (const node of document.querySelectorAll("a[href],img[src]")) {
+        const attr = node.localName === "a" ? "href" : "src";
+        try {
+            node.setAttribute(attr, new URL(node.getAttribute(attr) ?? "", url).href);
+        }
+        catch {
+            node.removeAttribute(attr);
+        }
+    }
+    const article = mode === "article" ? new Readability(document.cloneNode(true)).parse() : null;
+    const source = article?.content || (mode === "article" ? document.querySelector("main,article,[role=main]")?.innerHTML : undefined) || document.body.innerHTML;
+    const converter = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" });
+    converter.addRule("checkboxState", {
+        filter: (node) => node.nodeName === "SPAN" && node.hasAttribute("data-loop-checked"),
+        replacement: (_content, node) => `\n- [${node.getAttribute("data-loop-checked") === "true" ? "x" : " "}] ${converter.escape((node.textContent ?? "").split(":")[0] ?? "")}\n`,
+    });
+    converter.addRule("tables", {
+        filter: "table",
+        replacement: (_content, node) => {
+            const rows = Array.from(node.querySelectorAll("tr"), (row) => Array.from(row.children, (cell) => (cell.textContent ?? "").trim().replace(/\|/g, "\\|").replace(/\s+/g, " ")));
+            const width = Math.max(0, ...rows.map((row) => row.length));
+            if (!width)
+                return "";
+            const header = rows.shift() ?? [];
+            const format = (row) => `| ${Array.from({ length: width }, (_, index) => row[index] ?? "").join(" | ")} |`;
+            return `\n\n${[format(header), format(Array(width).fill("---")), ...rows.map(format)].join("\n")}\n\n`;
+        },
+    });
+    const markdown = converter.turndown(source);
+    return { markdown: markdown.slice(0, 24_000), truncated: markdown.length > 24_000, mode, articleExtracted: !!article?.content };
+}

package/dist/worker/console/chat/browser-diagnostics.js

@@ -0,0 +1,250 @@
+/** Metadata only: never retain credentials, query values, fragments or non-HTTP payload URLs. */
+export function diagnosticUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return `[${url.protocol} URL omitted]`;
+        url.username = "";
+        url.password = "";
+        url.hash = "";
+        // Omit keys too: applications sometimes put secrets in parameter names.
+        const query = url.search ? "?[redacted]" : "";
+        url.search = "";
+        return `${url.href}${query}`.slice(0, 2000);
+    }
+    catch {
+        return "[invalid URL omitted]";
+    }
+}
+/** Best-effort redaction, not a guarantee for arbitrary application log text. */
+export function diagnosticText(raw) {
+    const text = raw
+        .replace(/https?:\/\/[^\s<>"']+/gi, (url) => diagnosticUrl(url))
+        .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9+/_=.\-]+/gi, "$1 [redacted]")
+        .replace(/\b(token|password|passwd|secret|api[_-]?key|authorization|cookie)\b(["']?\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;]+)/gi, "$1$2[redacted]");
+    return text.length > 2000 ? `${text.slice(0, 2000)}… [truncated]` : text;
+}
+/** Append-only journal. Clearing and eviction do not reset its cursor. */
+export class BrowserDiagnosticJournal {
+    capacity;
+    entries = [];
+    lastSequence = 0;
+    removedThrough = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        if (!Number.isSafeInteger(capacity) || capacity < 1)
+            throw new Error("invalid journal capacity");
+    }
+    append(entry, sequence) {
+        this.lastSequence = sequence;
+        this.entries.push({ ...entry, sequence });
+        while (this.entries.length > this.capacity) {
+            const removed = this.entries.shift();
+            if (removed)
+                this.removedThrough = removed.sequence;
+        }
+    }
+    read(query, tabId) {
+        const after = query.after ?? 0;
+        const limit = query.limit ?? 50;
+        if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100) {
+            throw new Error("after must be a non-negative integer and limit must be 1..100");
+        }
+        const pending = this.entries.filter((entry) => entry.sequence > after);
+        const entries = pending.slice(0, limit);
+        const nextCursor = entries.at(-1)?.sequence ?? Math.max(after, this.lastSequence);
+        const batch = { tabId, entries, nextCursor, hasMore: pending.length > limit, gap: after < this.removedThrough };
+        if (query.clear) {
+            this.entries = this.entries.filter((entry) => entry.sequence > nextCursor);
+            this.removedThrough = Math.max(this.removedThrough, Math.min(nextCursor, this.lastSequence));
+        }
+        return batch;
+    }
+}
+/** Owned by one browser service; no disk persistence and no request/response bodies. */
+export class BrowserDiagnostics {
+    tabs = new Map();
+    pending = new Map();
+    nextSequence = 1;
+    nextRequestId = 1;
+    detachContext;
+    resolveTab;
+    trackPage(page, tabId) {
+        if (this.tabs.has(tabId)) {
+            this.flushUnattributed();
+            return;
+        }
+        const journal = new BrowserDiagnosticJournal(200);
+        const onConsole = (message) => {
+            const location = message.location();
+            journal.append({
+                timestamp: Date.now(), level: message.type(), text: diagnosticText(message.text()),
+                location: { url: diagnosticUrl(location.url), line: location.lineNumber, column: location.columnNumber },
+            }, this.nextSequence++);
+        };
+        const onError = (error) => {
+            journal.append({ timestamp: Date.now(), level: "pageerror", text: diagnosticText(error.message) }, this.nextSequence++);
+        };
+        page.on("console", onConsole);
+        page.on("pageerror", onError);
+        this.tabs.set(tabId, {
+            console: journal,
+            network: new BrowserDiagnosticJournal(300),
+            detach: () => { page.off("console", onConsole); page.off("pageerror", onError); },
+        });
+        this.flushUnattributed();
+    }
+    attachContext(context, trackPage) {
+        this.detachContext?.();
+        this.resolveTab = trackPage;
+        const onRequest = (request) => {
+            if (request.serviceWorker?.())
+                return;
+            const startedAt = Date.now();
+            const pending = {
+                tabId: null, deferred: [], startedAt, completed: false,
+                entry: {
+                    requestId: this.nextRequestId++, url: diagnosticUrl(request.url()),
+                    method: request.method().slice(0, 32), resourceType: request.resourceType(),
+                },
+            };
+            this.pending.set(request, pending);
+            this.flushUnattributed();
+            this.record(pending, "request");
+            // Bound retained Playwright Request objects as well as output journals.
+            while (this.pending.size > 500) {
+                const oldest = this.pending.keys().next().value;
+                if (!oldest)
+                    break;
+                const dropped = this.pending.get(oldest);
+                if (dropped)
+                    this.record(dropped, "observation-lost", { failure: "observation-capacity-exceeded" });
+                this.pending.delete(oldest);
+            }
+        };
+        const onResponse = (response) => {
+            this.flushUnattributed();
+            const pending = this.pending.get(response.request());
+            if (pending) {
+                pending.entry.status = response.status();
+                this.record(pending, "response");
+            }
+        };
+        const complete = (request, event) => {
+            this.flushUnattributed();
+            this.complete(request, event);
+        };
+        const onFinished = (request) => complete(request, "finished");
+        const onFailed = (request) => complete(request, "failed");
+        context.on("request", onRequest);
+        context.on("response", onResponse);
+        context.on("requestfinished", onFinished);
+        context.on("requestfailed", onFailed);
+        this.detachContext = () => {
+            context.off("request", onRequest);
+            context.off("response", onResponse);
+            context.off("requestfinished", onFinished);
+            context.off("requestfailed", onFailed);
+        };
+    }
+    console(query, tabId) {
+        return (this.tabs.get(tabId ?? -1)?.console ?? new BrowserDiagnosticJournal(1)).read(query, tabId);
+    }
+    network(query, tabId) {
+        return (this.tabs.get(tabId ?? -1)?.network ?? new BrowserDiagnosticJournal(1)).read(query, tabId);
+    }
+    removePage(tabId) {
+        this.tabs.get(tabId)?.detach();
+        this.tabs.delete(tabId);
+        for (const [request, pending] of this.pending) {
+            if (pending.tabId === tabId)
+                this.pending.delete(request);
+        }
+    }
+    reset() {
+        this.detachContext?.();
+        this.detachContext = undefined;
+        this.resolveTab = undefined;
+        for (const tabId of this.tabs.keys())
+            this.removePage(tabId);
+        this.pending.clear();
+    }
+    flushUnattributed() {
+        if (!this.resolveTab)
+            return;
+        for (const [request, pending] of this.pending) {
+            this.attributeRequest(request, pending);
+        }
+        for (const [request, pending] of this.pending) {
+            if (pending.tabId === null)
+                continue;
+            this.attributeRedirectChain(request, pending.tabId);
+            if (pending.completed)
+                this.pending.delete(request);
+        }
+    }
+    attributeRequest(request, pending) {
+        if (pending.tabId !== null || !this.resolveTab)
+            return;
+        try {
+            const page = request.frame().page();
+            if (page.isClosed())
+                return;
+            this.assignTab(pending, this.resolveTab(page));
+        }
+        catch {
+            // Popup navigation can precede frame creation. Retry on later events
+            // or when a redirect successor can be attributed; never guess a tab.
+        }
+    }
+    attributeRedirectChain(request, tabId) {
+        const neighbor = (item, direction) => {
+            const read = item[direction];
+            if (typeof read !== "function")
+                return null;
+            return read.call(item) ?? null;
+        };
+        let current = neighbor(request, "redirectedFrom");
+        while (current) {
+            const previous = this.pending.get(current);
+            if (previous)
+                this.assignTab(previous, tabId);
+            current = neighbor(current, "redirectedFrom");
+        }
+        current = neighbor(request, "redirectedTo");
+        while (current) {
+            const next = this.pending.get(current);
+            if (next)
+                this.assignTab(next, tabId);
+            current = neighbor(current, "redirectedTo");
+        }
+    }
+    assignTab(pending, tabId) {
+        if (pending.tabId === tabId)
+            return;
+        pending.tabId = tabId;
+        const journal = this.tabs.get(tabId)?.network;
+        for (const entry of pending.deferred)
+            journal?.append(entry, this.nextSequence++);
+        pending.deferred = [];
+    }
+    record(pending, event, extra) {
+        const timestamp = Date.now();
+        const entry = { ...pending.entry, timestamp, event, durationMs: Math.max(0, timestamp - pending.startedAt), ...extra };
+        if (pending.tabId === null)
+            pending.deferred.push(entry);
+        else
+            this.tabs.get(pending.tabId)?.network.append(entry, this.nextSequence++);
+    }
+    complete(request, event) {
+        const pending = this.pending.get(request);
+        if (!pending)
+            return;
+        this.record(pending, event, event === "failed"
+            ? { failure: diagnosticText(request.failure()?.errorText ?? "request failed") }
+            : undefined);
+        pending.completed = true;
+        if (pending.tabId !== null)
+            this.pending.delete(request);
+    }
+}

package/dist/worker/console/chat/browser-evaluation.js

@@ -0,0 +1,58 @@
+/** Executes an expression in the page, returning a JSON-safe, size-bounded envelope. */
+export async function evaluateBrowserExpression(page, expression, maxChars = 24_000) {
+    const result = await page.evaluate(async ({ expression, maxChars }) => {
+        const AsyncFunction = Object.getPrototypeOf(async () => { }).constructor;
+        const value = await new AsyncFunction(`return (${expression}\n)`)();
+        const seen = new WeakSet();
+        const json = JSON.stringify(value, (_key, item) => {
+            if (item === undefined)
+                return { type: "undefined" };
+            if (typeof item === "bigint")
+                return { type: "bigint", value: String(item) };
+            if (typeof item === "number" && !Number.isFinite(item))
+                return { type: "number", value: String(item) };
+            if (typeof item === "function" || typeof item === "symbol")
+                return { type: typeof item, value: String(item) };
+            if (item && typeof item === "object") {
+                if (seen.has(item))
+                    return { type: "circular" };
+                seen.add(item);
+            }
+            return item;
+        });
+        return { json: json.slice(0, maxChars), truncated: json.length > maxChars };
+    }, { expression, maxChars });
+    if (result.truncated)
+        return { text: result.json, truncated: true };
+    try {
+        return { value: JSON.parse(result.json), truncated: false };
+    }
+    catch (cause) {
+        throw new Error("page returned invalid serialized evaluation result", { cause });
+    }
+}
+/** Stops waiting without claiming the underlying browser operation was cancelled. */
+export async function waitForBrowserOperation(pending, timeoutMs, signal) {
+    let timer;
+    let abort;
+    try {
+        return await Promise.race([
+            pending,
+            new Promise((_resolve, reject) => {
+                abort = () => reject(Object.assign(new Error("browser operation cancelled; page work may still be running"), { code: "BROWSER_CANCELLED" }));
+                if (signal?.aborted) {
+                    abort();
+                    return;
+                }
+                signal?.addEventListener("abort", abort, { once: true });
+                timer = setTimeout(() => reject(Object.assign(new Error("page evaluation timed out; wait for recovery or explicitly close the tab"), { code: "EVAL_TIMEOUT" })), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abort)
+            signal?.removeEventListener("abort", abort);
+    }
+}

package/dist/worker/console/chat/browser-operation-queue.js

@@ -0,0 +1,19 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/** Serializes service entrypoints, including HTTP and chat, without reentrant deadlocks. */
+export class BrowserOperationQueue {
+    tail = Promise.resolve();
+    local = new AsyncLocalStorage();
+    get current() { return this.local.getStore(); }
+    run(target, signal, operation) {
+        const task = this.tail.then(async () => {
+            signal?.throwIfAborted();
+            return this.local.run({ target, signal }, async () => {
+                const result = await operation();
+                signal?.throwIfAborted();
+                return result;
+            });
+        });
+        this.tail = task.catch(() => undefined);
+        return task;
+    }
+}

package/dist/worker/console/chat/browser-pick.js

@@ -0,0 +1,113 @@
+import { randomUUID } from "node:crypto";
+import { waitForBrowserOperation } from "./browser-evaluation.js";
+/** Human input happens in the external window, never the independent sidebar iframe. */
+export async function pickBrowserElement(page, message, timeoutMs, signal) {
+    const key = `__loopPick_${randomUUID().replace(/-/g, "")}`;
+    const pending = page.evaluateHandle(({ key, message, timeoutMs }) => new Promise((resolve) => {
+        const global = window;
+        const banner = document.createElement("div");
+        banner.dataset.loopBrowserPicker = "true";
+        banner.textContent = `${message} — click a control; Esc to cancel`;
+        banner.style.cssText = "position:fixed;bottom:16px;left:16px;padding:12px;background:#172033;color:white;z-index:2147483647;font:14px sans-serif;pointer-events:none";
+        document.documentElement.append(banner);
+        const frames = Array.from(document.querySelectorAll("iframe,frame"), (frame) => {
+            const cover = document.createElement("div");
+            cover.textContent = "Frame picking unavailable";
+            cover.style.cssText = "position:fixed;z-index:2147483646;background:#17203322;color:#172033;font:12px sans-serif";
+            document.documentElement.append(cover);
+            return { frame, cover };
+        });
+        const positionFrames = () => {
+            for (const { frame, cover } of frames) {
+                const rect = frame.getBoundingClientRect();
+                Object.assign(cover.style, { left: `${rect.x}px`, top: `${rect.y}px`, width: `${rect.width}px`, height: `${rect.height}px` });
+            }
+        };
+        positionFrames();
+        window.addEventListener("scroll", positionFrames, true);
+        window.addEventListener("resize", positionFrames);
+        const finish = (value) => {
+            clearTimeout(timer);
+            document.removeEventListener("click", click, true);
+            document.removeEventListener("keydown", keydown, true);
+            banner.remove();
+            frames.forEach(({ cover }) => cover.remove());
+            window.removeEventListener("scroll", positionFrames, true);
+            window.removeEventListener("resize", positionFrames);
+            delete global[key];
+            resolve(value);
+        };
+        const click = (event) => {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            const element = event.composedPath()[0];
+            if (!(element instanceof Element))
+                return;
+            if (frames.some(({ cover }) => cover === element)) {
+                finish({ code: "PICK_UNSUPPORTED" });
+                return;
+            }
+            finish({ element: element.closest("button,a,input,select,textarea,[role=button],[role=checkbox]") ?? element });
+        };
+        const keydown = (event) => {
+            if (event.key !== "Escape")
+                return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            finish({ code: "PICK_CANCELLED" });
+        };
+        const timer = setTimeout(() => finish({ code: "PICK_TIMEOUT" }), timeoutMs);
+        global[key] = () => finish({ code: "PICK_CANCELLED" });
+        document.addEventListener("click", click, true);
+        document.addEventListener("keydown", keydown, true);
+    }), { key, message, timeoutMs });
+    try {
+        const handle = await waitForBrowserOperation(pending, timeoutMs + 1000, signal);
+        const codeHandle = await handle.getProperty("code");
+        const code = await codeHandle.jsonValue();
+        await codeHandle.dispose();
+        if (code) {
+            await handle.dispose();
+            throw Object.assign(new Error(String(code)), { code });
+        }
+        const element = (await handle.getProperty("element")).asElement();
+        await handle.dispose();
+        if (!element)
+            throw Object.assign(new Error("PICK_UNSUPPORTED: no selectable element"), { code: "PICK_UNSUPPORTED" });
+        return element;
+    }
+    catch (error) {
+        if (browserDocumentGone(error)) {
+            throw Object.assign(new Error("page navigated or closed during picking; inspect again"), { code: "PICK_NAVIGATED" });
+        }
+        throw error;
+    }
+    finally {
+        let cleanupFailure;
+        const cleanup = page.evaluate((key) => {
+            const cancel = window[key];
+            if (typeof cancel === "function")
+                cancel();
+        }, key).catch((error) => { cleanupFailure = error; });
+        // A cancelled caller must not leave an eventual JS handle undisposed.
+        if (signal?.aborted)
+            void pending.then((handle) => handle.dispose()).catch(() => undefined);
+        let confirmed = true;
+        try {
+            await waitForBrowserOperation(cleanup, 1000);
+        }
+        catch {
+            confirmed = false;
+        }
+        // A navigation replaces the document (overlay is gone); any other unconfirmed
+        // cleanup leaves unknown page state and must quarantine the tab.
+        if (!confirmed || (cleanupFailure !== undefined && !browserDocumentGone(cleanupFailure))) {
+            throw Object.assign(new Error("picker cleanup unconfirmed; explicitly close this tab to recover"), { code: "PAGE_BUSY" });
+        }
+    }
+}
+/** True when the old document is provably gone, so a failed overlay cleanup is safe. */
+export function browserDocumentGone(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /context was destroyed|frame was detached|has been closed|Target closed|browser has been closed/i.test(message);
+}

package/dist/worker/console/chat/browser-routes.js

@@ -1,7 +1,6 @@
 /**
- * HTTP API for the Console Browser panel. The panel renders screenshots from
- * the controlled browser and sends pointer/keyboard input back to the same
- * Playwright page used by Operator Chat tools.
+ * HTTP API for the workspace-controlled external browser. The sidebar iframe
+ * is an independent preview; these endpoints operate the Playwright page.
  */
 import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
 function workspaceIdOf(req) {
@@ -49,7 +48,15 @@ async function readJson(req) {
     }
     if (chunks.length === 0)
         return {};
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    try {
+        const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("expected JSON object");
+        return value;
+    }
+    catch (cause) {
+        throw new Error("invalid browser request JSON object", { cause });
+    }
 }
 export async function handleBrowserRequest(req, res, deps, pathname) {
     if (!pathname.startsWith("/api/operator/v1/chat/browser"))
@@ -59,6 +66,26 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
     const parts = rest.split("/").filter(Boolean);
     const sub = parts[0] ?? "";
     try {
+        if (method === "GET" && sub === "screenshots" && parts.length === 2) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, { ok: false, error: { code: scope.code, message: scope.message } });
+                return true;
+            }
+            if (!deps.automation) {
+                sendJson(res, 503, { ok: false });
+                return true;
+            }
+            try {
+                const bytes = await deps.automation.readScreenshot(parts[1] ?? "");
+                res.writeHead(200, { "content-type": "image/png", "cache-control": "no-store", "x-content-type-options": "nosniff" });
+                res.end(bytes);
+            }
+            catch {
+                sendJson(res, 404, { ok: false, error: { code: "SCREENSHOT_UNAVAILABLE", message: "screenshot unavailable" } });
+            }
+            return true;
+        }
         if (method === "GET" && sub === "state" && parts.length === 1) {
             const scope = requireScope(req, deps);
             if (!scope.ok) {
@@ -160,7 +187,8 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 return true;
             }
             const body = await readJson(req);
-            const result = await dispatchBrowserPost(deps.automation, sub, body);
+            const automation = deps.automation;
+            const result = await automation.run({ tabId: numberOrUndefined(body.tabId) }, () => dispatchBrowserPost(automation, sub, body));
             sendJson(res, 200, { ok: true, data: result });
             return true;
         }

package/dist/worker/console/chat/browser-screenshot-result.js

@@ -0,0 +1,47 @@
+/** Small text envelope survives live SSE and restored tool-result previews. */
+const SCREENSHOT_METADATA_BUDGET = 2500;
+const ESSENTIAL_KEYS = ["tabId", "snapshotId", "screenshotUrl", "screenshotPath", "screenshotError", "imageWarning"];
+const OPTIONAL_KEYS = ["title", "url"];
+const OPTIONAL_KEY_SET = new Set(OPTIONAL_KEYS);
+/** Control characters balloon the serialized JSON and can break history restore. */
+function cleanString(value, max) {
+    if (typeof value !== "string")
+        return value;
+    return value.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, max);
+}
+export function screenshotMetadata(result) {
+    const output = {};
+    for (const key of [...ESSENTIAL_KEYS, ...OPTIONAL_KEYS]) {
+        if (result[key] !== undefined)
+            output[key] = cleanString(result[key], OPTIONAL_KEY_SET.has(key) ? 200 : 500);
+    }
+    // Never truncate the serialized JSON itself: shed optional fields, then shorten the rest.
+    if (JSON.stringify(output).length > SCREENSHOT_METADATA_BUDGET)
+        for (const key of OPTIONAL_KEYS)
+            delete output[key];
+    if (JSON.stringify(output).length > SCREENSHOT_METADATA_BUDGET) {
+        for (const key of ESSENTIAL_KEYS)
+            if (typeof output[key] === "string")
+                output[key] = output[key].slice(0, 120);
+    }
+    return output;
+}
+/** Only renderer-local, workspace-scoped screenshot routes may become an <img>. */
+export function screenshotUrlFromText(text) {
+    try {
+        const data = JSON.parse(text);
+        if (!data || typeof data !== "object" || !("screenshotUrl" in data) || typeof data.screenshotUrl !== "string")
+            return undefined;
+        return /^\/api\/operator\/v1\/chat\/browser\/screenshots\/[0-9a-f-]{36}\.png\?workspaceId=[A-Za-z0-9_%.-]+$/.test(data.screenshotUrl) ? data.screenshotUrl : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Console's text history omits binary payloads; this never mutates Pi model messages. */
+export function omitBrowserImageData(_key, value) {
+    if (value && typeof value === "object" && "type" in value && value.type === "image") {
+        return { type: "image", dataOmitted: true };
+    }
+    return value;
+}