e2e 0.16.0 → 0.17.0

package/dist/internal/redact.js

@@ -63,24 +63,31 @@ function compile(values) {
     });
     // `split` on a capturing pattern returns the markers at the odd indexes; those pass through untouched.
     const redact = (text) => text.split(known).map((piece, index) => (index % 2 === 1 ? piece : rewrite(piece))).join('');
-    const valueKeys = entries.map(([, value]) => caseKey(value));
+    const valueKeys = entries.map(([, value]) => readingKey(value).key);
+    // A reader trims a value's leading whitespace as it trims any text's, so a cut part may begin past it.
+    const leadingForms = entries.map(([, value], index) => {
+        const key = valueKeys[index] ?? '';
+        return secretLength(value.trim()) >= MIN_SECRET_LENGTH && key.trimStart() !== key ? [key, key.trimStart()] : [key];
+    });
     const redactCut = (text) => {
         // Only what follows the last marker can end in a value cut short.
         const tail = text.split(known).at(-1) ?? '';
-        const tailKey = caseKey(tail);
+        const tailKey = readingKey(tail);
         let cut = 0;
         let marker = '';
-        valueKeys.forEach((value, index) => {
-            const length = leadingPartAtEnd(tailKey, value, Math.min(FRAGMENT_LENGTH, Math.ceil(value.length / 2)));
-            if (length > cut) {
-                cut = length;
-                marker = markers[index] ?? '';
+        leadingForms.forEach((forms, index) => {
+            for (const value of forms) {
+                const length = leadingPartAtEnd(tailKey.key, value, Math.min(FRAGMENT_LENGTH, Math.ceil(value.length / 2)));
+                if (length > cut) {
+                    cut = length;
+                    marker = markers[index] ?? '';
+                }
             }
         });
         if (cut === 0)
             return redact(text);
         // An occurrence the whole-value pass would rewrite across the fragment's start joins the fragment.
-        let start = tail.length - cut;
+        let start = tailKey.at(tailKey.key.length - cut);
         pattern.lastIndex = 0;
         for (let match = pattern.exec(tail); match !== null && match.index < start; match = pattern.exec(tail)) {
             if (match.index + match[0].length > start) {
@@ -221,6 +228,87 @@ function caseKey(text) {
         out += ch.charCodeAt(0) < 128 ? ch.toLowerCase() : caseKeyOf(ch);
     return out;
 }
+/** Whitespace a reader rewrites: a run of two or more, or one character other than a plain space. */
+const COLLAPSIBLE = /\s\s|[^\S ]/u;
+/** UTF-16 units joined into one string at a time when the key is rebuilt. */
+const KEY_CHUNK = 8192;
+/**
+ * `text` as a cut or a fragment of a value is compared: `caseKey`, with each
+ * whitespace run read as one space, as an engine that collapses whitespace
+ * (`normalizeText`) shows it before cutting. A value holding a line break, a
+ * tab, a CRLF, a no-break space, or a run of spaces then agrees with what a
+ * collapsed text keeps of it, and a stretch of the key maps back to the text
+ * through `at`. `caseKey` keeps every index, so text with nothing to collapse
+ * is its own key. Otherwise the key is rebuilt unit by unit into a typed
+ * array, and `at` keeps one pair of offsets per collapsed run: a trace text
+ * of many megabytes costs a few times its size, never an object per unit.
+ */
+function readingKey(text) {
+    const cased = caseKey(text);
+    if (!COLLAPSIBLE.test(cased))
+        return { key: cased, at: (index) => index };
+    const units = new Uint16Array(cased.length);
+    // Pairs of where a stretch after a collapsed run starts, in the key and in the text.
+    let breaks = new Int32Array(64);
+    let pairs = 0;
+    let length = 0;
+    for (let index = 0; index < cased.length; index += 1) {
+        const unit = cased.charCodeAt(index);
+        if (!isWhitespace(unit)) {
+            units[length++] = unit;
+            continue;
+        }
+        let end = index + 1;
+        while (end < cased.length && isWhitespace(cased.charCodeAt(end)))
+            end += 1;
+        units[length++] = 0x20;
+        if (end - index > 1 || unit !== 0x20) {
+            if (2 * pairs + 2 > breaks.length) {
+                const grown = new Int32Array(breaks.length * 2);
+                grown.set(breaks);
+                breaks = grown;
+            }
+            breaks[2 * pairs] = length;
+            breaks[2 * pairs + 1] = end;
+            pairs += 1;
+        }
+        index = end - 1;
+    }
+    const chunks = [];
+    for (let start = 0; start < length; start += KEY_CHUNK) {
+        chunks.push(String.fromCharCode(...units.subarray(start, Math.min(length, start + KEY_CHUNK))));
+    }
+    return {
+        key: chunks.join(''),
+        at: (index) => {
+            // The last stretch starting at or before `index`; before the first run the key and the text agree.
+            let low = -1;
+            let high = pairs - 1;
+            while (low < high) {
+                const middle = (low + high + 1) >> 1;
+                if ((breaks[2 * middle] ?? 0) <= index)
+                    low = middle;
+                else
+                    high = middle - 1;
+            }
+            return low === -1 ? index : (breaks[2 * low + 1] ?? 0) + index - (breaks[2 * low] ?? 0);
+        },
+    };
+}
+/** Whether a UTF-16 unit is one `\s` matches: what `normalizeText` collapses. */
+function isWhitespace(unit) {
+    return (unit === 0x20 ||
+        (unit >= 0x09 && unit <= 0x0d) ||
+        unit === 0xa0 ||
+        unit === 0x1680 ||
+        (unit >= 0x2000 && unit <= 0x200a) ||
+        unit === 0x2028 ||
+        unit === 0x2029 ||
+        unit === 0x202f ||
+        unit === 0x205f ||
+        unit === 0x3000 ||
+        unit === 0xfeff);
+}
 /** One non-ASCII character's `caseKey`, the same length as `ch`. */
 function caseKeyOf(ch) {
     const upper = sameLength(ch.toUpperCase(), ch);
@@ -306,8 +394,9 @@ function leadingPartAtEnd(text, value, minimum) {
 /**
  * Every run of `FRAGMENT_LENGTH` characters of every value, mapped to the
  * index of the first value holding it; values come longest first, so a run
- * two values share names the longer one. The values come as `caseKey`
- * reads them, so a run in any case finds its owner.
+ * two values share names the longer one. The values come as `readingKey`
+ * reads them, so a run in any case or with its whitespace collapsed finds
+ * its owner.
  */
 function fragmentOwners(values) {
     const owners = new Map();
@@ -323,29 +412,30 @@ function fragmentOwners(values) {
 /**
  * `text` with every stretch whose windows of `FRAGMENT_LENGTH` characters
  * each occur in a value replaced by the marker of the value owning its first
- * window. Windows are looked up by `caseKey`, as `owners` is keyed, so a
- * fragment in another case is one too. The stretch grows one window at a time, so the
- * scan is linear in the text and a run spanning two values becomes one
- * marker.
+ * window. Windows are looked up by `readingKey`, as `owners` is keyed, so a
+ * fragment in another case or with another whitespace run is one too, and
+ * the stretch is cut back out of `text` whole, its whitespace runs included.
+ * The stretch grows one window at a time, so the scan is linear in the text
+ * and a run spanning two values becomes one marker.
  */
 function rewriteFragments(text, owners, markers) {
     if (owners.size === 0)
         return text;
-    const key = caseKey(text);
+    const { key, at } = readingKey(text);
     let out = '';
     let kept = 0;
     let start = 0;
-    while (start + FRAGMENT_LENGTH <= text.length) {
+    while (start + FRAGMENT_LENGTH <= key.length) {
         const owner = owners.get(key.slice(start, start + FRAGMENT_LENGTH));
         if (owner === undefined) {
             start += 1;
             continue;
         }
         let end = start + FRAGMENT_LENGTH;
-        while (end < text.length && owners.has(key.slice(end + 1 - FRAGMENT_LENGTH, end + 1)))
+        while (end < key.length && owners.has(key.slice(end + 1 - FRAGMENT_LENGTH, end + 1)))
             end += 1;
-        out += `${text.slice(kept, start)}${markers[owner] ?? ''}`;
-        kept = end;
+        out += `${text.slice(kept, at(start))}${markers[owner] ?? ''}`;
+        kept = at(end);
         start = end;
     }
     return out + text.slice(kept);
@@ -449,9 +539,12 @@ export class SecretLedger {
      * `FRAGMENT_LENGTH` characters, or half of a value shorter than twice that.
      * A cut is one position, so a boundary this short seldom matches plain text
      * by chance. Matched as the value is written, in any case (`caseKey`), as
-     * a CSS `text-transform` shows it: the cut falls on text as the engine read
-     * it, before any serializer spells it. A case mapping that changes length
-     * (`ß` to `SS`) is not followed, nor is collapsed whitespace. The part is found before whole values are
+     * a CSS `text-transform` shows it, and with every whitespace run on both
+     * sides read as one space (`readingKey`) and the value's leading whitespace
+     * dropped where whole-value matching trims it (`valuePattern`), as an
+     * engine that collapses text before cutting it shows it: the cut falls on
+     * text as the engine read it, before any serializer spells it. A case
+     * mapping that changes length (`ß` to `SS`) is not followed. The part is found before whole values are
      * rewritten, so a value that starts with another registered value is not
      * half rewritten as the shorter one, and an occurrence running into the
      * part joins its marker. Bound like `redact`.
@@ -463,7 +556,7 @@ export class SecretLedger {
      * becomes its marker. For a recording that keeps what an engine read raw
      * (a Playwright trace holds the page's cut text and selections), where a
      * value cut or selected partway through survives whole-value matching.
-     * Matched as the value is written, in any case, like `redactCut`. A
+     * Matched in any case and with whitespace runs collapsed, like `redactCut`. A
      * base64 or base64url run that decodes to text holding a value or a
      * fragment is rewritten whole (a basic-auth header the engine sent). Bound
      * like `redact`.

package/dist/internal/time.d.ts

@@ -30,6 +30,12 @@ export interface PollConditionOptions {
  * Polls a condition until it holds (or, when negated, until its negation has
  * held continuously for the negation grace window), throwing the caller's
  * error at the deadline.
+ *
+ * A negation holds from the moment the read that first saw it was issued, so
+ * a slow read counts toward the window. A budget shorter than the window
+ * still has to be satisfiable: the negation then only needs to hold for the
+ * whole budget, and passes at the deadline on what it has seen, since a read
+ * past the deadline has no budget left.
  */
 export declare function pollCondition(options: PollConditionOptions): Promise<void>;
 /** Races a promise against a timeout; on timeout invokes onTimeout to build the error. */

package/dist/internal/time.js

@@ -47,29 +47,41 @@ export const NEGATION_GRACE_MS = 1000;
  * Polls a condition until it holds (or, when negated, until its negation has
  * held continuously for the negation grace window), throwing the caller's
  * error at the deadline.
+ *
+ * A negation holds from the moment the read that first saw it was issued, so
+ * a slow read counts toward the window. A budget shorter than the window
+ * still has to be satisfiable: the negation then only needs to hold for the
+ * whole budget, and passes at the deadline on what it has seen, since a read
+ * past the deadline has no budget left.
  */
 export async function pollCondition(options) {
-    // A budget shorter than the grace window still has to be satisfiable: the
-    // negation then only needs to hold for the budget itself.
-    const grace = Math.min(NEGATION_GRACE_MS, Math.max(0, options.deadline.remaining()));
-    let negatedTrueSince;
+    const { deadline, negated } = options;
+    const startedAt = Date.now();
+    const grace = Math.min(NEGATION_GRACE_MS, deadline.remaining(startedAt));
+    let readAt = startedAt;
+    let holdingSince;
+    const holds = (now) => holdingSince !== undefined && now - holdingSince >= grace;
     for (;;) {
         const value = await options.evaluate();
-        if (!options.negated) {
+        if (!negated) {
             if (value === true)
                 return;
         }
-        else if (value === false) {
-            negatedTrueSince ??= Date.now();
-            if (Date.now() - negatedTrueSince >= grace)
-                return;
-        }
         else {
-            negatedTrueSince = undefined;
+            holdingSince = value === false ? (holdingSince ?? readAt) : undefined;
         }
-        if (options.deadline.expired())
+        const now = Date.now();
+        if (holds(now))
+            return;
+        if (deadline.expired(now))
             throw await options.onTimeout();
-        await sleep(POLL_INTERVAL_MS, options.signal);
+        await sleep(negated ? Math.min(POLL_INTERVAL_MS, deadline.remaining(now)) : POLL_INTERVAL_MS, options.signal);
+        readAt = Date.now();
+        if (negated && deadline.expired(readAt)) {
+            if (holds(readAt))
+                return;
+            throw await options.onTimeout();
+        }
     }
 }
 /** Races a promise against a timeout; on timeout invokes onTimeout to build the error. */

package/dist/internal/urls.d.ts

@@ -23,10 +23,12 @@ export declare function isLoopbackHost(hostname: string): boolean;
 /** True when environment may default to `test` (loopback, .localhost, .test hosts). */
 export declare function isImplicitTestHost(hostname: string): boolean;
 /**
- * Resolves a navigation URL against the base and refuses the schemes no test
- * may open. Returns the absolute URL string. Any http(s) origin is admitted:
- * a click can reach one just as well, so a gate on typed navigation alone
- * would guard nothing.
+ * Resolves a navigation URL against the base and refuses every scheme but
+ * http(s), except the exact `about:blank`. Returns the absolute URL string.
+ * Any http(s) origin is admitted: a click can reach one just as well, so a
+ * gate on typed navigation alone would guard nothing. The rule is an
+ * allowlist because a browser wraps and nests schemes (`view-source:file:`,
+ * `blob:`, `filesystem:`), and a list of forbidden ones misses the wrapper.
  */
 export declare function resolveNavigationUrl(input: string, base: NormalizedBaseUrl | undefined): {
     url: string;
@@ -53,5 +55,7 @@ export declare function sameSite(url: string | URL, site: string): boolean;
  * Relative expected strings resolve against the base URL; string comparison is
  * exact after WHATWG serialization; regexps test the complete serialized URL.
  * Anything else is `INVALID_ARGUMENT`, the `toTextPattern` rule.
+ * `ignoreCase` is Playwright's: `true` compares a string case-insensitively
+ * and adds the `i` flag to a regexp, `false` removes it.
  */
-export declare function urlMatches(current: string, expected: string | RegExp, baseHref: string): boolean;
+export declare function urlMatches(current: string, expected: string | RegExp, baseHref: string, ignoreCase?: boolean): boolean;

package/dist/internal/urls.js

@@ -1,7 +1,7 @@
 /** URL normalization and origin policy helpers. */
 import { ConfigurationError } from './errors.js';
 import { testPattern } from './regexp.js';
-import { toTextPattern } from './text.js';
+import { toTextPattern, withIgnoreCase } from './text.js';
 /**
  * Parses and normalizes the app base URL. Rejects userinfo, query, and
  * fragment. WHATWG parsing handles IDNA ASCII hosts, dot segments, and
@@ -94,12 +94,16 @@ export function isLoopbackHost(hostname) {
 export function isImplicitTestHost(hostname) {
     return isLoopbackHost(hostname) || hostname.endsWith('.test');
 }
-const FORBIDDEN_PROTOCOLS = new Set(['file:', 'data:', 'javascript:']);
+const NAVIGABLE_PROTOCOLS = new Set(['http:', 'https:']);
+/** The one non-http(s) page navigation opens: empty, with no local or inline content. */
+const BLANK_PAGE = 'about:blank';
 /**
- * Resolves a navigation URL against the base and refuses the schemes no test
- * may open. Returns the absolute URL string. Any http(s) origin is admitted:
- * a click can reach one just as well, so a gate on typed navigation alone
- * would guard nothing.
+ * Resolves a navigation URL against the base and refuses every scheme but
+ * http(s), except the exact `about:blank`. Returns the absolute URL string.
+ * Any http(s) origin is admitted: a click can reach one just as well, so a
+ * gate on typed navigation alone would guard nothing. The rule is an
+ * allowlist because a browser wraps and nests schemes (`view-source:file:`,
+ * `blob:`, `filesystem:`), and a list of forbidden ones misses the wrapper.
  */
 export function resolveNavigationUrl(input, base) {
     let url;
@@ -114,7 +118,7 @@ export function resolveNavigationUrl(input, base) {
         }
         throw new ConfigurationError('POLICY_DENIED', `malformed URL: ${input}`);
     }
-    if (FORBIDDEN_PROTOCOLS.has(url.protocol)) {
+    if (!NAVIGABLE_PROTOCOLS.has(url.protocol) && url.href !== BLANK_PAGE) {
         throw new ConfigurationError('POLICY_DENIED', `forbidden URL scheme: ${url.protocol}`);
     }
     return { url: url.href };
@@ -160,9 +164,11 @@ export function sameSite(url, site) {
  * Relative expected strings resolve against the base URL; string comparison is
  * exact after WHATWG serialization; regexps test the complete serialized URL.
  * Anything else is `INVALID_ARGUMENT`, the `toTextPattern` rule.
+ * `ignoreCase` is Playwright's: `true` compares a string case-insensitively
+ * and adds the `i` flag to a regexp, `false` removes it.
  */
-export function urlMatches(current, expected, baseHref) {
-    const pattern = toTextPattern(expected);
+export function urlMatches(current, expected, baseHref, ignoreCase) {
+    const pattern = withIgnoreCase(toTextPattern(expected), ignoreCase);
     if (pattern.kind === 'regexp') {
         return testPattern(pattern.source, pattern.flags, serializeForComparison(current));
     }
@@ -173,7 +179,10 @@ export function urlMatches(current, expected, baseHref) {
     catch {
         return false;
     }
-    return serializeForComparison(current) === expectedUrl.href;
+    const actual = serializeForComparison(current);
+    return ignoreCase === true
+        ? actual.toLowerCase() === expectedUrl.href.toLowerCase()
+        : actual === expectedUrl.href;
 }
 function serializeForComparison(url) {
     try {

package/dist/locator/engine.d.ts

@@ -18,6 +18,11 @@ export declare function attributeOf(node: SemanticNode, name: string): string |
  * empty or absent.
  */
 export declare function denySecureRead(nodes: readonly SemanticNode[], label: string): void;
+/**
+ * What a frame the engine reports missing means to a resolve: `wait` treats
+ * it like a node that is not there yet, `empty` answers zero matches.
+ */
+type MissingFrame = 'wait' | 'empty';
 interface LocatorEngineOptions {
     readonly session: TargetSession;
     /** The running phase's signal and deadline, read per operation. */
@@ -95,8 +100,13 @@ export declare class LocatorEngine {
     /** Reads every current match at once, for `allTextContents`: a missing frame reads as no matches. */
     readAllNow(expression: LocatorExpression): Promise<readonly SemanticNode[]>;
     private readEvery;
-    /** Reads one node for polling surfaces; returns null while zero matches. */
-    tryRead(expression: LocatorExpression, deadline: Deadline): Promise<{
+    /**
+     * Reads one node for polling surfaces; returns null while zero matches.
+     * A poll that waits for absence passes `missingFrame: 'empty'`: nothing
+     * under a frame that is not in the document is attached, so the sample is
+     * zero matches rather than a wait for the frame.
+     */
+    tryRead(expression: LocatorExpression, deadline: Deadline, missingFrame?: MissingFrame): Promise<{
         node: SemanticNode | null;
         count: number;
     }>;

package/dist/locator/engine.js

@@ -213,9 +213,14 @@ export class LocatorEngine {
             }
         }
     }
-    /** Reads one node for polling surfaces; returns null while zero matches. */
-    async tryRead(expression, deadline) {
-        return this.readOne(expression, deadline, 'wait');
+    /**
+     * Reads one node for polling surfaces; returns null while zero matches.
+     * A poll that waits for absence passes `missingFrame: 'empty'`: nothing
+     * under a frame that is not in the document is attached, so the sample is
+     * zero matches rather than a wait for the frame.
+     */
+    async tryRead(expression, deadline, missingFrame = 'wait') {
+        return this.readOne(expression, deadline, missingFrame);
     }
     /**
      * Reads the one current match at once, for `isVisible` and `isHidden`:

package/dist/locator/screen.js

@@ -55,6 +55,27 @@ const TEXT_OPTION_KEYS = ['exact', 'visible'];
 const ROLE_FILTER_KEYS = [...TEXT_OPTION_KEYS, 'checked', 'disabled', 'selected', 'expanded', 'pressed', 'level'];
 /** The keys of `RoleOptions`: the accessible name and the filters. */
 const ROLE_OPTION_KEYS = ['name', ...ROLE_FILTER_KEYS];
+/** The states `locator.waitFor` waits for, Playwright's four. */
+const WAIT_FOR_STATES = ['attached', 'detached', 'visible', 'hidden'];
+/** The states absence satisfies: a frame missing from the document reads as zero matches for them. */
+const ABSENCE_STATES = new Set(['detached', 'hidden']);
+/**
+ * Whether the one match, or its absence, is in `state`: `attached` is any
+ * match, `detached` none, `visible` a match that is not hidden, and `hidden`
+ * a hidden match or none.
+ */
+function inWaitForState(node, state) {
+    switch (state) {
+        case 'attached':
+            return node !== null;
+        case 'detached':
+            return node === null;
+        case 'visible':
+            return isNodeVisible(node);
+        case 'hidden':
+            return !isNodeVisible(node);
+    }
+}
 class ScreenImpl {
     context;
     scope;
@@ -361,7 +382,11 @@ class LocatorImpl extends ScreenImpl {
         return nodes.map((node) => normalizeText(node.text ?? ''));
     }
     async waitFor(options) {
-        const state = options?.state ?? 'visible';
+        rejectUnknownOptions('waitFor', options, ['state', 'timeout']);
+        const state = options?.state === undefined ? 'visible' : options.state;
+        if (!WAIT_FOR_STATES.includes(state)) {
+            throw new TestError('INVALID_ARGUMENT', `waitFor state must be one of ${WAIT_FOR_STATES.join(', ')}, got ${JSON.stringify(state)}`);
+        }
         await this.context.steps.run('locator', 'locator.waitFor', `${this.label} → ${state}`, async () => {
             const { engine } = this.context;
             const deadline = engine.deadline(options?.timeout);
@@ -371,9 +396,8 @@ class LocatorImpl extends ScreenImpl {
                 signal: engine.signal,
                 negated: false,
                 evaluate: async () => {
-                    const { node } = await engine.tryRead(this.expression, deadline);
-                    const visible = isNodeVisible(node);
-                    return state === 'visible' ? visible : !visible;
+                    const { node } = await engine.tryRead(this.expression, deadline, ABSENCE_STATES.has(state) ? 'empty' : 'wait');
+                    return inWaitForState(node, state);
                 },
                 onTimeout: () => new TestError('LOCATOR_NOT_FOUND', `locator did not become ${state}: ${this.label}`, {
                     details: locatorDetails(this.expression, Date.now() - startedMs),

package/dist/mcp/catalog.d.ts

@@ -12,6 +12,7 @@
  */
 import type { ToolSet } from 'ai';
 import type { StepExecutorContext } from '../agent/executor.ts';
+import { type NodeRedaction } from '../agent/observation.ts';
 import type { ScreenPresenter } from '../agent/screen-update.ts';
 import type { LocatorExpression, SemanticNode, TargetSession } from '../engine/surface.ts';
 import type { LocatorEngine } from '../locator/engine.ts';
@@ -35,7 +36,7 @@ export interface CatalogOptions {
     /** The agent's project tools (`agents.<name>.tools`), served beside the built-in ones. */
     readonly tools: Readonly<Record<string, AgentTool>>;
     /** The attempt's secret ledger: what `locate` shows of a node passes through it, as `observe` does. */
-    readonly redact: (text: string) => string;
+    readonly redaction: NodeRedaction;
     /** The session's recorder, when the engine records video. */
     readonly recorder: SessionRecorder | undefined;
     readonly warn: (message: string) => void;
@@ -60,4 +61,4 @@ export interface LocateQuery {
 /** Builds the expression and the matching `screen.*` call from the tool arguments. */
 export declare function locateQuery(args: LocateArgs): LocateQuery;
 /** Renders a locate result: the count, the verdict a test would get, and the nodes, each through the attempt's redactor. */
-export declare function describeLocate(query: LocateQuery, count: number, nodes: readonly SemanticNode[], redact: (text: string) => string): string;
+export declare function describeLocate(query: LocateQuery, count: number, nodes: readonly SemanticNode[], redaction: NodeRedaction): string;

package/dist/mcp/catalog.js

@@ -12,7 +12,7 @@
  */
 import { z } from 'zod';
 import { projectTools } from '../agent/default-agent.js';
-import { projectTree } from '../agent/observation.js';
+import { projectTree, redactNode } from '../agent/observation.js';
 import { GRAMMAR_TOOL_NAMES } from '../agent/action-names.js';
 import { createGrammarTools } from '../agent/primitives.js';
 import { ConfigurationError } from '../internal/errors.js';
@@ -34,7 +34,7 @@ export function createSessionCatalog(options) {
     const builtIn = {
         observe: fullObserveTool(context, screen),
         ...verbs,
-        locate: locateTool(options.locator, options.session, options.redact),
+        locate: locateTool(options.locator, options.session, options.redaction),
         ...recording,
     };
     const defined = options.tools;
@@ -65,7 +65,7 @@ function fullObserveTool(context, screen) {
     };
 }
 /** The session's `locate`: a semantic locator tried against the live screen, with the verdict a test would get. */
-function locateTool(locator, session, redact) {
+function locateTool(locator, session, redaction) {
     return {
         description: 'Try a semantic locator against the live screen before writing it into a test: screen.getByRole(role, name), getByText, getByLabel, getByPlaceholder, or getByTestId. Returns how many nodes match and which, plus the test code to use. Exactly one of role, text, label, placeholder, or testId; name narrows a role query. Matching is exact unless exact is false.',
         inputSchema: z.object({
@@ -84,7 +84,7 @@ function locateTool(locator, session, redact) {
             for (const ref of refs.slice(0, MAX_LOCATE_NODES)) {
                 read.push(await session.read(ref, locator.operation()));
             }
-            return describeLocate(query, refs.length, read, redact);
+            return describeLocate(query, refs.length, read, redaction);
         },
     };
 }
@@ -115,7 +115,7 @@ export function locateQuery(args) {
     return { expression: textQuery('placeholder', placeholder, { exact }, undefined), code: `screen.getByPlaceholder(${JSON.stringify(placeholder)}${options})` };
 }
 /** Renders a locate result: the count, the verdict a test would get, and the nodes, each through the attempt's redactor. */
-export function describeLocate(query, count, nodes, redact) {
+export function describeLocate(query, count, nodes, redaction) {
     const lines = [`${count === 1 ? '1 node matches' : `${count} nodes match`} ${describeExpression(query.expression)}.`];
     if (count === 1)
         lines.push(`Use: ${query.code}`);
@@ -124,7 +124,7 @@ export function describeLocate(query, count, nodes, redact) {
     else
         lines.push(`A test action on ${query.code} would fail with LOCATOR_AMBIGUOUS. Narrow it with a name, getByRole(role, name), .filter({ hasText }), .first(), or .nth(i), or scope it under a container.`);
     for (const node of nodes)
-        lines.push(`- ${describeNode(projectTree(node, redact))}`);
+        lines.push(`- ${describeNode(projectTree(redactNode(node, redaction)))}`);
     if (count > nodes.length)
         lines.push(`- and ${count - nodes.length} more`);
     return lines.join('\n');

package/dist/mcp/session.js

@@ -207,7 +207,7 @@ export class SessionHost {
                 screen,
                 session: attempt.session,
                 tools: config.agent.tools,
-                redact: attempt.agentRuntime.redact,
+                redaction: { redact: attempt.agentRuntime.redact, redactCut: attempt.agentRuntime.redactCut },
                 recorder,
                 locator: new LocatorEngine({
                     session: attempt.session,

package/dist/oauth/chatgpt.js

@@ -6,8 +6,10 @@
  */
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOAuthFetch } from './fetch.js';
-import { USER_AGENT, loginHint } from './providers.js';
+import { USER_AGENT } from '../internal/client-identity.js';
+import { loginHint } from './providers.js';
 import { createCodexProvider } from './providers/openai.js';
+import { withoutServerStorage } from './responses.js';
 import { defaultCredentialStore } from './store.js';
 export function chatgpt(modelId) {
     const fetch = createOAuthFetch(createCodexProvider(), {
@@ -18,25 +20,3 @@ export function chatgpt(modelId) {
     // The key header is removed per request; the value only satisfies the constructor.
     return withoutServerStorage(createOpenAI({ apiKey: 'oauth', fetch, name: 'chatgpt' }).responses(modelId));
 }
-/**
- * Tells the SDK what the Codex backend enforces: nothing is stored server
- * side. Believing storage is on, the SDK refers back to an earlier turn's
- * reasoning by id (`item_reference`), which the backend then cannot find; told
- * it is off, the SDK carries the encrypted reasoning itself.
- */
-function withoutServerStorage(model) {
-    const storeOff = (options) => ({
-        ...options,
-        providerOptions: { ...options.providerOptions, openai: { ...options.providerOptions?.['openai'], store: false } },
-    });
-    return {
-        specificationVersion: model.specificationVersion,
-        provider: model.provider,
-        modelId: model.modelId,
-        get supportedUrls() {
-            return model.supportedUrls;
-        },
-        doGenerate: (options) => model.doGenerate(storeOff(options)),
-        doStream: (options) => model.doStream(storeOff(options)),
-    };
-}

package/dist/oauth/cli.js

@@ -121,6 +121,7 @@ async function signedIn() {
 const PROVIDER_HINTS = {
     openai: 'ChatGPT Plus/Pro, the Codex sign-in',
     'github-copilot': 'GitHub Copilot: OpenAI, Anthropic, Google, and SpaceXAI models',
+    'opencode-console': 'your OpenCode Console workspace',
     spacexai: 'SuperGrok or X Premium+',
 };
 /** A terminal picker over providers; without a terminal the provider has to be named. */

package/dist/oauth/copilot.d.ts

@@ -1,9 +1,10 @@
 /**
  * `copilot('claude-sonnet-5')`: a GitHub Copilot subscription as an AI SDK
- * model. Copilot serves OpenAI, Anthropic, Google, and SpaceXAI models over the
- * OpenAI chat protocol; the instance is `@ai-sdk/openai-compatible`'s chat
- * model at the Copilot API with a fetch that carries the stored login. An
- * enterprise login stored by `e2e login` routes to its own host.
+ * model. Copilot serves most of its models over the OpenAI chat protocol and
+ * some only over its Responses API; the instance asks the plan's model
+ * listing which on the first call and delegates to the matching model, so
+ * construction stays synchronous and touches the network only when a call
+ * does. An enterprise login stored by `e2e login` routes to its own host.
  */
 import type { LanguageModelV4 } from '@ai-sdk/provider';
 export declare function copilot(modelId: string): LanguageModelV4;