e2e 0.21.1 → 0.21.2

package/dist/cache/trace.d.ts

@@ -15,7 +15,10 @@
  * and a document this runner cannot replay verbatim comes back as
  * `undefined`, never as a repaired or partially trusted entry.
  */
+import { type KeyModifier } from '../engine/contract.ts';
 import type { ScrollDirection } from '../types.ts';
+import { type RecordedModel } from './trace-fields.ts';
+export type { RecordedModel } from './trace-fields.ts';
 export declare const TRACE_SCHEMA_VERSION = "trace-1";
 /** Mirrors the default step action budget; overflow marks the trace truncated. */
 export declare const MAX_TRACE_ACTIONS = 50;
@@ -121,6 +124,8 @@ interface ActionBase {
 /** The verbs that act on one node and carry no input: tap and its variants, hover, scroll into view. */
 declare const NODE_ACTION_NAMES: readonly ['tap', 'doubleTap', 'longPress', 'secondaryTap', 'hover', 'scrollTo'];
 export type NodeActionName = (typeof NODE_ACTION_NAMES)[number];
+/** Whether a node verb clicks, so it may carry `modifiers`. */
+export declare const isTapActionName: (value: unknown) => value is "doubleTap" | "secondaryTap" | "tap";
 /**
  * Whether an action is one of the node verbs. The every-layer switches over
  * an action union (prose, recording, templating, replay) take these six
@@ -134,6 +139,8 @@ export declare function isNodeAction<A extends {
 export interface NodeAction extends ActionBase {
     readonly name: NodeActionName;
     readonly target: TraceTargetDescriptor;
+    /** Keys a tap-family action held for the click; replayed with the action. */
+    readonly modifiers?: readonly KeyModifier[];
 }
 export interface TypeAction extends ActionBase {
     readonly name: 'type';
@@ -283,6 +290,8 @@ export interface ActionTrace {
     };
     /** Which test, target, and instruction recorded it; absent on older entries. */
     readonly recordedFor?: TraceProvenance;
+    /** Configured model when recorded; absent on older or unattributed entries. */
+    readonly recordedBy?: RecordedModel;
     /** The recorded run's verdict summary. */
     readonly summary: string;
     /**
@@ -372,4 +381,3 @@ export type TraceTextMap = (text: string) => string | undefined;
  * `undefined` from `map` makes the whole result `undefined`.
  */
 export declare function mapTraceText(trace: ActionTrace, map: TraceTextMap): ActionTrace | undefined;
-export {};

package/dist/cache/trace.js

@@ -15,8 +15,10 @@
  * and a document this runner cannot replay verbatim comes back as
  * `undefined`, never as a repaired or partially trusted entry.
  */
+import { isKeyModifier, KEY_MODIFIERS } from '../engine/contract.js';
 import { timestamp } from '../internal/ids.js';
 import { bound } from '../internal/text.js';
+import { readBoundedText, readRecordedModel } from './trace-fields.js';
 export const TRACE_SCHEMA_VERSION = 'trace-1';
 /** Mirrors the default step action budget; overflow marks the trace truncated. */
 export const MAX_TRACE_ACTIONS = 50;
@@ -81,6 +83,10 @@ const isTraceAnchorState = oneOf(TRACE_ANCHOR_STATES);
 /** The verbs that act on one node and carry no input: tap and its variants, hover, scroll into view. */
 const NODE_ACTION_NAMES = ['tap', 'doubleTap', 'longPress', 'secondaryTap', 'hover', 'scrollTo'];
 const isNodeActionName = oneOf(NODE_ACTION_NAMES);
+/** The node verbs that click: the only ones that may hold key modifiers. */
+const TAP_ACTION_NAMES = ['tap', 'doubleTap', 'secondaryTap'];
+/** Whether a node verb clicks, so it may carry `modifiers`. */
+export const isTapActionName = oneOf(TAP_ACTION_NAMES);
 /**
  * Whether an action is one of the node verbs. The every-layer switches over
  * an action union (prose, recording, templating, replay) take these six
@@ -172,6 +178,7 @@ function readActionTrace(document) {
     const recordedFor = recordedForRaw === undefined ? undefined : readProvenance(recordedForRaw);
     if (recordedForRaw !== undefined && recordedFor === undefined)
         return undefined;
+    const recordedBy = readRecordedModel(raw['recordedBy'], MAX_TRACE_DESCRIPTOR_CHARS);
     const summary = readBoundedText(raw['summary'], MAX_TRACE_SUMMARY_CHARS);
     if (summary === undefined)
         return undefined;
@@ -211,6 +218,7 @@ function readActionTrace(document) {
             ...(executorVersion === undefined ? {} : { version: executorVersion }),
         },
         ...(recordedFor === undefined ? {} : { recordedFor }),
+        ...(recordedBy === undefined ? {} : { recordedBy }),
         summary,
         ...(startPath === undefined ? {} : { startPath }),
         ...(endPath === undefined ? {} : { endPath }),
@@ -229,6 +237,18 @@ function readAnchors(document) {
         return undefined;
     return each(document, readDescriptor);
 }
+/** The `modifiers` of a recorded tap-family action: a non-empty list of distinct key modifiers, or undefined when malformed. */
+function readModifiers(document) {
+    if (!Array.isArray(document) || document.length === 0 || document.length > KEY_MODIFIERS.length)
+        return undefined;
+    const modifiers = [];
+    for (const value of document) {
+        if (!isKeyModifier(value) || modifiers.includes(value))
+            return undefined;
+        modifiers.push(value);
+    }
+    return modifiers;
+}
 function readRecordedAction(document) {
     if (typeof document !== 'object' || document === null || Array.isArray(document)) {
         return undefined;
@@ -240,7 +260,12 @@ function readRecordedAction(document) {
     const name = raw['name'];
     if (isNodeActionName(name)) {
         const target = readDescriptor(raw['target']);
-        return target === undefined ? undefined : { name, summary, target };
+        if (target === undefined)
+            return undefined;
+        if (raw['modifiers'] === undefined)
+            return { name, summary, target };
+        const modifiers = isTapActionName(name) ? readModifiers(raw['modifiers']) : undefined;
+        return modifiers === undefined ? undefined : { name, summary, target, modifiers };
     }
     switch (name) {
         case 'type': {
@@ -635,12 +660,6 @@ function readProvenance(document) {
         ...(agent === undefined ? {} : { agent }),
     };
 }
-function readBoundedText(value, maxChars) {
-    if (typeof value !== 'string' || value.trim() === '' || value.length > maxChars) {
-        return undefined;
-    }
-    return value;
-}
 /** One to `MAX_TRACE_UPLOAD_PATHS` verbatim paths, each a replay input like a typed value. */
 function readInputPaths(value) {
     if (!Array.isArray(value) || value.length === 0 || value.length > MAX_TRACE_UPLOAD_PATHS)

package/dist/cli/feedback.js

@@ -107,7 +107,8 @@ async function latestRelease(fetchImpl) {
         const response = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(LATEST_TIMEOUT_MS) });
         if (!response.ok)
             return undefined;
-        const { version } = (await response.json());
+        const body = await response.json();
+        const version = typeof body === 'object' && body !== null && 'version' in body ? body.version : undefined;
         return typeof version === 'string' && RELEASE.test(version) ? version : undefined;
     }
     catch {

package/dist/cli/init/sibling-versions.json

@@ -1 +1 @@
-{"@e2e-dev/web":"0.15.1","@e2e-dev/mobile":"0.12.2"}
+{"@e2e-dev/web":"0.15.2","@e2e-dev/mobile":"0.12.3"}

package/dist/collect/select.js

@@ -592,7 +592,9 @@ function shardItem(pair) {
  * come from as few files as possible; the slices differ in size by at most
  * one item, the first shards taking the remainder. Applied after every other
  * filter and the serial closure, before the setup tests are chosen, so each
- * shard brings only the setups it needs.
+ * shard brings only the setups it needs. A skipped test is not an item: the
+ * shard holding the item before it in report order reports it, the first
+ * shard when none comes before, so the shards together report it once.
  */
 function applyShard(pairs, shard) {
     const items = shardItems(pairs);
@@ -601,8 +603,16 @@ function applyShard(pairs, shard) {
     const from = (shard.index - 1) * size + Math.min(shard.index - 1, remainder);
     const to = from + size + (shard.index - 1 < remainder ? 1 : 0);
     const kept = new Set(items.slice(from, to));
+    let previousKept = shard.index === 1;
     return pairs.map((pair) => {
-        if (pair.disposition !== 'run' || pair.test.kind !== 'test' || kept.has(shardItem(pair)))
+        if (pair.test.kind !== 'test')
+            return pair;
+        if (pair.disposition === 'filtered')
+            return pair;
+        if (pair.disposition === 'skip')
+            return previousKept ? pair : { ...pair, disposition: 'filtered' };
+        previousKept = kept.has(shardItem(pair));
+        if (previousKept)
             return pair;
         return { ...pair, disposition: 'filtered', skip: { cause: 'filtered', reason: FILTERED_REASON.shard } };
     });

package/dist/config/agent.d.ts

@@ -22,7 +22,7 @@ export interface ResolvedModel {
     readonly model: ModelInstance;
 }
 /** A resolved model as reports and diagnostics name it: the instance's `provider/model-id`. */
-export declare function modelLabel(model: ResolvedModel): string;
+export declare function modelLabel(model: Pick<ResolvedModel, 'provider' | 'id'>): string;
 export interface ResolvedAgentConfig {
     /**
      * The custom brain `agent.act()` dispatches to (`agents.<name>.executor`);

package/dist/config/diagnose.js

@@ -8,6 +8,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { withHint } from '../internal/errors.js';
+import { isPlainObject } from '../internal/options.js';
 import { addDevDependencyCommand, detectPackageManager } from '../internal/package-manager.js';
 import { didYouMean, suggest } from '../internal/suggest.js';
 /** The runtime exports of `e2e`; a unit test keeps this list equal to the real module. */
@@ -104,9 +105,12 @@ function subpathHint(subpath, manifestPath) {
     catch {
         return '';
     }
-    const name = typeof parsed.name === 'string' ? parsed.name : path.basename(path.dirname(manifestPath));
-    const entries = typeof parsed.exports === 'object' && parsed.exports !== null && !Array.isArray(parsed.exports)
-        ? Object.keys(parsed.exports).filter((key) => key.startsWith('.'))
+    if (!isPlainObject(parsed))
+        return '';
+    const name = typeof parsed['name'] === 'string' ? parsed['name'] : path.basename(path.dirname(manifestPath));
+    const exported = parsed['exports'];
+    const entries = typeof exported === 'object' && exported !== null && !Array.isArray(exported)
+        ? Object.keys(exported).filter((key) => key.startsWith('.'))
         : ['.'];
     const specifiers = entries.map((entry) => (entry === '.' ? name : `${name}/${entry.slice(2)}`));
     const attempted = `${name}/${subpath.replace(/^\.\//, '')}`;
@@ -136,6 +140,8 @@ function nearestManifest(dir) {
         if (existsSync(manifestPath)) {
             try {
                 const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+                if (!isPlainObject(parsed))
+                    return undefined;
                 const dependencies = new Set();
                 for (const block of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
                     const section = parsed[block];

package/dist/config/esm-hooks.js

@@ -89,13 +89,14 @@ function directoryMain(directory, view) {
     const manifest = path.join(directory, 'package.json');
     if (!view.isFile(manifest))
         return undefined;
-    let main;
+    let parsed;
     try {
-        ({ main } = JSON.parse(readFileSync(manifest, 'utf8')));
+        parsed = JSON.parse(readFileSync(manifest, 'utf8'));
     }
     catch {
         return undefined;
     }
+    const main = typeof parsed === 'object' && parsed !== null && 'main' in parsed ? parsed.main : undefined;
     return typeof main === 'string' && main !== '' ? path.resolve(directory, main) : undefined;
 }
 /**

package/dist/config/resolve.js

@@ -555,8 +555,9 @@ function resolveProjectId(explicit, projectRoot) {
     if (existsSync(packageJsonPath)) {
         try {
             const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-            if (typeof parsed.name === 'string' && parsed.name.length > 0)
-                return parsed.name;
+            const name = isRecord(parsed) ? parsed['name'] : undefined;
+            if (typeof name === 'string' && name.length > 0)
+                return name;
         }
         catch {
             // fall through to hashed identity

package/dist/config/typescript.js

@@ -11,6 +11,8 @@ import remapping, {} from '@jridgewell/remapping';
 import { createRequire } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { InfrastructureError } from '../internal/errors.js';
+import { obj } from '../internal/objects.js';
+import { isPlainObject } from '../internal/options.js';
 import { HOOKED_REQUIRE_KEY } from './compiled-files.js';
 const ownRequire = createRequire(import.meta.url);
 /** oxc's transformer and parser, loaded on first use. */
@@ -220,6 +222,53 @@ function withOwnHelpers(code, helpers, format) {
 }
 /** An inline source map at the end of `source`, as another loader earlier in the chain leaves one. */
 const INLINE_MAP = /\n\/\/# sourceMappingURL=data:application\/json(?:;charset=utf-8)?;base64,([A-Za-z0-9+/=]+)\s*$/;
+/** Whether `value` is an array whose every entry passes `is`. */
+function isArrayOf(value, is) {
+    return Array.isArray(value) && value.every(is);
+}
+/** Whether `entry` is a string. */
+function isString(entry) {
+    return typeof entry === 'string';
+}
+/** Whether `entry` is a string or null, as a source map's `sources` and `sourcesContent` hold. */
+function isStringOrNull(entry) {
+    return entry === null || typeof entry === 'string';
+}
+/** Whether `entry` is an integer, as a source map's `ignoreList` holds. */
+function isInteger(entry) {
+    return Number.isInteger(entry);
+}
+/**
+ * The source map an earlier loader inlined as base64 JSON, rebuilt from the
+ * fields composing it reads, or undefined when it is malformed. A malformed
+ * map is left out rather than failing the import, so positions lead to the
+ * code that loader handed over.
+ */
+function inlineSourceMap(base64) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(base64, 'base64').toString('utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!isPlainObject(parsed))
+        return undefined;
+    const { mappings, sources } = parsed;
+    const names = parsed['names'] ?? [];
+    const sourceRoot = parsed['sourceRoot'] ?? undefined;
+    const sourcesContent = parsed['sourcesContent'] ?? undefined;
+    const ignoreList = parsed['ignoreList'] ?? parsed['x_google_ignoreList'] ?? undefined;
+    if (typeof mappings !== 'string' ||
+        !isArrayOf(sources, isStringOrNull) ||
+        !isArrayOf(names, isString) ||
+        (sourceRoot !== undefined && typeof sourceRoot !== 'string') ||
+        (sourcesContent !== undefined && !isArrayOf(sourcesContent, isStringOrNull)) ||
+        (ignoreList !== undefined && !isArrayOf(ignoreList, isInteger))) {
+        return undefined;
+    }
+    return { version: 3, mappings, sources, names, ...obj({ sourceRoot, sourcesContent, ignoreList }) };
+}
 /**
  * `source`, the content of `file` as the next loader handed it over,
  * compiled to JavaScript for its kind with `compilerOptions`, with an
@@ -247,7 +296,8 @@ export function compileTypeScript(file, source, kind, compilerOptions) {
         ({ code, mappings } = runnableCommonJs(file, code, mappings));
     // Absolute, so a frame names the file without the loader's query, whatever characters its name holds.
     const own = { version: 3, mappings, names: result.map?.names ?? [], sources: [pathToFileURL(file).href] };
-    const incoming = INLINE_MAP.exec(source)?.[1];
-    const map = incoming === undefined ? own : remapping([own, JSON.parse(Buffer.from(incoming, 'base64').toString('utf8'))], () => null);
+    const encoded = INLINE_MAP.exec(source)?.[1];
+    const incoming = encoded === undefined ? undefined : inlineSourceMap(encoded);
+    const map = incoming === undefined ? own : remapping([own, incoming], () => null);
     return `${code}\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString('base64')}\n`;
 }

package/dist/engine/contract.d.ts

@@ -148,8 +148,9 @@ export interface SemanticNode {
      * The node's test id, when the platform gives it one: the value of the
      * project's test-id attribute on a document platform, an accessibility
      * identifier on iOS, a resource id on Android, an automation id on a
-     * desktop. The `testId` query resolves against exactly this field, so the
-     * harness never knows where a platform keeps it.
+     * desktop. The `testId` query resolves against this field, so the harness
+     * never knows where a platform keeps it. An engine may also match the id
+     * without its platform's namespacing.
      */
     readonly testId?: string;
     /** What a field takes, deciding which secrets may fill it. */

package/dist/engine/manifest.js

@@ -155,7 +155,7 @@ export function defineEngine(spec) {
     }
     const name = spec.name;
     if (typeof spec.version !== 'string' || spec.version.trim() === '') {
-        throw invalid(name, 'version must be a non-empty string; it is provenance and keys the replay cache');
+        throw invalid(name, 'version must be a non-empty string; it is recorded in reports and keys saved sessions');
     }
     if (spec.spiVersion !== ENGINE_SPI_VERSION) {
         throw invalid(name, `declares spiVersion ${String(spec.spiVersion)}; this runner supports ${ENGINE_SPI_VERSION}`);
@@ -285,7 +285,7 @@ export function defineEngine(spec) {
         handle['secrets'] = declaredSecrets(name, spec.secrets);
     if (spec.session !== undefined)
         handle['session'] = hookManifest(name, 'session', spec.session);
-    // Assembled key by key above, so the record is an Engine by construction.
+    // oxlint-disable-next-line e2e/no-chained-type-assertions -- assembled key by key above, so the record is an Engine by construction
     return Object.freeze({
         ...handle,
         [engineBrand]: true,

package/dist/internal/errors.js

@@ -136,10 +136,10 @@ export function asEngineError(value) {
         return value;
     if (!(value instanceof Error) || value.name !== 'EngineError')
         return undefined;
-    const code = value.code;
+    const code = 'code' in value ? value.code : undefined;
     if (!isEngineErrorCode(code))
         return undefined;
-    const retryable = value.retryable === true;
+    const retryable = 'retryable' in value && value.retryable === true;
     if (retryable && !RETRYABLE_ENGINE_ERROR_CODES.has(code)) {
         return { code: 'ENGINE_FAILURE', message: value.message, retryable: false };
     }
@@ -178,8 +178,11 @@ const CATEGORIES = new Set([
  */
 export function isE2EError(value) {
     return (value instanceof Error &&
+        E2E_ERROR_MARKER in value &&
         value[E2E_ERROR_MARKER] === true &&
+        'category' in value &&
         CATEGORIES.has(value.category) &&
+        'code' in value &&
         typeof value.code === 'string');
 }
 export class ConfigurationError extends E2EError {

package/dist/internal/source.js

@@ -35,6 +35,8 @@ export function userFrame(stack, projectRoot) {
         if (match === null)
             continue;
         const [, location, line, column] = match;
+        if (location === undefined || line === undefined || column === undefined)
+            continue;
         const withoutQuery = location.split('?')[0];
         let file;
         try {

package/dist/internal/unserved-model.d.ts

@@ -0,0 +1,5 @@
+/** A model constructor's mark on a provider failure meaning the account cannot use the model, with the explanation a user reads; a well-known symbol, so it survives two loaded copies of the package. */
+/** Marks `failure` as a model the account cannot use, with the explanation a user reads, and returns it. */
+export declare function markUnservedModel<Failure extends Error>(failure: Failure, explanation: string): Failure;
+/** The explanation `failure`, or the last attempt of its spent retry chain, was marked with; read by shape, before any SDK loaded. */
+export declare function unservedModelExplanation(failure: unknown): string | undefined;

package/dist/internal/unserved-model.js

@@ -0,0 +1,22 @@
+/** A model constructor's mark on a provider failure meaning the account cannot use the model, with the explanation a user reads; a well-known symbol, so it survives two loaded copies of the package. */
+const UNSERVED_MODEL = Symbol.for('e2e.unserved-model.v1');
+/** Marks `failure` as a model the account cannot use, with the explanation a user reads, and returns it. */
+export function markUnservedModel(failure, explanation) {
+    Object.defineProperty(failure, UNSERVED_MODEL, { value: explanation });
+    return failure;
+}
+/** The explanation `failure`, or the last attempt of its spent retry chain, was marked with; read by shape, before any SDK loaded. */
+export function unservedModelExplanation(failure) {
+    const attempt = lastAttempt(failure);
+    if (!(attempt instanceof Error))
+        return undefined;
+    const explanation = Reflect.get(attempt, UNSERVED_MODEL);
+    return typeof explanation === 'string' ? explanation : undefined;
+}
+/** The last attempt of a spent retry chain, else `failure` itself; a chain the deadline cut short stays whole. */
+function lastAttempt(failure) {
+    if (!(failure instanceof Error) || failure.name !== 'AI_RetryError')
+        return failure;
+    const chain = failure;
+    return chain.reason !== 'abort' && chain.lastError !== undefined ? chain.lastError : failure;
+}

package/dist/locator/screen.js

@@ -12,7 +12,7 @@ import { obj } from '../internal/objects.js';
 import { isTextMatch, normalizeText } from '../internal/text.js';
 import { attributeOf, denySecureRead, isNodeVisible, locatorDetails } from './engine.js';
 import { describeExpression, filterExpression, indexExpression, roleQuery, testIdQuery, textQuery, } from './expression.js';
-import { cutOffAtDeadline, isOperationTimeout, POLL_INTERVAL_MS, pollCondition, sleep } from '../internal/time.js';
+import { cutOffAtDeadline, isOperationTimeout, POLL_INTERVAL_MS, pollCondition } from '../internal/time.js';
 import { SampleHistory } from '../expect/samples.js';
 /**
  * Internals hang off the locator object itself under a global symbol so that
@@ -194,7 +194,6 @@ class ScreenImpl {
                     }
                     throw cause;
                 }
-                await sleep(Math.min(POLL_INTERVAL_MS, deadline.remaining()), engine.signal);
             }
         });
     }

package/dist/oauth/copilot.js

@@ -10,8 +10,9 @@ import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 import { OAuthError } from './errors.js';
 import { createOAuthFetch } from './fetch.js';
 import { USER_AGENT } from '../internal/client-identity.js';
+import { markUnservedModel } from '../internal/unserved-model.js';
 import { loginHint } from './providers.js';
-import { COPILOT_API_URL, copilotProtocolFor, createCopilotProvider } from './providers/github-copilot.js';
+import { COPILOT_API_URL, copilotProtocolFor, copilotRefusal, createCopilotProvider, isCopilotRefusal } from './providers/github-copilot.js';
 import { withoutServerStorage } from './responses.js';
 import { defaultCredentialStore } from './store.js';
 /** How long the first call waits on the model listing before it calls over chat and asks again next time. */
@@ -30,7 +31,7 @@ export function copilot(modelId) {
         fetch,
         includeUsage: true,
     }).chatModel(modelId);
-    return protocolDelegate(chat, () => responsesModel(modelId, fetch), () => copilotProtocolFor(modelId, fetch, AbortSignal.timeout(LISTING_TIMEOUT_MS)));
+    return protocolDelegate(chat, () => responsesModel(modelId, fetch), () => copilotProtocolFor(modelId, fetch, AbortSignal.timeout(LISTING_TIMEOUT_MS)), modelId);
 }
 /**
  * The Responses model for `modelId`. `@ai-sdk/openai` is imported only here,
@@ -52,8 +53,9 @@ async function responsesModel(modelId, fetch) {
  * own timeout, so a caller that gives up never fails the others. Only a
  * listing that was read is remembered: when it could not be read, that call
  * goes over chat, the endpoint most models use, and the next call asks again.
+ * A call Copilot refuses with `model_not_supported` is marked for the runner.
  */
-function protocolDelegate(chat, responses, lookup) {
+function protocolDelegate(chat, responses, lookup, modelId) {
     let resolved;
     let pending;
     const settle = () => {
@@ -70,6 +72,8 @@ function protocolDelegate(chat, responses, lookup) {
         });
         return pending;
     };
+    /** The failure as the runner reads it: a refusal of the model to this account carries the explanation. */
+    const refused = (cause) => (isCopilotRefusal(cause) ? markUnservedModel(cause, copilotRefusal(modelId)) : cause);
     return {
         specificationVersion: chat.specificationVersion,
         get provider() {
@@ -81,8 +85,22 @@ function protocolDelegate(chat, responses, lookup) {
         get supportedUrls() {
             return resolved?.supportedUrls ?? chat.supportedUrls;
         },
-        doGenerate: async (options) => (await untilAborted(settle(), options.abortSignal)).doGenerate(options),
-        doStream: async (options) => (await untilAborted(settle(), options.abortSignal)).doStream(options),
+        doGenerate: async (options) => {
+            try {
+                return await (await untilAborted(settle(), options.abortSignal)).doGenerate(options);
+            }
+            catch (cause) {
+                throw refused(cause);
+            }
+        },
+        doStream: async (options) => {
+            try {
+                return await (await untilAborted(settle(), options.abortSignal)).doStream(options);
+            }
+            catch (cause) {
+                throw refused(cause);
+            }
+        },
     };
 }
 /** Waits for `promise` unless `signal` aborts first, leaving the shared promise running for other callers. */

package/dist/oauth/device-code.js

@@ -5,8 +5,9 @@
  * `rfc8628Flow` is the standard shape itself, which GitHub and SpaceXAI both
  * speak apart from the status code they answer "pending" with.
  */
-import { OAuthError, describeResponse } from './errors.js';
-import { positiveSeconds, postForm } from './token-endpoint.js';
+import { z } from 'zod';
+import { OAuthError, describeResponse, readJsonBody } from './errors.js';
+import { parseTokens, positiveSeconds, postForm } from './token-endpoint.js';
 const DEFAULT_INTERVAL_S = 5;
 const MIN_INTERVAL_MS = 1_000;
 const SLOW_DOWN_INCREMENT_MS = 5_000;
@@ -69,6 +70,23 @@ function throwIfCancelled(signal) {
     if (signal?.aborted)
         throw new OAuthError('CANCELLED', 'the login was cancelled');
 }
+/** The device authorization response, as far as the flow reads it; the timing values stay raw for `positiveSeconds`. */
+const DeviceCodeSchema = z.object({
+    device_code: z.string(),
+    user_code: z.string(),
+    verification_uri: z.string(),
+    verification_uri_complete: z.string().optional().catch(undefined),
+    expires_in: z.unknown().optional(),
+    interval: z.unknown().optional(),
+});
+/** The error fields of a poll that granted nothing; a field of another type, or a body that is not an object, names nothing. */
+const DevicePollErrorSchema = z
+    .object({
+    error: z.string().optional().catch(undefined),
+    error_description: z.string().optional().catch(undefined),
+    interval: z.number().optional().catch(undefined),
+})
+    .catch({});
 /** The standard device flow; the poll reads the body before the status, since vendors disagree on the status for "pending". */
 export function rfc8628Flow(options) {
     const { vendor, clientId, callbacks } = options;
@@ -78,37 +96,35 @@ export function rfc8628Flow(options) {
             const response = await postForm(options.deviceCodeUrl, { client_id: clientId, ...options.request }, signal);
             if (!response.ok)
                 throw new OAuthError('FLOW_FAILED', `${vendor} device login could not start: ${await describeResponse(response)}`);
-            const json = (await response.json());
-            const { device_code, user_code, verification_uri, verification_uri_complete } = json;
-            if (typeof device_code !== 'string' || typeof user_code !== 'string' || typeof verification_uri !== 'string') {
-                throw new OAuthError('FLOW_FAILED', `the ${vendor} device code response is missing fields`);
-            }
+            const device = await readJsonBody(response, DeviceCodeSchema, `the ${vendor} device code response`, 'is missing fields');
             return {
-                deviceCode: device_code,
-                userCode: user_code,
-                verificationUri: verification_uri,
-                ...(typeof verification_uri_complete === 'string' ? { verificationUriComplete: verification_uri_complete } : {}),
-                expiresIn: Number(json['expires_in']),
-                interval: Number(json['interval']),
+                deviceCode: device.device_code,
+                userCode: device.user_code,
+                verificationUri: device.verification_uri,
+                ...(device.verification_uri_complete === undefined ? {} : { verificationUriComplete: device.verification_uri_complete }),
+                expiresIn: Number(device.expires_in),
+                interval: Number(device.interval),
             };
         },
         async poll(authorization, signal) {
             const response = await postForm(options.tokenUrl, { grant_type: 'urn:ietf:params:oauth:grant-type:device_code', client_id: clientId, device_code: authorization.deviceCode }, signal);
-            const json = (await response.json().catch(() => ({})));
-            if (typeof json['access_token'] === 'string' && json['access_token'] !== '')
-                return { status: 'granted', value: json };
-            switch (json['error']) {
+            const body = await response.json().catch(() => undefined);
+            const tokens = parseTokens(body);
+            if (tokens !== undefined)
+                return { status: 'granted', value: tokens };
+            const { error, error_description, interval } = DevicePollErrorSchema.parse(body);
+            switch (error) {
                 case 'authorization_pending':
                     return { status: 'pending' };
                 case 'slow_down':
-                    return typeof json['interval'] === 'number' ? { status: 'slow_down', intervalSeconds: json['interval'] } : { status: 'slow_down' };
+                    return interval === undefined ? { status: 'slow_down' } : { status: 'slow_down', intervalSeconds: interval };
                 case 'access_denied':
                 case 'authorization_denied':
                     return { status: 'denied' };
                 case 'expired_token':
                     return { status: 'expired' };
                 default:
-                    throw new OAuthError('FLOW_FAILED', `${vendor} device login failed: ${String(json['error_description'] ?? json['error'] ?? response.status)}`);
+                    throw new OAuthError('FLOW_FAILED', `${vendor} device login failed: ${error_description ?? error ?? response.status}`);
             }
         },
     });

package/dist/oauth/errors.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export type OAuthErrorCode = 
 /** No stored credentials for the provider. */
 'NOT_LOGGED_IN'
@@ -20,3 +21,5 @@ export declare class OAuthError extends Error {
 }
 /** Reads an error body for a message without assuming JSON. */
 export declare function describeResponse(response: Response): Promise<string>;
+/** A response's or request's JSON body checked against `schema`; FLOW_FAILED as `<subject> is not JSON` or `<subject> <invalid>` otherwise. */
+export declare function readJsonBody<T>(source: Pick<Response, 'text'>, schema: z.ZodType<T>, subject: string, invalid?: string): Promise<T>;