pi-agent-browser-native 0.9.5 → 0.9.6

package/dist/extensions/agent-browser/lib/browser-legacy-projection.js

@@ -1,282 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { extractUpstreamCommandTokens } from "./argv-descriptor.js";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "./argv-grammar.js";
-import { batchHasSuccessfulCloseAll, getSuccessfulBatchCloseLifecycle } from "./batch-lifecycle.js";
-import { BROWSER_RESULT_TOOLS, BROWSER_TRANSITION_ENTRY, applyArtifactChanges, artifactChanges, browserStateEffects, getBrowserRecord, } from "./browser-transcript.js";
-import { isCloseAllCommand, isCloseCommand } from "./command-taxonomy.js";
-import { isRecord } from "./parsing.js";
-import { isSessionArtifactManifest } from "./results/artifact-manifest.js";
-import { browserStringArray } from "./browser-value-parsing.js";
-import { canonicalPage, LegacyPageConversion } from "./browser-legacy-pages.js";
-export const emptyProjection = () => ({ pages: new Map(), nextIndex: 0 });
-function legacyMessage(entry) {
-    if (entry.type === "custom" &&
-        entry.customType === BROWSER_TRANSITION_ENTRY &&
-        isRecord(entry.data) &&
-        isRecord(entry.data.details)) {
-        return entry.data;
-    }
-    const message = entry.type === "message" && isRecord(entry.message) ? entry.message : undefined;
-    return isLegacyToolMessage(message) ? message : undefined;
-}
-function isLegacyToolMessage(message) {
-    return (message !== undefined &&
-        typeof message.toolName === "string" &&
-        BROWSER_RESULT_TOOLS.has(message.toolName) &&
-        isRecord(message.details) &&
-        message.details.browserEventVersion !== 1);
-}
-function applyCanonical(current, parent, canonical) {
-    current.manifest = applyArtifactChanges(parent.manifest, canonical.event.artifacts);
-    for (const page of canonical.event.pages ?? []) {
-        if (page.clear === true) {
-            current.pages.delete(page.key);
-            continue;
-        }
-        current.pages.set(page.key, canonicalPage(current.pages.get(page.key) ?? {}, canonical, page));
-    }
-}
-function scriptRecord(entry, nativeId, ownerSessionId) {
-    if (entry.type !== "custom" ||
-        entry.customType !== "agent-browser-script-session" ||
-        !isRecord(entry.data)) {
-        return undefined;
-    }
-    return {
-        event: {
-            version: 1,
-            phase: "state",
-            operationId: `legacy-${nativeId}`,
-            toolCallId: `legacy-${nativeId}`,
-            commandIndex: 0,
-            isError: entry.data.cleanup !== "closed",
-            state: {
-                scriptLease: { ...entry.data, ownerSessionId: entry.data.ownerSessionId ?? ownerSessionId },
-            },
-        },
-    };
-}
-function isLegacyBegin(entry, details) {
-    return (entry.type === "custom" &&
-        details.sessionTabTargetUnknown === true &&
-        details.command === undefined &&
-        details.exitCode === undefined &&
-        details.agentBrowserStarted === undefined);
-}
-function legacyIdentity(details) {
-    const sessionName = typeof details.sessionName === "string" ? details.sessionName : undefined;
-    const namespace = typeof details.namespace === "string" ? details.namespace : undefined;
-    const key = sessionName !== undefined && sessionName.length > 0
-        ? getAgentBrowserSessionIdentityKey(sessionName, namespace)
-        : undefined;
-    const tokens = extractUpstreamCommandTokens(browserStringArray(details.args));
-    return {
-        key,
-        namespace,
-        tokens,
-        command: typeof details.command === "string" ? details.command : tokens[0],
-        subcommand: typeof details.subcommand === "string" ? details.subcommand : tokens[1],
-    };
-}
-function legacyPrior(key, current) {
-    return key === undefined ? {} : (current.pages.get(key) ?? {});
-}
-function operationIdentity(options, current) {
-    const prior = legacyPrior(options.key, current);
-    const begin = isLegacyBegin(options.entry, options.details);
-    const pending = prior.pending?.toolCallId === options.toolCallId ? prior.pending : undefined;
-    let phase = "state";
-    if (begin) {
-        phase = "begin";
-    }
-    else if (pending) {
-        phase = "finish";
-    }
-    let commandIndex = pending?.index ?? 0;
-    if (begin) {
-        commandIndex = current.nextIndex;
-        current.nextIndex++;
-    }
-    return {
-        prior,
-        begin,
-        phase,
-        commandIndex,
-        operationId: pending?.operationId ?? `legacy-${options.nativeId}`,
-    };
-}
-function context(entry, message, details, current) {
-    const nativeId = typeof entry.id === "string" ? entry.id : randomUUID();
-    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : `legacy-${nativeId}`;
-    const identity = legacyIdentity(details);
-    const operation = operationIdentity({ entry, details, key: identity.key, toolCallId, nativeId }, current);
-    return {
-        ...identity,
-        ...operation,
-        nativeId,
-        details,
-        isError: message.isError === true,
-        toolCallId,
-    };
-}
-function closingLifecycle(ctx) {
-    const close = getSuccessfulBatchCloseLifecycle(ctx.details.batchSteps);
-    const closeAll = ctx.details.closeAllApplied === true ||
-        (!ctx.isError && isCloseAllCommand(ctx.tokens)) ||
-        batchHasSuccessfulCloseAll(ctx.details.batchSteps);
-    return {
-        closeAll,
-        lifecycleReset: (!ctx.isError && isCloseCommand(ctx.command)) || close !== undefined,
-        endsClosed: close?.endsClosed === true,
-    };
-}
-function closePages(current, ctx) {
-    const closing = closingLifecycle(ctx);
-    const pages = [];
-    if (closing.closeAll) {
-        for (const key of current.pages.keys()) {
-            if (isAgentBrowserSessionIdentityKeyInNamespace(key, ctx.namespace)) {
-                current.pages.delete(key);
-                pages.push({ key, clear: true, refs: { kind: "invalidate" } });
-            }
-        }
-    }
-    else if (ctx.key !== undefined && closing.lifecycleReset) {
-        current.pages.delete(ctx.key);
-        pages.push({ key: ctx.key, clear: true, refs: { kind: "invalidate" } });
-    }
-    return { ...closing, pages };
-}
-function hasPageEffects(ctx) {
-    return (ctx.begin ||
-        [
-            "sessionTabTargetUnknown",
-            "sessionTabTarget",
-            "sessionTabReopenPending",
-            "refSnapshot",
-            "refSnapshotInvalidation",
-        ].some((field) => ctx.details[field] !== undefined) ||
-        (ctx.command === "batch" && Array.isArray(ctx.details.data)));
-}
-function stampElectronState(state, ownerSessionId) {
-    if (!isRecord(state.electron)) {
-        return state;
-    }
-    const stamp = (value) => isRecord(value) ? { ...value, ownerSessionId: value.ownerSessionId ?? ownerSessionId } : value;
-    const cleanup = isRecord(state.electron.cleanup) ? state.electron.cleanup : undefined;
-    return {
-        ...state,
-        electron: {
-            ...state.electron,
-            launch: stamp(state.electron.launch),
-            ...(cleanup
-                ? {
-                    cleanup: {
-                        ...cleanup,
-                        records: Array.isArray(cleanup.records)
-                            ? cleanup.records.map(stamp)
-                            : cleanup.records,
-                        results: Array.isArray(cleanup.results)
-                            ? cleanup.results.map((row) => isRecord(row) ? { ...row, record: stamp(row.record) } : row)
-                            : cleanup.results,
-                    },
-                }
-                : {}),
-        },
-    };
-}
-function updateManifest(current, parent, details) {
-    if (isSessionArtifactManifest(details.artifactManifest) &&
-        (!parent.manifest || details.artifactManifest.updatedAtMs >= parent.manifest.updatedAtMs)) {
-        current.manifest = details.artifactManifest;
-    }
-    const changes = artifactChanges(parent.manifest, current.manifest);
-    if (!changes) {
-        current.manifest = parent.manifest;
-    }
-    return changes;
-}
-function convertMessage(ctx, parent, current, ownerSessionId) {
-    const closing = closePages(current, ctx);
-    const pages = closing.pages;
-    let definition;
-    const suppressPage = (closing.closeAll || closing.lifecycleReset) &&
-        (isCloseCommand(ctx.command) || closing.endsClosed);
-    if (ctx.key !== undefined && hasPageEffects(ctx) && !suppressPage) {
-        const conversion = new LegacyPageConversion(ctx, current.pages.get(ctx.key) ?? {});
-        pages.push(conversion.change(ctx.key));
-        current.pages.set(ctx.key, conversion.page);
-        definition = conversion.definition;
-    }
-    const artifacts = updateManifest(current, parent, ctx.details);
-    return {
-        event: {
-            version: 1,
-            phase: ctx.phase,
-            operationId: ctx.operationId,
-            toolCallId: ctx.toolCallId,
-            commandIndex: ctx.commandIndex,
-            isError: ctx.isError,
-            state: stampElectronState(browserStateEffects(ctx.details), ownerSessionId),
-            pages,
-            artifacts,
-        },
-        ...(definition ? { snapshot: definition } : {}),
-    };
-}
-/** Offline only: normalize old receipts along their actual parent ancestry, never physical equality. */
-export function convertLegacyBrowserEntry(entry, parent = emptyProjection(), ownerSessionId) {
-    const current = {
-        pages: new Map(parent.pages),
-        manifest: parent.manifest,
-        nextIndex: parent.nextIndex,
-    };
-    const canonical = getBrowserRecord(entry);
-    if (canonical) {
-        applyCanonical(current, parent, canonical);
-        return { projection: current };
-    }
-    const script = scriptRecord(entry, typeof entry.id === "string" ? entry.id : randomUUID(), ownerSessionId);
-    if (script) {
-        return { record: script, projection: current };
-    }
-    const message = legacyMessage(entry);
-    if (!message || !isRecord(message.details)) {
-        return { projection: parent };
-    }
-    return {
-        record: convertMessage(context(entry, message, message.details, current), parent, current, ownerSessionId),
-        projection: current,
-    };
-}
-function archiveParent(value, states, linear) {
-    if (typeof value.parentId === "string") {
-        return states.get(value.parentId) ?? emptyProjection();
-    }
-    return Object.hasOwn(value, "parentId") ? emptyProjection() : linear;
-}
-/** Explicit archive conversion; runtime restoration never invokes the legacy decoder. */
-export function convertBrowserEntries(entries, ownerSessionId) {
-    const states = new Map();
-    let linear = emptyProjection();
-    return entries.map((value, index) => {
-        if (!isRecord(value)) {
-            return value;
-        }
-        const entry = {
-            ...value,
-            id: typeof value.id === "string" ? value.id : `archive-${index}`,
-            parentId: value.parentId ?? null,
-        };
-        const converted = convertLegacyBrowserEntry(entry, archiveParent(value, states, linear), ownerSessionId);
-        states.set(entry.id, converted.projection);
-        linear = converted.projection;
-        return converted.record
-            ? {
-                ...entry,
-                ...(entry.type === "custom" ? { customType: BROWSER_TRANSITION_ENTRY } : {}),
-                data: converted.record,
-            }
-            : entry;
-    });
-}

