pi-agent-browser-native 0.9.3 → 0.9.4

package/dist/extensions/agent-browser/lib/prompt-artifacts.js

@@ -0,0 +1,287 @@
+const PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`()[\],;:\\/]+(?:[\\/][^\s"'`()[\],;\\/]+)+|[^\s"'`()[\],;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?=[\s"'`),;.!?]|$)/gi;
+const COLON_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s*:\s*$/i;
+const OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the|this)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s+(?:directly\s+)?(?:\b(?:at|as|to)\b\s*[:=-]?|\bhere\b(?:\s+(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available)?\s*[:=-]?)\s*$|\b(?:export|output|save|write)\s+(?:it\s+)?(?:at|as|to)\s*[:=-]?\s*$/i;
+const UNSAFE_OUTPUT_PREFIX_PATTERN = /n['’]t\b|\b(?:cannot|disallowed|forbidden|maybe|needed|never|no|not|optional(?:ly)?|perhaps|prohibited|rather|refrain|unable|without)\b|\b(?:he|i|it|she|they|we|you)\s+(?:can|could|may|might)\b/i;
+const AFFIRMATIVE_PREFIX_PATTERN = /^(?:(?:and(?:\s+then)?|then)(?:\s+please)?|please|you|(?:be|make)\s+sure\s+to|(?:can|could|will|would)\s+you(?:\s+please)?|(?:i|we)\s+(?:need|want)\s+you\s+to|you\s+(?:must|should))$/i;
+const AFFIRMATIVE_LEAD_IN_PATTERN = /^(?:please\s+)?(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\b.*(?:[,\-:–—]|\b(?:and|then))\s*$/i;
+const LIST_CONNECTOR_PATTERN = /^[\s"'`()[\]{},;:.*!?/&+>-]*(?:(?:and|or)[\s"'`()[\]{},;:.*!?/&+>-]*)?$/i;
+const LIST_PREFIX_PATTERN = /^\s*(?:(?:[-*+]|\d+[.)])\s*)/;
+const OPTIONAL_RECORDING_PATTERN = /\b(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available\b/i;
+const STANDALONE_OPTIONAL_RECORDING_PATTERN = /^\s*(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available[.:;]?\s*$/i;
+const EXPLICIT_OPTIONAL_PATTERN = /\b(?:optionally|if\s+(?:convenient|desired|needed|possible|you\s+can|you\s+want\s+to)|when\s+(?:convenient|desired|needed|possible)|only\s+if\s+you\s+(?:can|want\s+to))\b/i;
+const REFERENCE_INTENT_PATTERN = /\btake\s+the\s+(?:image|recording|screenshot|video)\s+(?:at|from)\b/i;
+const CLAUSE_BOUNDARY_PATTERN = /(?:[;.!?](?:\s|$)|\b(?:but|instead)\b)/i;
+function artifactKind(path) {
+    if (/\.(?:webm|mp4)$/i.test(path)) {
+        return "recording";
+    }
+    if (/\.(?:png|jpe?g|webp|gif)$/i.test(path)) {
+        return "screenshot";
+    }
+    return undefined;
+}
+function intentClause(context) {
+    return context.split(CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context;
+}
+function trailingClause(context) {
+    return context.split(CLAUSE_BOUNDARY_PATTERN)[0] ?? context;
+}
+function hasOutputIntent(context) {
+    const clause = intentClause(context)
+        .replace(/\[[^\]\r\n]*\]\(\s*$/, "")
+        .replace(/[([{"'`]+\s*$/, "");
+    const match = clause.match(OUTPUT_INTENT_PATTERN) ?? clause.match(COLON_OUTPUT_INTENT_PATTERN);
+    if (!match) {
+        return false;
+    }
+    const prefix = clause.slice(0, match.index ?? 0);
+    const governingPrefix = prefix.split(/\b(?:before|unless|until)\b/i).at(-1) ?? prefix;
+    if (UNSAFE_OUTPUT_PREFIX_PATTERN.test(governingPrefix)) {
+        return false;
+    }
+    return (governingPrefix.trim().length === 0 ||
+        AFFIRMATIVE_PREFIX_PATTERN.test(governingPrefix.trim()) ||
+        AFFIRMATIVE_LEAD_IN_PATTERN.test(governingPrefix));
+}
+function stripListPrefix(context) {
+    return context.replace(LIST_PREFIX_PATTERN, "");
+}
+function pathMatches(line) {
+    PATH_PATTERN.lastIndex = 0;
+    const matches = [];
+    for (const match of line.matchAll(PATH_PATTERN)) {
+        const rawPath = match.at(1)?.trim();
+        if (rawPath === undefined || rawPath.length === 0) {
+            continue;
+        }
+        const path = rawPath.replace(/^[([{]+/, "");
+        if (path.length === 0) {
+            continue;
+        }
+        const start = match.index + match[0].indexOf(rawPath) + rawPath.indexOf(path);
+        matches.push({ end: start + path.length, path, start });
+    }
+    return matches;
+}
+/** Groups output candidates and optionality on one line; it owns no cross-line state. */
+class ArtifactCandidateLine {
+    input;
+    candidates = [];
+    isPathList;
+    groupOptional = new Map();
+    remainder;
+    nextGroup = 0;
+    previousGroup;
+    previousKind;
+    previousPathEnd = 0;
+    constructor(input) {
+        this.input = input;
+        const pathless = stripListPrefix(input.line.replace(PATH_PATTERN, ""));
+        this.remainder = pathless.replace(/[\s"'`()[\],;:.*!?>-]+/g, "").toLowerCase();
+        const syntax = pathless
+            .replace(OPTIONAL_RECORDING_PATTERN, "")
+            .replace(EXPLICIT_OPTIONAL_PATTERN, "");
+        this.isPathList = input.matches.length > 0 && LIST_CONNECTOR_PATTERN.test(syntax);
+        for (let index = 0; index < input.matches.length; index += 1) {
+            this.collectCandidate(index);
+        }
+        this.applyTrailingOptionality();
+    }
+    candidateContext(index, localContext) {
+        if (index === 0 &&
+            (this.isPathList ||
+                this.remainder.length === 0 ||
+                ["file", "output", "path"].includes(this.remainder))) {
+            return `${this.input.previousLine}\n${localContext}`;
+        }
+        return localContext;
+    }
+    selectGroup(direct, priorLine, context) {
+        if (direct) {
+            const group = this.nextGroup++;
+            this.groupOptional.set(group, this.input.recordingOptional || OPTIONAL_RECORDING_PATTERN.test(intentClause(context)));
+            return group;
+        }
+        if (priorLine) {
+            const group = this.nextGroup++;
+            this.groupOptional.set(group, this.input.continuation?.required === false);
+            return group;
+        }
+        return undefined;
+    }
+    excludesCandidate(path, context, trailing, direct) {
+        if (/(?:^|[\\/])pi-(?:attachment|clipboard|paste|upload)-/i.test(path)) {
+            return true;
+        }
+        return (direct &&
+            (REFERENCE_INTENT_PATTERN.test(intentClause(context)) ||
+                EXPLICIT_OPTIONAL_PATTERN.test(intentClause(context)) ||
+                EXPLICIT_OPTIONAL_PATTERN.test(trailing)));
+    }
+    continuesPriorLine(index, kind, context) {
+        return (index === 0 &&
+            this.isPathList &&
+            kind === this.input.continuation?.kind &&
+            LIST_CONNECTOR_PATTERN.test(context));
+    }
+    continuesSameLine(kind, context) {
+        return (kind === this.previousKind &&
+            this.previousGroup !== undefined &&
+            LIST_CONNECTOR_PATTERN.test(context));
+    }
+    collectCandidate(index) {
+        const { end, path, start } = this.input.matches[index];
+        const localContext = stripListPrefix(this.input.line.slice(this.previousPathEnd, start));
+        const context = this.candidateContext(index, localContext);
+        const kind = artifactKind(path);
+        const direct = hasOutputIntent(context);
+        const sameLine = this.continuesSameLine(kind, localContext);
+        const priorLine = this.continuesPriorLine(index, kind, localContext);
+        const group = !direct && sameLine ? this.previousGroup : this.selectGroup(direct, priorLine, context);
+        const trailing = trailingClause(this.input.line.slice(end, this.input.matches[index + 1]?.start ?? this.input.line.length));
+        this.previousPathEnd = end;
+        if (kind === undefined ||
+            group === undefined ||
+            this.excludesCandidate(path, context, trailing, direct)) {
+            this.previousGroup = undefined;
+            this.previousKind = undefined;
+            return;
+        }
+        this.candidates.push({
+            continuedFromPriorLine: priorLine && !direct,
+            group,
+            kind,
+            matchIndex: index,
+            path,
+        });
+        this.previousGroup = group;
+        this.previousKind = kind;
+    }
+    applyTrailingOptionality() {
+        for (const candidate of this.candidates) {
+            const match = this.input.matches[candidate.matchIndex];
+            const nextStart = this.input.matches[candidate.matchIndex + 1]?.start ?? this.input.line.length;
+            if (OPTIONAL_RECORDING_PATTERN.test(trailingClause(this.input.line.slice(match.end, nextStart)))) {
+                this.groupOptional.set(candidate.group, true);
+            }
+        }
+    }
+    result() {
+        const candidates = [];
+        for (const candidate of this.candidates) {
+            candidates.push({
+                ...candidate,
+                required: candidate.kind === "screenshot" || this.groupOptional.get(candidate.group) !== true,
+            });
+        }
+        return { candidates, isPathList: this.isPathList };
+    }
+}
+/** Owns deduplication and list/fence state for one prompt; no parser state survives the call. */
+class PromptArtifactCollector {
+    artifacts = [];
+    seen = new Map();
+    inCodeFence = false;
+    listArtifactIndexes = [];
+    continuation;
+    pendingRecordingAvailability = false;
+    resetList() {
+        this.listArtifactIndexes = [];
+        this.continuation = undefined;
+    }
+    applyRecordingAvailability() {
+        if (this.continuation?.kind !== "recording") {
+            this.pendingRecordingAvailability = true;
+            return;
+        }
+        for (const index of this.listArtifactIndexes) {
+            const artifact = this.artifacts[index];
+            if (artifact.kind === "recording") {
+                this.artifacts[index] = { ...artifact, required: false };
+            }
+        }
+        this.continuation = { ...this.continuation, required: false };
+    }
+    skipLine(line, matches) {
+        if (matches.length > 0) {
+            return false;
+        }
+        if (STANDALONE_OPTIONAL_RECORDING_PATTERN.test(line)) {
+            this.applyRecordingAvailability();
+            return true;
+        }
+        return (this.pendingRecordingAvailability && /\brecordings?\b/i.test(line) && hasOutputIntent(line));
+    }
+    storeCandidates(analysis) {
+        const indexes = [];
+        for (const candidate of analysis.candidates) {
+            const required = candidate.required;
+            const key = `${candidate.kind}:${candidate.path}`;
+            let index = this.seen.get(key);
+            if (index === undefined) {
+                index = this.artifacts.length;
+                this.seen.set(key, index);
+                this.artifacts.push({ kind: candidate.kind, path: candidate.path, required });
+            }
+            else if (required) {
+                this.artifacts[index] = { ...this.artifacts[index], required: true };
+            }
+            indexes.push(index);
+        }
+        return indexes;
+    }
+    updateContinuation(analysis, indexes, matchCount) {
+        const lastCandidate = analysis.candidates.at(-1);
+        const lastIndex = indexes.at(-1);
+        if (!analysis.isPathList ||
+            lastCandidate?.matchIndex !== matchCount - 1 ||
+            lastIndex === undefined) {
+            this.resetList();
+            return;
+        }
+        const lastArtifact = this.artifacts[lastIndex];
+        this.continuation = { kind: lastArtifact.kind, required: lastArtifact.required };
+        if (analysis.candidates[0]?.continuedFromPriorLine) {
+            this.listArtifactIndexes.push(...indexes);
+        }
+        else {
+            this.listArtifactIndexes = [...indexes];
+        }
+    }
+    collectLine(line, previousLine) {
+        if (/^\s*(?:`{3,}|~{3,})/.test(line)) {
+            this.inCodeFence = !this.inCodeFence;
+            this.resetList();
+            this.pendingRecordingAvailability = false;
+            return;
+        }
+        if (this.inCodeFence) {
+            return;
+        }
+        const matches = pathMatches(line);
+        if (this.skipLine(line, matches)) {
+            return;
+        }
+        const recordingOptional = matches.length > 0 && this.pendingRecordingAvailability;
+        this.pendingRecordingAvailability = false;
+        const analysis = new ArtifactCandidateLine({
+            line,
+            previousLine,
+            matches,
+            continuation: this.continuation,
+            recordingOptional,
+        }).result();
+        const indexes = this.storeCandidates(analysis);
+        this.updateContinuation(analysis, indexes, matches.length);
+    }
+    collect(prompt) {
+        const lines = prompt.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            this.collectLine(lines[index] ?? "", lines[index - 1] ?? "");
+        }
+        return this.artifacts;
+    }
+}
+export function extractPromptRequestedArtifacts(prompt) {
+    return new PromptArtifactCollector().collect(prompt);
+}

package/dist/extensions/agent-browser/lib/prompt-policy.js

@@ -1,3 +1,5 @@
+import { extractPromptRequestedArtifacts, } from "./prompt-artifacts.js";
+import { isRecord } from "./parsing.js";
 const LEGACY_BASH_ALLOW_PATTERNS = [
     /\b(?:bash-oriented workflow|bash workflow)\b/i,
     /\b(?:use|via|through|with)\s+bash\b/i,
@@ -5,194 +7,6 @@ const LEGACY_BASH_ALLOW_PATTERNS = [
     /\bagent-browser\s+--(?:help|version)\b/i,
     /\bdebug(?:ging)?\b.*\b(?:agent[_ -]?browser|agent_browser|browser integration)\b/i,
 ];
-const PROMPT_ARTIFACT_PATH_PATTERN = /(?:^|[\s"'`(:])((?:\/[^\s"'`),;]+|[A-Za-z]:[\\/][^\s"'`),;]+|\.{1,2}[\\/][^\s"'`),;]+|[^\s"'`()[\],;:\\/]+(?:[\\/][^\s"'`()[\],;\\/]+)+|[^\s"'`()[\],;:\\/]+)\.(?:png|jpe?g|webp|gif|webm|mp4|har|pdf|trace|json))(?=[\s"'`),;.!?]|$)/gi;
-const PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s*:\s*$/i;
-const PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN = /\b(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\s+(?:(?:a|an|another|the|this)\s+)?(?:short\s+)?(?:(?:full[- ]page|page|screen)\s+)?(?:image|page|recordings?|screenshots?|screen|video)\s+(?:directly\s+)?(?:\b(?:at|as|to)\b\s*[:=-]?|\bhere\b(?:\s+(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available)?\s*[:=-]?)\s*$|\b(?:export|output|save|write)\s+(?:it\s+)?(?:at|as|to)\s*[:=-]?\s*$/i;
-const PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN = /n['’]t\b|\b(?:cannot|disallowed|forbidden|maybe|needed|never|no|not|optional(?:ly)?|perhaps|prohibited|rather|refrain|unable|without)\b|\b(?:he|i|it|she|they|we|you)\s+(?:can|could|may|might)\b/i;
-const PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN = /^(?:(?:and(?:\s+then)?|then)(?:\s+please)?|please|you|(?:be|make)\s+sure\s+to|(?:can|could|will|would)\s+you(?:\s+please)?|(?:i|we)\s+(?:need|want)\s+you\s+to|you\s+(?:must|should))$/i;
-const PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN = /^(?:please\s+)?(?:capture|create|export|generate|output|record|render|save|screenshot|start|take|write)\b.*(?:[,\-:–—]|\b(?:and|then))\s*$/i;
-const PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN = /^[\s"'`()\[\]{},;:.*!?\/&+>-]*(?:(?:and|or)[\s"'`()\[\]{},;:.*!?\/&+>-]*)?$/i;
-const PROMPT_ARTIFACT_LIST_PREFIX_PATTERN = /^\s*(?:(?:[-*+]|\d+[.)])\s*)/;
-const PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN = /\b(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available\b/i;
-const PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN = /^\s*(?:if|when)\s+(?:recordings?\s+)?(?:(?:are|is)\s+)?available[.:;]?\s*$/i;
-const PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN = /\b(?:optionally|if\s+(?:convenient|desired|needed|possible|you\s+can|you\s+want\s+to)|when\s+(?:convenient|desired|needed|possible)|only\s+if\s+you\s+(?:can|want\s+to))\b/i;
-const PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN = /\btake\s+the\s+(?:image|recording|screenshot|video)\s+(?:at|from)\b/i;
-const PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN = /(?:[;.!?](?:\s|$)|\b(?:but|instead)\b)/i;
-function getPromptArtifactKind(path) {
-    const lowerPath = path.toLowerCase();
-    if (/\.(?:webm|mp4)$/.test(lowerPath))
-        return "recording";
-    if (/\.(?:png|jpe?g|webp|gif)$/.test(lowerPath))
-        return "screenshot";
-    return undefined;
-}
-function getPromptArtifactIntentClause(context) {
-    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN).at(-1) ?? context;
-}
-function getPromptArtifactTrailingClause(context) {
-    return context.split(PROMPT_ARTIFACT_CLAUSE_BOUNDARY_PATTERN)[0] ?? context;
-}
-function hasPromptArtifactOutputIntent(context) {
-    const clause = getPromptArtifactIntentClause(context)
-        .replace(/\[[^\]\r\n]*\]\(\s*$/, "")
-        .replace(/[([{\"'`]+\s*$/, "");
-    const intentMatch = clause.match(PROMPT_ARTIFACT_OUTPUT_INTENT_PATTERN) ?? clause.match(PROMPT_ARTIFACT_COLON_OUTPUT_INTENT_PATTERN);
-    if (!intentMatch)
-        return false;
-    const prefix = clause.slice(0, intentMatch.index ?? 0);
-    const governingPrefix = prefix.split(/\b(?:before|unless|until)\b/i).at(-1) ?? prefix;
-    if (PROMPT_ARTIFACT_UNSAFE_OUTPUT_PREFIX_PATTERN.test(governingPrefix))
-        return false;
-    const normalizedPrefix = governingPrefix.trim();
-    return normalizedPrefix.length === 0
-        || PROMPT_ARTIFACT_AFFIRMATIVE_PREFIX_PATTERN.test(normalizedPrefix)
-        || PROMPT_ARTIFACT_AFFIRMATIVE_LEAD_IN_PATTERN.test(governingPrefix);
-}
-function stripPromptArtifactListPrefix(context) {
-    return context.replace(PROMPT_ARTIFACT_LIST_PREFIX_PATTERN, "");
-}
-function normalizePromptArtifactPath(path) {
-    return path.replace(/^[([{]+/, "");
-}
-function isLikelyInboundPromptArtifact(path) {
-    return /(?:^|[\\/])pi-(?:attachment|clipboard|paste|upload)-/i.test(path);
-}
-function extractPromptRequestedArtifacts(prompt) {
-    const artifacts = [];
-    const seen = new Map();
-    const lines = prompt.split(/\r?\n/);
-    let inCodeFence = false;
-    let listArtifactIndexes = [];
-    let listContinuation;
-    let pendingRecordingAvailability = false;
-    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
-        const line = lines[lineIndex] ?? "";
-        if (/^\s*(?:`{3,}|~{3,})/.test(line)) {
-            inCodeFence = !inCodeFence;
-            listArtifactIndexes = [];
-            listContinuation = undefined;
-            pendingRecordingAvailability = false;
-            continue;
-        }
-        if (inCodeFence)
-            continue;
-        PROMPT_ARTIFACT_PATH_PATTERN.lastIndex = 0;
-        const pathMatches = [];
-        for (const match of line.matchAll(PROMPT_ARTIFACT_PATH_PATTERN)) {
-            const rawPath = match[1]?.trim();
-            const path = rawPath ? normalizePromptArtifactPath(rawPath) : undefined;
-            if (!path || !rawPath)
-                continue;
-            const start = (match.index ?? 0) + match[0].indexOf(rawPath) + rawPath.indexOf(path);
-            pathMatches.push({ end: start + path.length, path, start });
-        }
-        if (pathMatches.length === 0 && PROMPT_ARTIFACT_STANDALONE_OPTIONAL_RECORDING_PATTERN.test(line)) {
-            if (listContinuation?.kind === "recording") {
-                for (const artifactIndex of listArtifactIndexes) {
-                    if (artifacts[artifactIndex]?.kind === "recording")
-                        artifacts[artifactIndex].required = false;
-                }
-                listContinuation = { ...listContinuation, required: false };
-            }
-            else {
-                pendingRecordingAvailability = true;
-            }
-            continue;
-        }
-        if (pathMatches.length === 0 && pendingRecordingAvailability && /\brecordings?\b/i.test(line) && hasPromptArtifactOutputIntent(line))
-            continue;
-        const pendingRecordingAvailabilityForLine = pathMatches.length > 0 && pendingRecordingAvailability;
-        pendingRecordingAvailability = false;
-        const pathlessLine = stripPromptArtifactListPrefix(line.replace(PROMPT_ARTIFACT_PATH_PATTERN, ""));
-        const remainder = pathlessLine.replace(/[\s"'`()\[\],;:.*!?>-]+/g, "").toLowerCase();
-        const listSyntax = pathlessLine
-            .replace(PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN, "")
-            .replace(PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN, "");
-        const isPathList = pathMatches.length > 0 && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(listSyntax);
-        const groupOptional = new Map();
-        const candidates = [];
-        let nextGroup = 0;
-        let previousGroup;
-        let previousKind;
-        let previousPathEnd = 0;
-        for (let matchIndex = 0; matchIndex < pathMatches.length; matchIndex += 1) {
-            const { end, path, start } = pathMatches[matchIndex];
-            const localContext = stripPromptArtifactListPrefix(line.slice(previousPathEnd, start));
-            const intentContext = matchIndex === 0 && (isPathList || !remainder || ["file", "output", "path"].includes(remainder))
-                ? `${lines[lineIndex - 1] ?? ""}\n${localContext}`
-                : localContext;
-            const kind = getPromptArtifactKind(path);
-            const directIntent = hasPromptArtifactOutputIntent(intentContext);
-            const sameLineContinuation = kind === previousKind && previousGroup !== undefined && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
-            const priorLineContinuation = matchIndex === 0 && isPathList && kind === listContinuation?.kind && PROMPT_ARTIFACT_LIST_CONNECTOR_PATTERN.test(localContext);
-            let group;
-            if (directIntent) {
-                group = nextGroup++;
-                groupOptional.set(group, pendingRecordingAvailabilityForLine || PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactIntentClause(intentContext)));
-            }
-            else if (sameLineContinuation) {
-                group = previousGroup;
-            }
-            else if (priorLineContinuation) {
-                group = nextGroup++;
-                groupOptional.set(group, listContinuation?.required === false);
-            }
-            const referenceReading = directIntent && PROMPT_ARTIFACT_REFERENCE_INTENT_PATTERN.test(getPromptArtifactIntentClause(intentContext));
-            const trailingContext = getPromptArtifactTrailingClause(line.slice(end, pathMatches[matchIndex + 1]?.start ?? line.length));
-            const explicitlyOptional = directIntent && (PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(getPromptArtifactIntentClause(intentContext))
-                || PROMPT_ARTIFACT_EXPLICIT_OPTIONAL_PATTERN.test(trailingContext));
-            if (!kind || group === undefined || referenceReading || explicitlyOptional || isLikelyInboundPromptArtifact(path)) {
-                previousGroup = undefined;
-                previousKind = undefined;
-                previousPathEnd = end;
-                continue;
-            }
-            candidates.push({ continuedFromPriorLine: priorLineContinuation && !directIntent, group, kind, matchIndex, path });
-            previousGroup = group;
-            previousKind = kind;
-            previousPathEnd = end;
-        }
-        for (const candidate of candidates) {
-            const match = pathMatches[candidate.matchIndex];
-            const nextStart = pathMatches[candidate.matchIndex + 1]?.start ?? line.length;
-            if (PROMPT_ARTIFACT_OPTIONAL_RECORDING_PATTERN.test(getPromptArtifactTrailingClause(line.slice(match.end, nextStart)))) {
-                groupOptional.set(candidate.group, true);
-            }
-        }
-        const lineArtifactIndexes = [];
-        for (const candidate of candidates) {
-            const required = candidate.kind === "screenshot" || groupOptional.get(candidate.group) !== true;
-            const key = `${candidate.kind}:${candidate.path}`;
-            let artifactIndex = seen.get(key);
-            if (artifactIndex === undefined) {
-                artifactIndex = artifacts.length;
-                seen.set(key, artifactIndex);
-                artifacts.push({ kind: candidate.kind, path: candidate.path, required });
-            }
-            else if (required) {
-                artifacts[artifactIndex].required = true;
-            }
-            lineArtifactIndexes.push(artifactIndex);
-        }
-        const lastCandidate = candidates.at(-1);
-        if (isPathList && lastCandidate?.matchIndex === pathMatches.length - 1) {
-            const lastArtifact = artifacts[lineArtifactIndexes.at(-1)];
-            listContinuation = { kind: lastArtifact.kind, required: lastArtifact.required };
-            if (candidates[0]?.continuedFromPriorLine) {
-                for (const artifactIndex of lineArtifactIndexes)
-                    listArtifactIndexes.push(artifactIndex);
-            }
-            else {
-                listArtifactIndexes = lineArtifactIndexes;
-            }
-        }
-        else {
-            listArtifactIndexes = [];
-            listContinuation = undefined;
-        }
-    }
-    return artifacts;
-}
 export function buildPromptPolicy(prompt) {
     return {
         allowLegacyAgentBrowserBash: LEGACY_BASH_ALLOW_PATTERNS.some((pattern) => pattern.test(prompt)),
@@ -200,14 +14,17 @@ export function buildPromptPolicy(prompt) {
     };
 }
 export function getMessageText(content) {
-    if (typeof content === "string")
+    if (typeof content === "string") {
         return content;
-    if (!Array.isArray(content))
+    }
+    if (!Array.isArray(content)) {
         return "";
+    }
     return content
         .map((item) => {
-        if (typeof item !== "object" || item === null)
+        if (!isRecord(item)) {
             return "";
+        }
         return item.type === "text" && typeof item.text === "string" ? item.text : "";
     })
         .filter((text) => text.length > 0)
@@ -218,15 +35,19 @@ export function getLatestUserMessage(manager) {
     let id = manager.getLeafId();
     const seen = new Set();
     while (id !== null) {
-        if (typeof id !== "string" || seen.has(id))
+        if (typeof id !== "string" || seen.has(id)) {
             throw new Error("Latest user prompt ancestry is invalid or cyclic.");
+        }
         seen.add(id);
         const entry = manager.getEntry(id);
-        if (!entry || entry.id !== id || entry.parentId !== null && typeof entry.parentId !== "string") {
+        if (!entry ||
+            entry.id !== id ||
+            (entry.parentId !== null && typeof entry.parentId !== "string")) {
             throw new Error("Latest user prompt ancestry is incomplete.");
         }
-        if (entry.type === "message" && entry.message.role === "user")
+        if (entry.type === "message" && entry.message.role === "user") {
             return entry.message;
+        }
         id = entry.parentId;
     }
     return undefined;

package/dist/extensions/agent-browser/lib/read-command.js

@@ -0,0 +1,41 @@
+const READ_VALUE_OPTIONS = new Set(["--filter", "--llms", "--timeout"]);
+const READ_BOOLEAN_OPTIONS = new Set(["--raw", "--require-md", "--outline", "--json"]);
+function validReadOption(flag, value) {
+    if (value === undefined) {
+        return false;
+    }
+    if (flag === "--llms") {
+        return ["index", "full"].includes(value);
+    }
+    if (flag === "--timeout") {
+        return /^\+?\d+$/.test(value) && BigInt(value) > 0n && BigInt(value) <= 18446744073709551615n;
+    }
+    return true;
+}
+// undefined is a valid DOM read; null is invalid native syntax, which must not trigger page helpers.
+export function getExplicitReadUrl(commandTokens) {
+    if (commandTokens[0] !== "read") {
+        return undefined;
+    }
+    let url;
+    const options = new Set();
+    for (let index = 1; index < commandTokens.length; index += 1) {
+        const token = commandTokens[index];
+        if (READ_VALUE_OPTIONS.has(token)) {
+            if (!validReadOption(token, commandTokens.at(++index))) {
+                return null;
+            }
+            options.add(token);
+        }
+        else if (READ_BOOLEAN_OPTIONS.has(token)) {
+            options.add(token);
+        }
+        else if (token.startsWith("--") || url !== undefined) {
+            return null;
+        }
+        else {
+            url = token;
+        }
+    }
+    return options.has("--llms") && options.has("--outline") ? null : url;
+}