codex-chatgpt-control 0.1.0-alpha.1

package/dist/src/dom/messages.js

@@ -0,0 +1,127 @@
+import { extractRoleMessageHtml, formatMessageHtml, normalizeResponseFormat } from "./message-format.js";
+import { normalizeWhitespace } from "./visible-text.js";
+export function extractMessagesFromHtml(html, args = {}) {
+    return extractRoleMessageHtml(html)
+        .filter(message => args.role === undefined || message.role === args.role)
+        .map(message => normalizeExtractedMessage(message, args));
+}
+export async function readMessages(page, args = {}) {
+    if (typeof page.evaluate === "function") {
+        const messages = await page.evaluate(() => {
+            const nodes = Array.from(document.querySelectorAll("[data-message-author-role]"));
+            return nodes
+                .map(node => {
+                const role = node.getAttribute("data-message-author-role");
+                if (role !== "user" && role !== "assistant") {
+                    return undefined;
+                }
+                return {
+                    role,
+                    html: node.innerHTML,
+                    metadataHtml: node.closest("[data-testid^='conversation-turn']")?.outerHTML ?? node.outerHTML
+                };
+            })
+                .filter(Boolean);
+        });
+        return messages
+            .filter(message => args.role === undefined || message.role === args.role)
+            .map(message => normalizeExtractedMessage(message, args));
+    }
+    if (typeof page.content === "function") {
+        const html = await page.content();
+        return extractMessagesFromHtml(html, args);
+    }
+    return [];
+}
+export async function readLatestMessage(page, role = "assistant", format = "markdown", maxChars) {
+    if (typeof page.evaluate === "function") {
+        const message = await page.evaluate((wantedRole) => {
+            const nodes = Array.from(document.querySelectorAll(`[data-message-author-role="${wantedRole}"]`));
+            const node = nodes.at(-1);
+            if (node === undefined)
+                return undefined;
+            return {
+                role: wantedRole,
+                html: node.innerHTML,
+                metadataHtml: node.closest("[data-testid^='conversation-turn']")?.outerHTML ?? node.outerHTML
+            };
+        }, role).catch(() => undefined);
+        if (message !== undefined) {
+            const args = { role, format };
+            if (maxChars !== undefined)
+                args.maxChars = maxChars;
+            return normalizeExtractedMessage(message, args);
+        }
+        return undefined;
+    }
+    const args = { role, format };
+    if (maxChars !== undefined)
+        args.maxChars = maxChars;
+    const messages = await readMessages(page, args);
+    return messages.at(-1);
+}
+export async function readLatestMessageText(page, role = "assistant") {
+    if (typeof page.evaluate === "function") {
+        return page.evaluate((wantedRole) => {
+            const nodes = Array.from(document.querySelectorAll(`[data-message-author-role="${wantedRole}"]`));
+            const node = nodes.at(-1);
+            return node?.innerText ?? node?.textContent ?? undefined;
+        }, role).catch(() => undefined);
+    }
+    return readLatestMessage(page, role, "normalized_text")
+        .then(message => message?.text)
+        .catch(() => undefined);
+}
+export async function readLatestMessageTextSnapshot(page, role) {
+    if (typeof page.evaluate === "function") {
+        return page.evaluate((wantedRole) => {
+            const allNodes = Array.from(document.querySelectorAll("[data-message-author-role]"));
+            const roleNodes = allNodes.filter(node => node.getAttribute("data-message-author-role") === wantedRole);
+            const latest = roleNodes.at(-1);
+            const latestText = latest?.innerText ?? latest?.textContent ?? undefined;
+            const snapshot = { turnCount: allNodes.length };
+            if (latestText !== undefined)
+                snapshot.latestText = latestText;
+            return snapshot;
+        }, role);
+    }
+    const messages = await readMessages(page, { role, format: "normalized_text" });
+    const allMessages = await readMessages(page, { format: "normalized_text" });
+    const snapshot = { turnCount: allMessages.length };
+    const latestText = messages.at(-1)?.text;
+    if (latestText !== undefined)
+        snapshot.latestText = latestText;
+    return snapshot;
+}
+export function isTransientAssistantText(text) {
+    const normalized = normalizeWhitespace(text)
+        .replace(/[.。…]+$/g, "")
+        .trim()
+        .toLowerCase();
+    return normalized === "thinking"
+        || normalized === "reasoning"
+        || normalized === "searching"
+        || normalized === "searching the web"
+        || /^analyzing (?:the )?images?$/.test(normalized)
+        || /^processing (?:the )?images?$/.test(normalized)
+        || /^reading (?:the )?images?$/.test(normalized);
+}
+export function countMessages(messages, role) {
+    return role === undefined ? messages.length : messages.filter(message => message.role === role).length;
+}
+export async function countPageMessages(page, role) {
+    if (typeof page.evaluate === "function") {
+        return page.evaluate((wantedRole) => {
+            const selector = wantedRole === undefined
+                ? "[data-message-author-role]"
+                : `[data-message-author-role="${wantedRole}"]`;
+            return document.querySelectorAll(selector).length;
+        }, role);
+    }
+    return countMessages(await readMessages(page), role);
+}
+function normalizeExtractedMessage(message, args = {}) {
+    const metadataHtml = message.role === "assistant" ? message.metadataHtml : undefined;
+    const content = formatMessageHtml(message.html, normalizeResponseFormat(args.format), args.maxChars, metadataHtml);
+    return { role: message.role, ...content };
+}