package/dist/extensions/agent-browser/lib/browser-legacy-types.js

@@ -1 +0,0 @@
-export {};

package/dist/extensions/agent-browser/lib/browser-session-conversion-stream.js

@@ -1,217 +0,0 @@
-import { createHash } from "node:crypto";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import tokenizeJson from "stream-json/parser.js";
-import ignoreJson from "stream-json/filters/ignore.js";
-import stringifyJson from "stream-json/stringer.js";
-import disassembleJson from "stream-json/disassembler.js";
-import { BROWSER_RESULT_TOOLS, BROWSER_STATE_FIELDS, BROWSER_TRANSITION_ENTRY, } from "./browser-transcript-contracts.js";
-import { projectJson, readRange, } from "./browser-journal-reader.js";
-import { isRecord } from "./parsing.js";
-import { convertLegacyBrowserEntry, emptyProjection, } from "./browser-legacy-projection.js";
-const DETAILS_FIELDS = [
-    ...BROWSER_STATE_FIELDS,
-    "browserEventVersion",
-    "electron",
-    "compiledNetworkSourceLookup",
-    "sessionTabTarget",
-    "sessionTabTargetUnknown",
-    "sessionTabReopenPending",
-    "refSnapshot",
-    "refSnapshotInvalidation",
-    "artifactManifest",
-    "error",
-    "summary",
-];
-const LEGACY_FIELDS = [
-    ["data", "event"],
-    ["data", "snapshot"],
-    ["data", "cleanup"],
-    ["data", "sessionName"],
-    ["data", "closeCommandArgs"],
-    ["data", "launchAttempted"],
-    ["data", "toolCallId"],
-    ["data", "isError"],
-    ["message", "toolName"],
-    ["message", "toolCallId"],
-    ["message", "isError"],
-    ...["data", "message"].flatMap((root) => DETAILS_FIELDS.map((field) => [root, "details", field])),
-    ...["data", "message"].flatMap((root) => ["command", "success", "lifecycle"]
-        .map((field) => [root, "details", "batchSteps", "*", field])
-        .concat([
-        ["data", "lifecycle"],
-        ["result", "lifecycle"],
-    ].map((field) => [root, "details", "batchSteps", "*"].concat(field)))),
-    ...["data", "message"].flatMap((root) => ["command", "success", "error"]
-        .map((field) => [root, "details", "data", "*", field])
-        .concat(["url", "title", "origin", "targetId"].map((field) => [
-        root,
-        "details",
-        "data",
-        "*",
-        "result",
-        field,
-    ]))),
-];
-export async function sourceChecksum(file, size) {
-    const hash = createHash("sha256");
-    for await (const chunk of readRange(file, { offset: 0, length: size })) {
-        hash.update(chunk);
-    }
-    return hash.digest("hex");
-}
-export async function writeBytes(file, 
-// The native async iterator owns its cursor; yielded byte/string contents are read, never changed.
-// oxlint-disable-next-line typescript/prefer-readonly-parameter-types
-chunks) {
-    for await (const chunk of chunks) {
-        const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-        let offset = 0;
-        while (offset < buffer.length) {
-            // Partial writes determine the offset for the next write.
-            // oxlint-disable-next-line no-await-in-loop
-            const { bytesWritten } = await file.write(buffer, offset, buffer.length - offset);
-            if (bytesWritten === 0) {
-                throw new Error("Could not write converted journal.");
-            }
-            offset += bytesWritten;
-        }
-    }
-}
-async function* decodeRange(file, range) {
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    for await (const bytes of readRange(file, range)) {
-        yield decoder.decode(bytes, { stream: true });
-    }
-    const tail = decoder.decode();
-    if (tail.length > 0) {
-        yield tail;
-    }
-}
-async function rewriteMessage(file, range, destination, record) {
-    const tokenizer = tokenizeJson.asStream({ packValues: false, packKeys: true, streamKeys: false });
-    const filter = ignoreJson.asStream({
-        filter: /^(?:data|message\.details\.(?:refSnapshot|artifactManifest|browserEventVersion))$/,
-    });
-    async function* inject(
-    // Native token iteration advances a mutable cursor; token observations themselves remain readonly.
-    // oxlint-disable-next-line typescript/prefer-readonly-parameter-types
-    tokens) {
-        let depth = 0;
-        for await (const token of tokens) {
-            if (token.name === "startObject" || token.name === "startArray") {
-                depth++;
-            }
-            if (token.name === "endObject" || token.name === "endArray") {
-                depth--;
-                if (depth === 0) {
-                    const key = { name: "keyValue", value: "data" };
-                    yield key;
-                    yield* disassembleJson({ packValues: false, packKeys: true, streamKeys: false })(record);
-                }
-            }
-            yield token;
-        }
-    }
-    const output = stringifyJson.asStream({ useKeyValues: true });
-    const processing = pipeline(Readable.from(decodeRange(file, range)), tokenizer, filter, inject, output);
-    try {
-        await Promise.all([writeBytes(destination, output), processing]);
-    }
-    finally {
-        tokenizer.destroy();
-        filter.destroy();
-        output.destroy();
-    }
-    await destination.write("\n");
-}
-function isLegacyBrowserEntry(value) {
-    if (value.type === "custom" &&
-        typeof value.customType === "string" &&
-        [BROWSER_TRANSITION_ENTRY, "agent-browser-script-session"].includes(value.customType)) {
-        return true;
-    }
-    return (isRecord(value.message) &&
-        typeof value.message.toolName === "string" &&
-        BROWSER_RESULT_TOOLS.has(value.message.toolName));
-}
-/** Owns branch projection and counters while streaming entries, never whole raw payloads. */
-export class BrowserConversionWriter {
-    file;
-    stage;
-    sessionId;
-    checksum;
-    ids = new Set();
-    states = new Map();
-    convertedRecords = 0;
-    snapshotDefinitions = 0;
-    constructor(file, stage, sessionId, checksum) {
-        this.file = file;
-        this.stage = stage;
-        this.sessionId = sessionId;
-        this.checksum = checksum;
-    }
-    get counts() {
-        return {
-            entryCount: this.ids.size,
-            convertedRecords: this.convertedRecords,
-            snapshotDefinitions: this.snapshotDefinitions,
-        };
-    }
-    async conversion(entry) {
-        if (entry.value.type === "session") {
-            return undefined;
-        }
-        const id = entry.value.id;
-        if (typeof id !== "string" || this.ids.has(id)) {
-            throw new Error("Conversion source contains a missing or duplicate native entry ID.");
-        }
-        const parentId = entry.value.parentId;
-        if (parentId !== null && (typeof parentId !== "string" || !this.ids.has(parentId))) {
-            throw new Error("Conversion source contains a missing or forward parent.");
-        }
-        this.ids.add(id);
-        const parent = typeof parentId === "string"
-            ? (this.states.get(parentId) ?? emptyProjection())
-            : emptyProjection();
-        if (!isLegacyBrowserEntry(entry.value)) {
-            this.states.set(id, parent);
-            return undefined;
-        }
-        const details = await projectJson(readRange(this.file, entry), LEGACY_FIELDS, Infinity);
-        const conversion = convertLegacyBrowserEntry({ ...entry.value, ...details }, parent, this.sessionId);
-        this.states.set(id, conversion.projection);
-        return conversion.record;
-    }
-    async write(entry, sourceSize) {
-        const record = await this.conversion(entry);
-        if (!record) {
-            await writeBytes(this.stage, readRange(this.file, entry));
-            if (entry.offset + entry.length === sourceSize) {
-                await this.completeLastLine(sourceSize);
-            }
-            return;
-        }
-        const data = {
-            ...record,
-            archive: { sourceSha256: this.checksum, offset: entry.offset, length: entry.length },
-        };
-        if (entry.value.type === "message") {
-            await rewriteMessage(this.file, entry, this.stage, data);
-        }
-        else {
-            await this.stage.write(`${JSON.stringify({ ...entry.value, customType: BROWSER_TRANSITION_ENTRY, data })}\n`);
-        }
-        this.convertedRecords++;
-        if (record.snapshot !== undefined) {
-            this.snapshotDefinitions++;
-        }
-    }
-    async completeLastLine(size) {
-        const lastByte = Buffer.alloc(1);
-        await this.file.read(lastByte, 0, 1, size - 1);
-        if (lastByte[0] !== 10) {
-            await this.stage.write("\n");
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/browser-session-conversion.js

@@ -1,126 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { constants } from "node:fs";
-import { link, lstat, mkdir, open, unlink } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-import { scanJournalMetadata } from "./browser-journal-reader.js";
-import { getErrorCode } from "./process-errors.js";
-import { BrowserConversionWriter, sourceChecksum } from "./browser-session-conversion-stream.js";
-export { convertLegacyBrowserEntry, convertBrowserEntries } from "./browser-legacy-projection.js";
-async function validateConversionPaths(options) {
-    if (!options.confirmedStopped) {
-        throw new Error("Stop/quiesce the exact session writer first, then pass --confirm-stopped. Conversion never stops a session.");
-    }
-    const source = resolve(options.source);
-    const destination = resolve(options.destination);
-    if (source === destination) {
-        throw new Error("Conversion requires a separate destination; originals are never rewritten.");
-    }
-    const sourceStat = await lstat(source);
-    if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
-        throw new Error("Conversion source must be a regular file, not a symlink.");
-    }
-    const directory = dirname(destination);
-    await mkdir(directory, { mode: 0o700, recursive: true });
-    await validateDestination(directory, destination);
-    return { source, destination, directory, sourceStat };
-}
-async function validateDestination(directory, destination) {
-    const entry = await lstat(directory);
-    if (!entry.isDirectory() ||
-        entry.isSymbolicLink() ||
-        (process.platform !== "win32" &&
-            (entry.uid !== process.getuid?.() || (entry.mode & 0o077) !== 0))) {
-        throw new Error("Conversion destination must be a private current-user directory (0700 on POSIX), without symlinks.");
-    }
-    try {
-        await lstat(destination);
-        throw new Error("Conversion destination is occupied.");
-    }
-    catch (error) {
-        if (getErrorCode(error) !== "ENOENT") {
-            throw error;
-        }
-    }
-}
-async function verifySourceUnchanged(file, source, initial, checksum) {
-    const final = await file.stat();
-    const finalPath = await lstat(source);
-    if (final.dev !== initial.dev ||
-        final.ino !== initial.ino ||
-        final.size !== initial.size ||
-        final.mtimeMs !== initial.mtimeMs ||
-        finalPath.dev !== initial.dev ||
-        finalPath.ino !== initial.ino ||
-        (await sourceChecksum(file, initial.size)) !== checksum) {
-        throw new Error("Conversion source changed; no destination was published.");
-    }
-}
-async function syncPublishedDirectory(directory) {
-    const parent = await open(directory, constants.O_RDONLY);
-    try {
-        await parent.sync();
-    }
-    finally {
-        await parent.close();
-    }
-}
-/** Separate-copy publication only. The operator must quiesce the exact writer first. */
-export async function convertBrowserSession(options) {
-    const { source, destination, directory, sourceStat } = await validateConversionPaths(options);
-    const file = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
-    const stagePath = `${destination}.${randomUUID()}.tmp`;
-    let stage;
-    let published = false;
-    try {
-        const initial = await file.stat();
-        if (initial.dev !== sourceStat.dev || initial.ino !== sourceStat.ino) {
-            throw new Error("Conversion source changed before capture.");
-        }
-        const checksum = await sourceChecksum(file, initial.size);
-        const metadata = await scanJournalMetadata(file, initial.size, true);
-        const header = metadata.at(0);
-        if (header === undefined ||
-            header.value.type !== "session" ||
-            typeof header.value.id !== "string") {
-            throw new Error("Conversion source has no native session header.");
-        }
-        stage = await open(stagePath, "wx+", 0o600);
-        const writer = new BrowserConversionWriter(file, stage, header.value.id, checksum);
-        for (const entry of metadata) {
-            // Native ancestry and output byte ordering require each entry to finish before the next.
-            // oxlint-disable-next-line no-await-in-loop
-            await writer.write(entry, initial.size);
-        }
-        await stage.sync();
-        const output = await stage.stat();
-        const destinationSha256 = await sourceChecksum(stage, output.size);
-        await verifySourceUnchanged(file, source, initial, checksum);
-        await stage.close();
-        stage = undefined;
-        await link(stagePath, destination); // Exclusive publication; never overwrite an existing destination.
-        published = true;
-        return {
-            version: 1,
-            source,
-            destination,
-            sessionId: header.value.id,
-            sourceSha256: checksum,
-            destinationSha256,
-            ...writer.counts,
-            sourceBytes: initial.size,
-            destinationBytes: output.size,
-        };
-    }
-    finally {
-        await stage?.close();
-        await file.close();
-        await unlink(stagePath).catch((error) => {
-            if (getErrorCode(error) !== "ENOENT") {
-                throw error;
-            }
-        });
-        if (published && process.platform !== "win32") {
-            await syncPublishedDirectory(directory);
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/browser-transcript-contracts.js

@@ -1,35 +0,0 @@
-export const BROWSER_TRANSITION_ENTRY = "agent-browser-transition";
-export const BROWSER_RESULT_TOOLS = new Set([
-    "agent_browser",
-    "agent_browser_code",
-    "agent_browser_action",
-    "agent_browser_qa",
-    "agent_browser_electron",
-    "agent_browser_source",
-    "agent_browser_network_source",
-]);
-export const BROWSER_STATE_FIELDS = [
-    "args",
-    "command",
-    "subcommand",
-    "sessionName",
-    "namespace",
-    "sessionMode",
-    "usedImplicitSession",
-    "managedSessionSocketDir",
-    "managedSessionDaemon",
-    "ownerSessionId",
-    "agentBrowserStarted",
-    "resultCategory",
-    "exitCode",
-    "closeAllApplied",
-    "attachedBrowserSession",
-    "readConfirmation",
-    "compatibilityWorkaround",
-    "managedSessionHeadedAutosaveDisabled",
-    "managedSessionHeadedAutosaveInterval",
-    "managedSessionOutcome",
-    "managedSessionCwd",
-    "managedSessionRestoreDisabled",
-    "nativeSucceeded",
-];