@steipete/oracle 0.13.0 → 0.14.1

package/dist/src/browser/actions/deepResearch.js

@@ -107,13 +107,16 @@ export async function waitForResearchPlanAutoConfirm(Runtime, logger, autoConfir
  * Polls for Deep Research completion over 5-30+ minutes.
  * Returns the full response text, optional HTML, and turn metadata.
  */
-export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs = DEEP_RESEARCH_DEFAULT_TIMEOUT_MS, minTurnIndex, Page, client) {
+export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs = DEEP_RESEARCH_DEFAULT_TIMEOUT_MS, minTurnIndex, Page, client, options) {
     const start = Date.now();
     let lastLogTime = start;
     let lastTextLength = 0;
     const minTurnLiteral = typeof minTurnIndex === "number" && Number.isFinite(minTurnIndex) && minTurnIndex >= 0
         ? Math.floor(minTurnIndex)
         : -1;
+    const scopedToNewTurns = minTurnLiteral >= 0;
+    const ignoredTargetKeys = new Set(options?.ignoredTargetKeys ?? []);
+    const requireScopedTargetOwner = options?.requireScopedTargetOwner === true;
     logger(`Monitoring Deep Research (timeout: ${Math.round(timeoutMs / 60_000)}min)...`);
     while (Date.now() - start < timeoutMs) {
         const { result } = await Runtime.evaluate({
@@ -124,19 +127,37 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         if (val?.accountBlocked) {
             throw new BrowserAutomationError("ChatGPT account security block detected during Deep Research. Open chatgpt.com in Chrome, secure the account, then rerun Oracle.", { stage: "chatgpt-account-blocked", code: "chatgpt-account-blocked" });
         }
-        const frameResult = Page
+        const activeScopedResearch = Boolean(val?.hasActiveScopedResearch);
+        // ChatGPT renders the Deep Research report inside an out-of-process,
+        // sandboxed iframe (connector_openai_deep_research.*.oaiusercontent.com),
+        // doubly nested and same-origin. That OOPIF does NOT appear in the main
+        // page's frame tree, so the in-page isolated-world path
+        // (readDeepResearchFrameResult) can never see it. The target-attach path
+        // (readDeepResearchTargetResult) attaches to the iframe's own CDP target and
+        // walks its nested frames, so it CAN read the report. Prefer the target path
+        // and fall back to the in-page frame path for legacy/inline rendering.
+        const targetResult = client
+            ? ((await readDeepResearchTargetResult(client, ignoredTargetKeys, requireScopedTargetOwner ? minTurnLiteral : -1).catch(() => null))?.read ?? null)
+            : null;
+        // A completed target read is authoritative. If the target read is missing or
+        // only in-progress, still try the in-page frame path so an incomplete target
+        // read does not suppress a completed report there (legacy/inline rendering).
+        const inPageResult = !targetResult?.completed && Page
             ? await readDeepResearchFrameResult(Runtime, Page).catch(() => null)
-            : client
-                ? await readDeepResearchTargetResult(client).catch(() => null)
-                : null;
-        const scopedToNewTurns = minTurnLiteral >= 0;
-        if (frameResult?.completed &&
-            frameResult.text &&
-            (!scopedToNewTurns || val?.hasActiveScopedResearch)) {
+            : null;
+        const read = pickPreferredDeepResearchRead(targetResult, inPageResult);
+        // A target-confirmed completion read the live connector iframe directly, so
+        // it is authoritative even when the main DOM exposes no assistant turn (the
+        // report lives entirely in the OOPIF). The main-DOM hasActiveScopedResearch
+        // heuristic no longer holds in that case, so don't gate on it.
+        const completedFromTarget = Boolean(targetResult?.completed);
+        if (read?.completed &&
+            read.text &&
+            (completedFromTarget || !scopedToNewTurns || activeScopedResearch)) {
             logger(`Deep Research completed (${Math.round((Date.now() - start) / 1000)}s elapsed)`);
             return {
-                text: frameResult.text,
-                html: frameResult.html,
+                text: read.text,
+                html: read.html,
                 meta: { turnId: null, messageId: null },
             };
         }
@@ -149,8 +170,8 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
         const now = Date.now();
         if (now - lastLogTime >= 60_000) {
             const elapsed = Math.round((now - start) / 1000);
-            const chars = Math.max(val?.textLength ?? 0, frameResult?.textLength ?? 0);
-            const phase = frameResult?.inProgress || val?.hasIframe
+            const chars = Math.max(val?.textLength ?? 0, read?.textLength ?? 0);
+            const phase = read?.inProgress || val?.hasIframe
                 ? "researching"
                 : val?.stopVisible
                     ? "generating"
@@ -158,7 +179,7 @@ export async function waitForDeepResearchCompletion(Runtime, logger, timeoutMs =
             logger(`Deep Research ${phase}... ${elapsed}s elapsed, ~${chars} chars`);
             lastLogTime = now;
         }
-        lastTextLength = Math.max(val?.textLength ?? 0, frameResult?.textLength ?? 0, lastTextLength);
+        lastTextLength = Math.max(val?.textLength ?? 0, read?.textLength ?? 0, lastTextLength);
         await delay(DEEP_RESEARCH_POLL_INTERVAL_MS);
     }
     // Timeout — throw with metadata for potential reattach
@@ -202,6 +223,26 @@ function isDeepResearchPlaceholderText(text) {
 export function isDeepResearchPlaceholderTextForTest(text) {
     return isDeepResearchPlaceholderText(text);
 }
+/**
+ * Choose the authoritative Deep Research read between the target-attach result
+ * and the in-page frame result. A completed read wins (target preferred, since
+ * it reads the live OOPIF directly); otherwise the best in-progress/text-bearing
+ * read is kept so progress logging still advances. This preserves the legacy
+ * Page-first inline behaviour: when the target read is missing or incomplete,
+ * a completed in-page result is still returned.
+ */
+function pickPreferredDeepResearchRead(targetResult, inPageResult) {
+    if (targetResult?.completed) {
+        return targetResult;
+    }
+    if (inPageResult?.completed) {
+        return inPageResult;
+    }
+    return targetResult ?? inPageResult;
+}
+export function pickPreferredDeepResearchReadForTest(targetResult, inPageResult) {
+    return pickPreferredDeepResearchRead(targetResult, inPageResult);
+}
 async function readDeepResearchFrameResult(Runtime, Page) {
     const pageWithFrames = Page;
     if (typeof pageWithFrames.getFrameTree !== "function" ||
@@ -228,58 +269,97 @@ async function readDeepResearchFrameResult(Runtime, Page) {
     });
     return result?.value ?? null;
 }
-async function readDeepResearchTargetResult(client) {
+async function readDeepResearchTargetResult(client, ignoredTargetKeys = new Set(), minTurnIndex = -1) {
     const rawClient = client;
     if (typeof rawClient.send !== "function") {
         return null;
     }
-    const sessionIds = new Set();
+    // On the browser-WSEndpoint path, `client` is a session-bound wrapper whose
+    // domain methods target the page session but whose raw `send` is the
+    // browser-level send. We must therefore pass the page session id explicitly so
+    // Target.setAutoAttach binds to THIS page (not the whole browser). For a direct
+    // tab client this is undefined and `send` already defaults to the page session.
+    const pageSessionId = rawClient.oraclePageSessionId;
+    const sessions = new Map();
     const ownedSessionIds = new Set();
-    const onAttached = (params, sessionId) => {
-        const targetInfo = params
-            ?.targetInfo;
-        const eventSessionId = params?.sessionId ?? sessionId;
+    const onAttached = (params, parentSessionId) => {
+        // chrome-remote-interface emits flattened target events both on the
+        // session-specific event name and on the shared base event. The second
+        // callback argument identifies the parent page session; ignore events from
+        // other tabs when this client wraps a shared browser WebSocket.
+        if (pageSessionId && parentSessionId !== pageSessionId) {
+            return;
+        }
+        const targetInfo = params?.targetInfo;
+        const eventSessionId = params?.sessionId ?? parentSessionId;
         const url = targetInfo?.url ?? "";
         const type = targetInfo?.type ?? "";
         if (eventSessionId && isDeepResearchTarget(url, type)) {
-            sessionIds.add(eventSessionId);
+            sessions.set(eventSessionId, { targetId: targetInfo?.targetId, url });
             ownedSessionIds.add(eventSessionId);
         }
     };
     client.on?.("Target.attachedToTarget", onAttached);
     try {
-        await rawClient.send("Target.setDiscoverTargets", { discover: true }).catch(() => undefined);
+        // Scope discovery to the current Oracle-controlled page. `client` is
+        // connected to the conversation page target, so enabling auto-attach on this
+        // session only attaches THIS page's related targets (its Deep Research OOPIF
+        // subframe) and emits Target.attachedToTarget for them.
+        //
+        // We deliberately do NOT enumerate Target.getTargets / attachToTarget here:
+        // that scan is browser-wide, and in a shared/persistent Chrome profile it
+        // would surface another tab's completed Deep Research report and let it be
+        // saved into the current session (cross-tab leak). Only auto-attached,
+        // page-scoped sessions are treated as belonging to this run.
         await rawClient
             .send("Target.setAutoAttach", {
             autoAttach: true,
             waitForDebuggerOnStart: false,
             flatten: true,
-        })
+        }, pageSessionId)
             .catch(() => undefined);
         await delay(100);
-        const targets = (await rawClient.send("Target.getTargets", {}));
-        for (const target of targets?.targetInfos ?? []) {
-            if (!target.targetId || !isDeepResearchTarget(target.url ?? "", target.type ?? "")) {
+        if (minTurnIndex >= 0) {
+            await rawClient.send("DOM.enable", {}, pageSessionId).catch(() => undefined);
+            await rawClient.send("Runtime.enable", {}, pageSessionId).catch(() => undefined);
+        }
+        // Baseline targets and owner turns before the submitted prompt are removed
+        // first. Among remaining targets, a completed report is authoritative;
+        // otherwise retain the newest meaningful progress read for status logging.
+        let completed = null;
+        let latestProgress = null;
+        const targetKeys = [];
+        for (const [sessionId, target] of sessions) {
+            const sessionResult = await readDeepResearchTargetSession(rawClient, sessionId, target.url);
+            if (!sessionResult.confirmed) {
                 continue;
             }
-            const attached = (await rawClient
-                .send("Target.attachToTarget", { targetId: target.targetId, flatten: true })
-                .catch(() => null));
-            if (attached?.sessionId) {
-                sessionIds.add(attached.sessionId);
-                ownedSessionIds.add(attached.sessionId);
+            if (target.targetId) {
+                targetKeys.push(target.targetId);
             }
-        }
-        for (const sessionId of sessionIds) {
-            const value = await readDeepResearchTargetSession(rawClient, sessionId);
+            if (target.targetId && ignoredTargetKeys.has(target.targetId)) {
+                continue;
+            }
+            if (minTurnIndex >= 0) {
+                const ownerTurnIndex = sessionResult.frameId
+                    ? await readDeepResearchTargetOwnerTurnIndex(rawClient, sessionResult.frameId, pageSessionId)
+                    : null;
+                if (ownerTurnIndex === null || ownerTurnIndex < minTurnIndex) {
+                    continue;
+                }
+            }
+            const value = sessionResult.read;
             if (value?.completed) {
-                return value;
+                completed = value;
             }
-            if (value?.inProgress || value?.textLength) {
-                return value;
+            else if (value && (value.inProgress || value.textLength > 0)) {
+                latestProgress = value;
             }
         }
-        return null;
+        return {
+            read: completed ?? latestProgress,
+            targetKeys,
+        };
     }
     finally {
         await rawClient
@@ -287,18 +367,62 @@ async function readDeepResearchTargetResult(client) {
             autoAttach: false,
             waitForDebuggerOnStart: false,
             flatten: true,
-        })
+        }, pageSessionId)
             .catch(() => undefined);
         await Promise.all(Array.from(ownedSessionIds, (sessionId) => rawClient.send("Target.detachFromTarget", { sessionId }).catch(() => undefined)));
         client.removeListener?.("Target.attachedToTarget", onAttached);
     }
 }
-async function readDeepResearchTargetSession(rawClient, sessionId) {
+export async function captureDeepResearchTargetKeys(client) {
+    return (await readDeepResearchTargetResult(client))?.targetKeys ?? [];
+}
+async function readDeepResearchTargetOwnerTurnIndex(rawClient, frameId, pageSessionId) {
+    const owner = (await rawClient
+        .send("DOM.getFrameOwner", { frameId }, pageSessionId)
+        .catch(() => null));
+    if (typeof owner?.backendNodeId !== "number") {
+        return null;
+    }
+    const resolved = (await rawClient
+        .send("DOM.resolveNode", { backendNodeId: owner.backendNodeId }, pageSessionId)
+        .catch(() => null));
+    const objectId = resolved?.object?.objectId;
+    if (!objectId) {
+        return null;
+    }
+    try {
+        const response = (await rawClient
+            .send("Runtime.callFunctionOn", {
+            objectId,
+            functionDeclaration: `function() {
+            const selector = ${JSON.stringify(CONVERSATION_TURN_SELECTOR)};
+            const turn = this.closest(selector);
+            return turn ? Array.from(document.querySelectorAll(selector)).indexOf(turn) : null;
+          }`,
+            returnByValue: true,
+        }, pageSessionId)
+            .catch(() => null));
+        const value = response?.result?.value;
+        return typeof value === "number" && Number.isFinite(value) && value >= 0
+            ? Math.floor(value)
+            : null;
+    }
+    finally {
+        await rawClient
+            .send("Runtime.releaseObject", { objectId }, pageSessionId)
+            .catch(() => undefined);
+    }
+}
+async function readDeepResearchTargetSession(rawClient, sessionId, targetUrl) {
     await rawClient.send("Runtime.enable", {}, sessionId).catch(() => undefined);
     await rawClient.send("Page.enable", {}, sessionId).catch(() => undefined);
     const frameTree = (await rawClient
         .send("Page.getFrameTree", {}, sessionId)
         .catch(() => null));
+    const frameId = frameTree?.frameTree?.frame?.id;
+    if (!isConfirmedDeepResearchTarget(targetUrl, frameTree?.frameTree)) {
+        return { confirmed: false, read: null };
+    }
     const frameIds = collectDeepResearchFrameIds(frameTree?.frameTree);
     let best = null;
     for (const frameId of frameIds) {
@@ -314,7 +438,7 @@ async function readDeepResearchTargetSession(rawClient, sessionId) {
         }
         const value = await evaluateDeepResearchFrameStatus(rawClient, sessionId, world.executionContextId);
         if (value?.completed) {
-            return value;
+            return { confirmed: true, read: value, frameId };
         }
         if ((value?.textLength ?? 0) > (best?.textLength ?? 0) || value?.inProgress) {
             best = value;
@@ -322,12 +446,12 @@ async function readDeepResearchTargetSession(rawClient, sessionId) {
     }
     const topFrameValue = await evaluateDeepResearchFrameStatus(rawClient, sessionId);
     if (topFrameValue?.completed) {
-        return topFrameValue;
+        return { confirmed: true, read: topFrameValue, frameId };
     }
     if ((topFrameValue?.textLength ?? 0) > (best?.textLength ?? 0) || topFrameValue?.inProgress) {
         best = topFrameValue;
     }
-    return best;
+    return { confirmed: true, read: best, frameId };
 }
 async function evaluateDeepResearchFrameStatus(rawClient, sessionId, contextId) {
     const response = (await rawClient
@@ -340,11 +464,14 @@ async function evaluateDeepResearchFrameStatus(rawClient, sessionId, contextId)
     return response?.result?.value ?? null;
 }
 function isDeepResearchTarget(url, type) {
-    const lowerUrl = url.toLowerCase();
-    const lowerType = type.toLowerCase();
-    return (lowerType === "iframe" ||
-        lowerUrl.includes("connector_openai_deep_research") ||
-        lowerUrl.includes("deep-research"));
+    return type.toLowerCase() === "iframe" || isDeepResearchFrameDescriptor(url);
+}
+function isConfirmedDeepResearchTarget(targetUrl, tree) {
+    return isDeepResearchFrameDescriptor(targetUrl) || Boolean(findDeepResearchFrameId(tree));
+}
+function isDeepResearchFrameDescriptor(url, name = "") {
+    const descriptor = `${url}\n${name}`.toLowerCase();
+    return (descriptor.includes("connector_openai_deep_research") || descriptor.includes("deep-research"));
 }
 function findDeepResearchFrameId(tree) {
     if (!tree?.frame) {
@@ -352,9 +479,7 @@ function findDeepResearchFrameId(tree) {
     }
     const url = tree.frame.url ?? "";
     const name = tree.frame.name ?? "";
-    if (url.includes("connector_openai_deep_research") ||
-        url.includes("deep-research") ||
-        name.includes("deep-research")) {
+    if (isDeepResearchFrameDescriptor(url, name)) {
         return tree.frame.id ?? null;
     }
     for (const child of tree.childFrames ?? []) {
@@ -439,6 +564,9 @@ function buildDeepResearchFrameStatusExpression() {
 export function findDeepResearchFrameIdForTest(tree) {
     return findDeepResearchFrameId(tree);
 }
+export function isConfirmedDeepResearchTargetForTest(targetUrl, tree) {
+    return isConfirmedDeepResearchTarget(targetUrl, tree);
+}
 export function buildDeepResearchFrameStatusExpressionForTest() {
     return buildDeepResearchFrameStatusExpression();
 }