package/dist/src/dom/selectors.d.ts

@@ -0,0 +1,20 @@
+import type { LocatorLike, PageLike } from "../types.js";
+export declare const cssSelectors: {
+    readonly assistantMessages: "[data-message-author-role='assistant']";
+    readonly userMessages: "[data-message-author-role='user']";
+    readonly roleMessages: "[data-message-author-role]";
+    readonly conversationTurns: "[data-testid^='conversation-turn']";
+    readonly hiddenFileInputs: "input[type='file']";
+    readonly downloadControls: string;
+};
+export declare function composerTextbox(page: PageLike): LocatorLike;
+export declare function sendButton(page: PageLike): LocatorLike;
+export declare function searchChatsButton(page: PageLike): LocatorLike;
+export declare function searchChatsInput(page: PageLike): LocatorLike;
+export declare function newChatButton(page: PageLike): LocatorLike;
+export declare function addFilesButton(page: PageLike): LocatorLike;
+export declare function copyResponseButtons(page: PageLike): LocatorLike;
+export declare function assistantMessageNodes(page: PageLike): LocatorLike;
+export declare function userMessageNodes(page: PageLike): LocatorLike;
+export declare function roleMessageNodes(page: PageLike): LocatorLike;
+export declare function requiredLocator(page: PageLike, selector: string): LocatorLike;

package/dist/src/dom/selectors.js

@@ -0,0 +1,72 @@
+export const cssSelectors = {
+    assistantMessages: "[data-message-author-role='assistant']",
+    userMessages: "[data-message-author-role='user']",
+    roleMessages: "[data-message-author-role]",
+    conversationTurns: "[data-testid^='conversation-turn']",
+    hiddenFileInputs: "input[type='file']",
+    downloadControls: [
+        "main [data-message-author-role='assistant'] a[download]",
+        "main [data-message-author-role='assistant'] a[href*='/backend-api/files/']",
+        "main [data-message-author-role='assistant'] button[aria-label*='Download']",
+        "main [data-message-author-role='assistant'] a[aria-label*='Download']",
+        "main a[download]",
+        "main a[href*='/backend-api/files/']"
+    ].join(", ")
+};
+export function composerTextbox(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "[contenteditable='true'], textarea");
+    }
+    return page.getByRole("textbox", { name: "Chat with ChatGPT" });
+}
+export function sendButton(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "button[aria-label*='Send']");
+    }
+    return page.getByRole("button", { name: "Send prompt" });
+}
+export function searchChatsButton(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "button");
+    }
+    return page.getByRole("button", { name: "Search chats" });
+}
+export function searchChatsInput(page) {
+    if (typeof page.getByPlaceholder === "function") {
+        return page.getByPlaceholder("Search chats...");
+    }
+    return requiredLocator(page, "input[placeholder*='Search chats']");
+}
+export function newChatButton(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "a[href='/'], button");
+    }
+    return page.getByRole("button", { name: "New chat" });
+}
+export function addFilesButton(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "button[aria-label*='Add']");
+    }
+    return page.getByRole("button", { name: "Add files and more" });
+}
+export function copyResponseButtons(page) {
+    if (typeof page.getByRole !== "function") {
+        return requiredLocator(page, "button[aria-label*='Copy response']");
+    }
+    return page.getByRole("button", { name: "Copy response" });
+}
+export function assistantMessageNodes(page) {
+    return requiredLocator(page, cssSelectors.assistantMessages);
+}
+export function userMessageNodes(page) {
+    return requiredLocator(page, cssSelectors.userMessages);
+}
+export function roleMessageNodes(page) {
+    return requiredLocator(page, cssSelectors.roleMessages);
+}
+export function requiredLocator(page, selector) {
+    if (typeof page.locator !== "function") {
+        throw new Error(`Page does not support locator("${selector}")`);
+    }
+    return page.locator(selector);
+}

package/dist/src/dom/visible-text.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeWhitespace(text: string): string;
+export declare function normalizeLineBreaks(text: string): string;
+export declare function decodeBasicEntities(text: string): string;
+export declare function stripTags(html: string): string;
+export declare function normalizeLabel(text: string): string;

package/dist/src/dom/visible-text.js

@@ -0,0 +1,27 @@
+export function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+export function normalizeLineBreaks(text) {
+    return text.replace(/\r\n?/g, "\n");
+}
+export function decodeBasicEntities(text) {
+    return text
+        .replace(/ /g, " ")
+        .replace(/&/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, "\"")
+        .replace(/&#39;/g, "'");
+}
+export function stripTags(html) {
+    return normalizeWhitespace(decodeBasicEntities(html
+        .replace(/<script[\s\S]*?<\/script>/gi, " ")
+        .replace(/<style[\s\S]*?<\/style>/gi, " ")
+        .replace(/<button[\s\S]*?<\/button>/gi, " ")
+        .replace(/<nav[\s\S]*?<\/nav>/gi, " ")
+        .replace(/<svg[\s\S]*?<\/svg>/gi, " ")
+        .replace(/<[^>]+>/g, " ")));
+}
+export function normalizeLabel(text) {
+    return normalizeWhitespace(text).toLowerCase();
+}

package/dist/src/errors.d.ts

@@ -0,0 +1,32 @@
+import type { BlockerKind, CommandContext, CommandResult } from "./types.js";
+type BlockerDetails = Partial<Omit<NonNullable<CommandResult["blocker"]>, "kind" | "message" | "visibleText">>;
+export declare const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, bootstrap the Chrome plugin runtime with setupBrowserRuntime({ globals: globalThis }) before using globalThis.agent.";
+export declare const BROWSER_BRIDGE_REMEDIATION: NonNullable<NonNullable<CommandResult["blocker"]>["remediation"]>;
+export declare class ChatGPTControlError extends Error {
+    readonly kind: BlockerKind;
+    readonly recoverable: boolean;
+    readonly visibleText?: string | undefined;
+    readonly blockerDetails: BlockerDetails;
+    constructor(message: string, kind: BlockerKind, recoverable: boolean, visibleText?: string | undefined, blockerDetails?: BlockerDetails);
+}
+export declare class BrowserBridgeUnavailableError extends ChatGPTControlError {
+    constructor(message?: string);
+}
+export declare class LoginRequiredError extends ChatGPTControlError {
+    constructor(visibleText?: string);
+}
+export declare class SelectorDriftError extends ChatGPTControlError {
+    constructor(message: string, visibleText?: string);
+}
+export declare class ConfirmationRequiredError extends ChatGPTControlError {
+    constructor(message: string, visibleText?: string);
+}
+export declare class TimeoutPartialError extends ChatGPTControlError {
+    constructor(message: string, visibleText?: string);
+}
+export declare function contextNow(partial?: Partial<CommandContext>): CommandContext;
+export declare function resultOk<T>(data: T, context?: Partial<CommandContext>, warnings?: string[]): CommandResult<T>;
+export declare function resultBlocked(kind: BlockerKind, message: string, visibleText?: string, context?: Partial<CommandContext>): CommandResult<never>;
+export declare function resultError(error: Error, context?: Partial<CommandContext>, recoverable?: boolean): CommandResult<never>;
+export declare function toCommandResult(error: unknown, context?: Partial<CommandContext>): CommandResult<never>;
+export {};

package/dist/src/errors.js

@@ -0,0 +1,127 @@
+export const BROWSER_BRIDGE_UNAVAILABLE_MESSAGE = "Codex cannot access the ChatGPT browser bridge from this backend process. In an ordinary shell this is expected; for a live Codex Chrome run, bootstrap the Chrome plugin runtime with setupBrowserRuntime({ globals: globalThis }) before using globalThis.agent.";
+export const BROWSER_BRIDGE_REMEDIATION = [
+    {
+        label: "Ordinary shell",
+        instruction: "Treat browser_bridge_unavailable from a plain shell as an expected protocol/blocker-path result, not proof that Chrome, ChatGPT, or the Codex extension is broken.",
+        userActionRequired: false
+    },
+    {
+        label: "Codex Chrome bootstrap",
+        instruction: "For a live run, initialize the Chrome plugin runtime in node_repl with setupBrowserRuntime({ globals: globalThis }), then set globalThis.browser = await agent.browsers.get(\"extension\") before calling createChatGPT({ agent: globalThis.agent }).",
+        userActionRequired: false
+    },
+    {
+        label: "Python live bridge",
+        instruction: "For Python browser-bridge smokes, keep the bridge-hosted Node backend JS execution alive and run scripts/http_stdio_relay.mjs with CHATGPT_BROWSER_BACKEND_HTTP_URL; a plain Python-spawned Node subprocess cannot inherit globalThis.agent.",
+        userActionRequired: false
+    },
+    {
+        label: "Extension availability",
+        instruction: "If this command was already running inside a bootstrapped bridge host, verify the Codex Chrome extension is installed and enabled, then restart Chrome or Codex before retrying.",
+        userActionRequired: true
+    }
+];
+export class ChatGPTControlError extends Error {
+    kind;
+    recoverable;
+    visibleText;
+    blockerDetails;
+    constructor(message, kind, recoverable, visibleText, blockerDetails = {}) {
+        super(message);
+        this.kind = kind;
+        this.recoverable = recoverable;
+        this.visibleText = visibleText;
+        this.blockerDetails = blockerDetails;
+        this.name = new.target.name;
+    }
+}
+export class BrowserBridgeUnavailableError extends ChatGPTControlError {
+    constructor(message = BROWSER_BRIDGE_UNAVAILABLE_MESSAGE) {
+        super(message, "browser_bridge_unavailable", true, undefined, {
+            code: "codex_chrome_bridge_unavailable",
+            remediation: BROWSER_BRIDGE_REMEDIATION
+        });
+    }
+}
+export class LoginRequiredError extends ChatGPTControlError {
+    constructor(visibleText) {
+        super("ChatGPT login is required before this command can continue.", "login_required", true, visibleText);
+    }
+}
+export class SelectorDriftError extends ChatGPTControlError {
+    constructor(message, visibleText) {
+        super(message, "selector_drift", true, visibleText);
+    }
+}
+export class ConfirmationRequiredError extends ChatGPTControlError {
+    constructor(message, visibleText) {
+        super(message, "confirmation", true, visibleText);
+    }
+}
+export class TimeoutPartialError extends ChatGPTControlError {
+    constructor(message, visibleText) {
+        super(message, "unknown", true, visibleText);
+    }
+}
+export function contextNow(partial = {}) {
+    return {
+        timestamp: new Date().toISOString(),
+        ...partial
+    };
+}
+export function resultOk(data, context = {}, warnings = []) {
+    return {
+        ok: true,
+        status: "ok",
+        data,
+        warnings,
+        context: contextNow(context)
+    };
+}
+export function resultBlocked(kind, message, visibleText, context = {}) {
+    const blocker = visibleText === undefined ? { kind, message } : { kind, message, visibleText };
+    return {
+        ok: false,
+        status: "blocked",
+        warnings: [],
+        blocker,
+        context: contextNow(context)
+    };
+}
+export function resultError(error, context = {}, recoverable = error instanceof ChatGPTControlError ? error.recoverable : false) {
+    const blocker = error instanceof ChatGPTControlError
+        ? error.visibleText === undefined
+            ? {
+                kind: error.kind,
+                message: error.message,
+                ...error.blockerDetails
+            }
+            : {
+                kind: error.kind,
+                message: error.message,
+                visibleText: error.visibleText,
+                ...error.blockerDetails
+            }
+        : undefined;
+    const result = {
+        ok: false,
+        status: blocker ? "blocked" : "error",
+        warnings: [],
+        error: {
+            name: error.name,
+            message: error.message,
+            recoverable
+        },
+        context: contextNow(context)
+    };
+    if (blocker !== undefined) {
+        result.blocker = blocker;
+    }
+    return result;
+}
+export function toCommandResult(error, context = {}) {
+    if (error instanceof Error) {
+        return resultError(error, context);
+    }
+    return resultError(new Error(String(error)), context);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,34 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./logger.js";
+export * from "./browser/attach.js";
+export * from "./browser/clipboard.js";
+export * from "./browser/page-state.js";
+export * from "./dom/messages.js";
+export * from "./dom/message-format.js";
+export * from "./dom/selectors.js";
+export * from "./dom/visible-text.js";
+export * from "./dom/fixtures.js";
+export * from "./safety/blockers.js";
+export * from "./safety/redaction.js";
+export * from "./safety/report-redaction.js";
+export * from "./commands/session.js";
+export * from "./commands/threads.js";
+export * from "./commands/messages.js";
+export * from "./commands/sequence.js";
+export * from "./commands/files.js";
+export * from "./commands/modes.js";
+export * from "./commands/response-actions.js";
+export * from "./commands/confirmations.js";
+export * from "./commands/helpers.js";
+export * from "./commands/doctor.js";
+export * from "./commands/reports.js";
+export * from "./commands/registry.js";
+export * from "./client.js";
+export * from "./browser/downloads.js";
+export * from "./dom/menus.js";
+export * from "./safety/risk.js";
+export * from "./runner/index.js";
+export * from "./backend/client.js";
+export * from "./backend/protocol.js";
+export * from "./backend/session.js";

package/dist/src/index.js

@@ -0,0 +1,34 @@
+export * from "./types.js";
+export * from "./errors.js";
+export * from "./logger.js";
+export * from "./browser/attach.js";
+export * from "./browser/clipboard.js";
+export * from "./browser/page-state.js";
+export * from "./dom/messages.js";
+export * from "./dom/message-format.js";
+export * from "./dom/selectors.js";
+export * from "./dom/visible-text.js";
+export * from "./dom/fixtures.js";
+export * from "./safety/blockers.js";
+export * from "./safety/redaction.js";
+export * from "./safety/report-redaction.js";
+export * from "./commands/session.js";
+export * from "./commands/threads.js";
+export * from "./commands/messages.js";
+export * from "./commands/sequence.js";
+export * from "./commands/files.js";
+export * from "./commands/modes.js";
+export * from "./commands/response-actions.js";
+export * from "./commands/confirmations.js";
+export * from "./commands/helpers.js";
+export * from "./commands/doctor.js";
+export * from "./commands/reports.js";
+export * from "./commands/registry.js";
+export * from "./client.js";
+export * from "./browser/downloads.js";
+export * from "./dom/menus.js";
+export * from "./safety/risk.js";
+export * from "./runner/index.js";
+export * from "./backend/client.js";
+export * from "./backend/protocol.js";
+export * from "./backend/session.js";

package/dist/src/logger.d.ts

@@ -0,0 +1,15 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogEvent = {
+    level: LogLevel;
+    event: string;
+    message: string;
+    timestamp: string;
+    data?: Record<string, unknown>;
+};
+export type Logger = {
+    log(event: LogEvent): void;
+};
+export declare function createMemoryLogger(): Logger & {
+    events: LogEvent[];
+};
+export declare function redactLogEvent(event: LogEvent): LogEvent;

package/dist/src/logger.js

@@ -0,0 +1,25 @@
+import { compactVisibleText } from "./safety/redaction.js";
+export function createMemoryLogger() {
+    const events = [];
+    return {
+        events,
+        log(event) {
+            events.push(redactLogEvent(event));
+        }
+    };
+}
+export function redactLogEvent(event) {
+    const redacted = {
+        level: event.level,
+        event: event.event,
+        message: compactVisibleText(event.message),
+        timestamp: event.timestamp
+    };
+    if (event.data !== undefined) {
+        redacted.data = Object.fromEntries(Object.entries(event.data).map(([key, value]) => [
+            key,
+            typeof value === "string" ? compactVisibleText(value) : value
+        ]));
+    }
+    return redacted;
+}

package/dist/src/runner/agent.d.ts

@@ -0,0 +1,2 @@
+import type { ChatGPTAgent, ChatGPTAgentConfig } from "./types.js";
+export declare function createChatGPTAgent<TOutput = string>(config: ChatGPTAgentConfig<TOutput>): ChatGPTAgent<TOutput>;

package/dist/src/runner/agent.js

@@ -0,0 +1,17 @@
+export function createChatGPTAgent(config) {
+    const name = config.name.trim();
+    if (name.length === 0) {
+        throw new Error("ChatGPT agent name must be a non-empty string.");
+    }
+    return {
+        kind: "chatgpt_browser_agent",
+        name,
+        ...(config.instructions === undefined ? {} : { instructions: config.instructions }),
+        instructionsMode: config.instructionsMode ?? "visible_prefix",
+        defaults: { ...(config.defaults ?? {}) },
+        tools: [...(config.tools ?? [])],
+        guardrails: [...(config.guardrails ?? [])],
+        ...(config.output === undefined ? {} : { output: config.output }),
+        ...(config.metadata === undefined ? {} : { metadata: { ...config.metadata } })
+    };
+}

package/dist/src/runner/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./agent.js";
+export * from "./interruptions.js";
+export * from "./result.js";
+export * from "./responses.js";
+export * from "./resume.js";
+export * from "./stream.js";
+export * from "./types.js";

package/dist/src/runner/index.js

@@ -0,0 +1,7 @@
+export * from "./agent.js";
+export * from "./interruptions.js";
+export * from "./result.js";
+export * from "./responses.js";
+export * from "./resume.js";
+export * from "./stream.js";
+export * from "./types.js";

package/dist/src/runner/interruptions.d.ts

@@ -0,0 +1,3 @@
+import type { CommandResult } from "../types.js";
+import type { ChatGPTInterruption } from "./types.js";
+export declare function interruptionFromCommandResult(result: CommandResult<unknown>, command?: string): ChatGPTInterruption | undefined;

package/dist/src/runner/interruptions.js

@@ -0,0 +1,65 @@
+import { augmentCommandBlocker, resumeDecisionForBlocker } from "./resume.js";
+export function interruptionFromCommandResult(result, command) {
+    if (!isInterruptingResult(result)) {
+        return undefined;
+    }
+    const id = `interruption-${Date.now().toString(36)}`;
+    const blocker = result.blocker === undefined ? undefined : augmentCommandBlocker(result.blocker);
+    const remediation = blocker?.remediation ?? [];
+    const interruption = {
+        id,
+        type: interruptionType(result, blocker),
+        status: result.status,
+        message: blocker?.message ?? result.error?.message ?? result.status,
+        resume: resumeDecisionForBlocker(blocker, id)
+    };
+    if (blocker !== undefined) {
+        interruption.blocker = blocker;
+        if (blocker.fieldPath !== undefined)
+            interruption.fieldPath = blocker.fieldPath;
+    }
+    if (command !== undefined)
+        interruption.command = command;
+    if (remediation.length > 0) {
+        interruption.fix = {
+            summary: "Resolve the reported blocker before resuming.",
+            steps: remediation.map(step => step.instruction)
+        };
+    }
+    return interruption;
+}
+function isInterruptingResult(result) {
+    return result.blocker !== undefined
+        || result.status === "needs_confirmation"
+        || result.status === "unsupported"
+        || result.status === "timeout";
+}
+function interruptionType(result, blocker) {
+    switch (blocker?.kind) {
+        case "confirmation":
+            return "approval_required";
+        case "permission":
+        case "upload_failed":
+        case "download_unavailable":
+            return "permission_required";
+        case "login_required":
+            return "login_required";
+        case "captcha":
+            return "captcha";
+        case "rate_limit":
+            return "rate_limit";
+        case "selector_drift":
+            return "selector_drift";
+        case "browser_bridge_unavailable":
+        case "not_found":
+        case "modal":
+        case "unknown":
+        case undefined:
+            break;
+    }
+    if (result.status === "needs_confirmation")
+        return "approval_required";
+    if (result.status === "timeout")
+        return "timeout";
+    return "unsupported";
+}