e2e 0.21.1 → 0.21.2

package/dist/oauth/errors.js

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export class OAuthError extends Error {
     code;
     name = 'OAuthError';
@@ -6,26 +7,40 @@ export class OAuthError extends Error {
         this.code = code;
     }
 }
+/** The fields an error body names its failure with; a field of another type, or a body that is not an object, names nothing. */
+const ErrorBodySchema = z
+    .object({
+    error: z.union([z.string(), z.object({ message: z.string() })]).optional().catch(undefined),
+    error_description: z.string().optional().catch(undefined),
+    message: z.string().optional().catch(undefined),
+})
+    .catch({});
 /** Reads an error body for a message without assuming JSON. */
 export async function describeResponse(response) {
     const text = await response.text().catch(() => '');
     if (text === '')
         return `${response.status} ${response.statusText}`.trim();
     try {
-        const json = JSON.parse(text);
-        const error = json.error;
-        const detail = typeof json.error_description === 'string'
-            ? json.error_description
-            : typeof error === 'object' && error !== null && 'message' in error && typeof error.message === 'string'
-                ? error.message
-                : typeof json.message === 'string'
-                    ? json.message
-                    : typeof error === 'string'
-                        ? error
-                        : undefined;
+        const { error, error_description, message } = ErrorBodySchema.parse(JSON.parse(text));
+        const detail = error_description ?? (typeof error === 'object' ? error.message : undefined) ?? message ?? (typeof error === 'string' ? error : undefined);
         return detail === undefined ? `${response.status}: ${text.slice(0, 200)}` : `${response.status}: ${detail}`;
     }
     catch {
         return `${response.status}: ${text.slice(0, 200)}`;
     }
 }
+/** A response's or request's JSON body checked against `schema`; FLOW_FAILED as `<subject> is not JSON` or `<subject> <invalid>` otherwise. */
+export async function readJsonBody(source, schema, subject, invalid = 'is malformed') {
+    const text = await source.text();
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch (cause) {
+        throw new OAuthError('FLOW_FAILED', `${subject} is not JSON`, { cause });
+    }
+    const result = schema.safeParse(value);
+    if (!result.success)
+        throw new OAuthError('FLOW_FAILED', `${subject} ${invalid}`, { cause: result.error });
+    return result.data;
+}

package/dist/oauth/providers/github-copilot.d.ts

@@ -48,3 +48,7 @@ export type CopilotProtocol = 'chat' | 'responses';
  * missing listing and rejects.
  */
 export declare function copilotProtocolFor(modelId: string, fetch: FetchFunction, signal: AbortSignal): Promise<CopilotProtocol | undefined>;
+/** Why `modelId` cannot be used, as the run error reads it, once Copilot answered `model_not_supported`. */
+export declare function copilotRefusal(modelId: string): string;
+/** True for the AI SDK's error over a 4xx whose body code is `model_not_supported`; a wrong endpoint (`unsupported_api_for_model`) is not this. */
+export declare function isCopilotRefusal(cause: unknown): cause is Error;

package/dist/oauth/providers/github-copilot.js

@@ -6,8 +6,9 @@
  */
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { z } from 'zod';
 import { rfc8628Flow } from '../device-code.js';
-import { OAuthError, describeResponse } from '../errors.js';
+import { OAuthError, describeResponse, readJsonBody } from '../errors.js';
 const execFileAsync = promisify(execFile);
 export const COPILOT_API_URL = 'https://api.githubcopilot.com';
 /**
@@ -99,6 +100,13 @@ export async function sendCopilotRequest(request, credentials, upstream) {
         headers.set('copilot-vision-request', 'true');
     return upstream(new Request(url, { method: request.method, headers, signal: request.signal, ...(text === undefined ? {} : { body: text }) }));
 }
+/** One turn of either protocol, a chat `messages[]` entry or a Responses `input[]` item; one that is not an object reads as empty. */
+const CopilotTurnSchema = z.object({ role: z.unknown().optional(), content: z.unknown().optional() }).catch({});
+/** The turns of a chat or Responses body; a list of another type reads as absent. */
+const CopilotBodySchema = z.object({
+    messages: z.array(CopilotTurnSchema).optional().catch(undefined),
+    input: z.array(CopilotTurnSchema).optional().catch(undefined),
+});
 /**
  * Reads who initiated the turn and whether images are present, whichever
  * protocol carried the body. Chat completions put turns in `messages[]` and
@@ -109,17 +117,16 @@ function copilotTurn(text) {
     if (text === undefined)
         return { initiator: 'user', vision: false };
     try {
-        const body = JSON.parse(text);
+        const { messages, input } = CopilotBodySchema.parse(JSON.parse(text));
         // A Responses body has `input` and no `messages`; anything else stays on the chat path.
-        if (!Array.isArray(body.messages) && Array.isArray(body.input)) {
-            const input = body.input;
+        if (messages === undefined && input !== undefined) {
             return { initiator: input.at(-1)?.role === 'user' ? 'user' : 'agent', vision: input.some((item) => hasPart(item.content, 'input_image')) };
         }
-        const messages = Array.isArray(body.messages) ? body.messages : [];
-        return { initiator: messages.at(-1)?.role === 'user' ? 'user' : 'agent', vision: messages.some((message) => hasPart(message.content, 'image_url')) };
+        const turns = messages ?? [];
+        return { initiator: turns.at(-1)?.role === 'user' ? 'user' : 'agent', vision: turns.some((message) => hasPart(message.content, 'image_url')) };
     }
     catch {
-        // Not JSON; the headers stay at their defaults.
+        // Not a JSON object; the headers stay at their defaults.
         return { initiator: 'user', vision: false };
     }
 }
@@ -127,6 +134,26 @@ function copilotTurn(text) {
 function hasPart(content, type) {
     return Array.isArray(content) && content.some((part) => part?.type === type);
 }
+/** One entry of the Copilot API's `/models`, as far as the listing reads it; a field of another type reads as absent. */
+const CopilotModelSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().optional().catch(undefined),
+    vendor: z.string().optional().catch(undefined),
+    preview: z.unknown().optional(),
+    policy: z.object({ state: z.string().optional().catch(undefined) }).optional().catch(undefined),
+    supported_endpoints: z.array(z.unknown()).optional().catch(undefined),
+    capabilities: z
+        .object({
+        type: z.unknown().optional(),
+        supports: z.object({ tool_calls: z.unknown().optional(), vision: z.unknown().optional() }).optional().catch(undefined),
+    })
+        .optional()
+        .catch(undefined),
+});
+/** The models in a Copilot API `/models` body, `undefined` when it names none; an entry without an id is left out. */
+const CopilotModelListSchema = z
+    .object({ data: z.array(CopilotModelSchema.optional().catch(undefined)).nullish() })
+    .transform(({ data }) => data?.filter((model) => model !== undefined));
 /**
  * The chat models the Copilot plan serves; embeddings and other kinds are
  * left out because only chat models fit `copilot()`. A model it cannot call
@@ -138,23 +165,22 @@ async function listCopilotModels(fetch) {
     const response = await fetch(`${COPILOT_API_URL}/models`);
     if (!response.ok)
         throw new OAuthError('FLOW_FAILED', `GitHub Copilot did not list its models: ${await describeResponse(response)}`);
-    const payload = (await response.json());
-    const models = Array.isArray(payload.data) ? payload.data : [];
+    const models = (await readJsonBody(response, CopilotModelListSchema, 'the GitHub Copilot model list')) ?? [];
     return models
-        .filter((model) => typeof model.id === 'string' && model.id !== '' && (model.capabilities?.type === undefined || model.capabilities.type === 'chat'))
+        .filter((model) => model.capabilities?.type === undefined || model.capabilities.type === 'chat')
         .map((model) => {
         const supports = model.capabilities?.supports;
         const detail = [
-            typeof model.vendor === 'string' ? model.vendor : undefined,
+            model.vendor,
             supports?.tool_calls === true ? 'tools' : undefined,
             supports?.vision === true ? 'vision' : undefined,
             model.preview === true ? 'preview' : undefined,
-            typeof model.policy?.state === 'string' && model.policy.state !== 'enabled' ? 'not enabled' : undefined,
+            model.policy?.state !== undefined && model.policy.state !== 'enabled' ? 'not enabled' : undefined,
             copilotProtocol(model) === undefined ? 'no chat or responses' : undefined,
         ].filter((part) => part !== undefined);
         return {
             id: model.id,
-            ...(typeof model.name === 'string' && model.name !== '' ? { name: model.name } : {}),
+            ...(model.name === undefined || model.name === '' ? {} : { name: model.name }),
             ...(detail.length === 0 ? {} : { detail: detail.join(', ') }),
         };
     });
@@ -173,10 +199,10 @@ export async function copilotProtocolFor(modelId, fetch, signal) {
         const response = await fetch(new Request(`${COPILOT_API_URL}/models`, { signal }));
         if (!response.ok)
             return undefined;
-        const payload = (await response.json());
-        if (!Array.isArray(payload.data))
+        const listing = CopilotModelListSchema.safeParse(await response.json());
+        if (!listing.success || listing.data === undefined)
             return undefined;
-        return copilotProtocol(payload.data.find((model) => model.id === modelId)) ?? 'chat';
+        return copilotProtocol(listing.data.find((model) => model.id === modelId)) ?? 'chat';
     }
     catch (error) {
         if (error instanceof OAuthError)
@@ -202,3 +228,25 @@ function copilotProtocol(model) {
         return 'responses';
     return undefined;
 }
+/** Why `modelId` cannot be used, as the run error reads it, once Copilot answered `model_not_supported`. */
+export function copilotRefusal(modelId) {
+    return `GitHub Copilot does not serve ${modelId} to this account: the plan does not include it, it is turned off in Copilot settings on GitHub, or Copilot lists no such id; npx e2e models github-copilot lists the ids, and the listing cannot see plan limits`;
+}
+/** True for the AI SDK's error over a 4xx whose body code is `model_not_supported`; a wrong endpoint (`unsupported_api_for_model`) is not this. */
+export function isCopilotRefusal(cause) {
+    if (!(cause instanceof Error) || cause.name !== 'AI_APICallError')
+        return false;
+    const { statusCode, data, responseBody } = cause;
+    if (typeof statusCode !== 'number' || statusCode < 400 || statusCode >= 500)
+        return false;
+    const parsed = data ?? (typeof responseBody === 'string' ? parseJson(responseBody) : undefined);
+    return parsed?.error?.code === 'model_not_supported';
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/oauth/providers/openai.d.ts

@@ -28,8 +28,8 @@ export interface CodexProviderOptions {
 }
 export declare function createCodexProvider(options?: CodexProviderOptions): OAuthProvider<CodexCredentials, CodexLoginOptions>;
 export declare function extractAccountId(tokens: {
-    id_token?: string;
-    access_token?: string;
+    id_token?: string | undefined;
+    access_token?: string | undefined;
 }): string | undefined;
 /** The code from what the user pasted: a full redirect URL, `code#state`, a query string, or the bare code. */
 export declare function parseAuthorizationInput(input: string): {

package/dist/oauth/providers/openai.js

@@ -6,9 +6,10 @@
  * Responses API, requires `store: false`, and answers only as a stream; the
  * stream is folded back into JSON when the SDK asked for a single response.
  */
+import { z } from 'zod';
 import { startCallbackServer } from '../callback-server.js';
 import { runDeviceFlow } from '../device-code.js';
-import { OAuthError, describeResponse } from '../errors.js';
+import { OAuthError, describeResponse, readJsonBody } from '../errors.js';
 import { decodeJwtPayload } from '../jwt.js';
 import { generatePkce, randomState } from '../pkce.js';
 import { foldResponsesStream } from '../sse.js';
@@ -192,6 +193,17 @@ async function pasteCode(callbacks, state) {
     }
     return pasted.code;
 }
+/** OpenAI's user-code answer: the code to show and the id the poll names it by. */
+const UserCodeSchema = z.object({
+    device_auth_id: z.string(),
+    user_code: z.string(),
+    interval: z.unknown().optional(),
+});
+/** OpenAI's answer once the user entered the code: an authorization code and the PKCE verifier to exchange it with. */
+const DeviceGrantSchema = z.object({
+    authorization_code: z.string(),
+    code_verifier: z.string(),
+});
 /** The Codex CLI's device login: OpenAI's own user-code endpoints, pending until the user enters the code. */
 function deviceLogin(callbacks, issuer, timeoutMs) {
     const json = (url, body, signal) => fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), ...(signal === undefined ? {} : { signal }) });
@@ -201,7 +213,7 @@ function deviceLogin(callbacks, issuer, timeoutMs) {
             const response = await json(`${issuer}/api/accounts/deviceauth/usercode`, { client_id: CLIENT_ID }, signal);
             if (!response.ok)
                 throw new OAuthError('FLOW_FAILED', `ChatGPT device login could not start: ${await describeResponse(response)}`);
-            const device = (await response.json());
+            const device = await readJsonBody(response, UserCodeSchema, 'the ChatGPT device code response', 'is missing fields');
             return {
                 deviceCode: device.device_auth_id,
                 userCode: device.user_code,
@@ -213,7 +225,7 @@ function deviceLogin(callbacks, issuer, timeoutMs) {
         async poll(authorization, signal) {
             const response = await json(`${issuer}/api/accounts/deviceauth/token`, { device_auth_id: authorization.deviceCode, user_code: authorization.userCode }, signal);
             if (response.ok) {
-                const grant = (await response.json());
+                const grant = await readJsonBody(response, DeviceGrantSchema, 'the ChatGPT device grant', 'is missing fields');
                 return { status: 'granted', value: await exchangeCode(issuer, grant.authorization_code, `${issuer}/deviceauth/callback`, grant.code_verifier, signal) };
             }
             // Pending shows as 403 or 404 until the user enters the code.
@@ -225,6 +237,14 @@ function deviceLogin(callbacks, issuer, timeoutMs) {
         },
     });
 }
+/** A Responses API body, as far as the Codex backend needs it changed; every other field passes through. */
+const CodexBodySchema = z.looseObject({
+    stream: z.unknown().optional(),
+    store: z.unknown().optional(),
+    instructions: z.unknown().optional(),
+    include: z.array(z.unknown()).nullish(),
+    max_output_tokens: z.unknown().optional(),
+});
 /**
  * Routes a Responses API request at the Codex backend with the body the
  * Codex CLI sends: no server-side storage, encrypted reasoning carried
@@ -240,13 +260,7 @@ export async function sendCodexRequest(request, credentials, upstream, options)
         return upstream(new Request(request, { headers }));
     if (credentials.residency !== undefined)
         headers.set('x-openai-internal-codex-residency', credentials.residency);
-    let body;
-    try {
-        body = (await request.json());
-    }
-    catch (cause) {
-        throw new OAuthError('FLOW_FAILED', 'the Responses request body is not JSON', { cause });
-    }
+    const body = await readJsonBody(request, CodexBodySchema, 'the Responses request body');
     const wantedStream = body.stream === true;
     body.stream = true;
     body.store = false;
@@ -260,6 +274,24 @@ export async function sendCodexRequest(request, credentials, upstream, options)
     const response = await upstream(new Request(options.apiUrl, { method: request.method, headers, body: JSON.stringify(body), signal: request.signal }));
     return wantedStream ? response : foldResponsesStream(response);
 }
+/** A reasoning level the Codex backend names bare or as `{ effort }`; one of another shape reads as absent. */
+const ReasoningLevelSchema = z
+    .union([z.string(), z.object({ effort: z.string() }).transform(({ effort }) => effort)])
+    .optional()
+    .catch(undefined);
+/** One entry of the Codex backend's model list, as far as the listing reads it; a field of another type reads as absent. */
+const CodexModelSchema = z.object({
+    slug: z.string().min(1),
+    display_name: z.string().optional().catch(undefined),
+    visibility: z.unknown().optional(),
+    default_reasoning_level: z.string().optional().catch(undefined),
+    supported_reasoning_levels: z.array(ReasoningLevelSchema).optional().catch(undefined),
+    priority: z.number().optional().catch(undefined),
+});
+/** The models in the Codex backend's `/models` body; a body that names none has none, and an entry without a slug is left out. */
+const CodexModelListSchema = z
+    .object({ models: z.array(CodexModelSchema.optional().catch(undefined)).nullish() })
+    .transform(({ models }) => (models ?? []).filter((model) => model !== undefined));
 /**
  * The models the Codex backend serves this subscription, `/models` next to
  * `/responses`. Hidden ones are listed too, marked, because the backend
@@ -273,22 +305,18 @@ async function listCodexModels(fetch, apiUrl) {
     const response = await fetch(url);
     if (!response.ok)
         throw new OAuthError('FLOW_FAILED', `ChatGPT did not list its models: ${await describeResponse(response)}`);
-    const payload = (await response.json());
-    const models = Array.isArray(payload.models) ? payload.models : [];
+    const models = await readJsonBody(response, CodexModelListSchema, 'the ChatGPT model list');
     return models
-        .filter((model) => typeof model.slug === 'string' && model.slug !== '')
-        .toSorted((a, b) => (typeof a.priority === 'number' ? a.priority : 0) - (typeof b.priority === 'number' ? b.priority : 0))
+        .toSorted((a, b) => (a.priority ?? 0) - (b.priority ?? 0))
         .map((model) => {
-        const levels = Array.isArray(model.supported_reasoning_levels)
-            ? model.supported_reasoning_levels.map((level) => (typeof level === 'string' ? level : level?.effort)).filter((level) => typeof level === 'string')
-            : [];
+        const levels = (model.supported_reasoning_levels ?? []).filter((level) => level !== undefined);
         const detail = [
-            levels.length === 0 ? undefined : `reasoning ${levels.join('/')}${typeof model.default_reasoning_level === 'string' ? ` (default ${model.default_reasoning_level})` : ''}`,
+            levels.length === 0 ? undefined : `reasoning ${levels.join('/')}${model.default_reasoning_level === undefined ? '' : ` (default ${model.default_reasoning_level})`}`,
             model.visibility === 'hide' ? 'hidden in Codex' : undefined,
         ].filter((part) => part !== undefined);
         return {
             id: model.slug,
-            ...(typeof model.display_name === 'string' && model.display_name !== '' ? { name: model.display_name } : {}),
+            ...(model.display_name === undefined || model.display_name === '' ? {} : { name: model.display_name }),
             ...(detail.length === 0 ? {} : { detail: detail.join('; ') }),
         };
     });

package/dist/oauth/providers/opencode-console.js

@@ -6,8 +6,9 @@
  * over which protocol: Zen is its `opencode` provider, Go `opencode-go`, present
  * only for the Go subscriber. Go ids take a `go/` prefix here.
  */
+import { z } from 'zod';
 import { rfc8628Flow } from '../device-code.js';
-import { OAuthError, describeResponse } from '../errors.js';
+import { OAuthError, describeResponse, readJsonBody } from '../errors.js';
 import { expiryFrom, requestTokens } from '../token-endpoint.js';
 /** Console accepts any client id. */
 const CLIENT_ID = 'e2e';
@@ -69,26 +70,46 @@ async function sendOpencodeConsoleRequest(request, credentials, upstream, consol
     const body = request.method === 'GET' || request.method === 'HEAD' ? undefined : await request.arrayBuffer();
     return upstream(new Request(request.url, { method: request.method, headers, signal: request.signal, ...(body === undefined ? {} : { body }) }));
 }
+/** The npm package and base URL a provider or one of its models is served through; a field of another type reads as absent. */
+const ConfigRouteSchema = z.object({
+    npm: z.string().optional().catch(undefined),
+    api: z.string().optional().catch(undefined),
+});
+/** One model of a workspace provider, as far as routing and the listing read it; a field of another type reads as absent. */
+const ConfigModelSchema = z.object({
+    id: z.string().optional().catch(undefined),
+    name: z.string().optional().catch(undefined),
+    disabled: z.unknown().optional(),
+    cost: z.object({ input: z.number().optional().catch(undefined), output: z.number().optional().catch(undefined) }).optional().catch(undefined),
+    modalities: z.object({ input: z.array(z.unknown()).optional().catch(undefined) }).optional().catch(undefined),
+    provider: ConfigRouteSchema.optional().catch(undefined),
+});
+/** One provider of the workspace config; a model that is not an object is left out. */
+const ConfigProviderSchema = ConfigRouteSchema.extend({
+    models: z.record(z.string(), ConfigModelSchema.optional().catch(undefined)).optional().catch(undefined),
+});
+/** The providers of the Console's `/api/config` body by id; a body that names none has none, and a provider that is not an object is left out. */
+const ConfigSchema = z
+    .object({ config: z.object({ provider: z.record(z.string(), ConfigProviderSchema.optional().catch(undefined)).nullish() }).nullish() })
+    .transform(({ config }) => config?.provider ?? {});
 async function readConfig(fetch, consoleUrl, signal) {
     const response = await fetch(new Request(`${consoleUrl}/api/config`, signal === undefined ? {} : { signal }));
     if (!response.ok)
         throw new OAuthError('FLOW_FAILED', `OpenCode Console did not return the workspace config: ${await describeResponse(response)}`);
-    const payload = (await response.json());
-    const providers = payload.config?.provider;
-    return typeof providers === 'object' && providers !== null ? providers : {};
+    return readJsonBody(response, ConfigSchema, 'the OpenCode Console workspace config');
 }
 /** Leaves out disabled models and Zen's free ones, which only OpenCode's own clients may use. */
 async function listOpencodeConsoleModels(fetch, consoleUrl) {
     const providers = await readConfig(fetch, consoleUrl);
-    const listed = (key, prefix, plan) => Object.entries(providers[key]?.models ?? {})
-        .filter(([, model]) => model.disabled !== true && (key === GO_PROVIDER || !isFree(model)))
-        .map(([id, model]) => {
+    const listed = (key, prefix, plan) => Object.entries(providers[key]?.models ?? {}).flatMap(([id, model]) => {
+        if (model === undefined || model.disabled === true || (key !== GO_PROVIDER && isFree(model)))
+            return [];
         const detail = [
             plan,
-            typeof model.cost?.input === 'number' && typeof model.cost.output === 'number' && key === ZEN_PROVIDER ? `$${model.cost.input} in, $${model.cost.output} out per 1M` : undefined,
-            Array.isArray(model.modalities?.input) && model.modalities.input.includes('image') ? 'vision' : undefined,
+            model.cost?.input !== undefined && model.cost.output !== undefined && key === ZEN_PROVIDER ? `$${model.cost.input} in, $${model.cost.output} out per 1M` : undefined,
+            model.modalities?.input?.includes('image') === true ? 'vision' : undefined,
         ].filter((part) => part !== undefined);
-        return { id: `${prefix}${id}`, ...(typeof model.name === 'string' && model.name !== '' ? { name: model.name } : {}), detail: detail.join(', ') };
+        return [{ id: `${prefix}${id}`, ...(model.name === undefined || model.name === '' ? {} : { name: model.name }), detail: detail.join(', ') }];
     });
     return [...listed(ZEN_PROVIDER, '', 'Zen'), ...listed(GO_PROVIDER, GO_PREFIX, 'Go')];
 }
@@ -130,15 +151,15 @@ export async function opencodeConsoleRouteFor(modelId, fetch, signal) {
     if (model === undefined || model.disabled === true) {
         throw new OAuthError('MISCONFIGURED', `the OpenCode Console workspace does not serve ${modelId}; \`npx e2e models opencode-console\` lists the ids`);
     }
-    const npm = typeof model.provider?.npm === 'string' ? model.provider.npm : provider.npm;
-    const baseURL = typeof model.provider?.api === 'string' ? model.provider.api : provider.api;
-    if (typeof npm !== 'string' || typeof baseURL !== 'string')
+    const npm = model.provider?.npm ?? provider.npm;
+    const baseURL = model.provider?.api ?? provider.api;
+    if (npm === undefined || baseURL === undefined)
         return undefined;
-    return { go, npm, baseURL, modelId: typeof model.id === 'string' && model.id !== '' ? model.id : id };
+    return { go, npm, baseURL, modelId: model.id === undefined || model.id === '' ? id : model.id };
 }
 /** A refresh keeps the workspace and the refresh token when the grant omits them. */
 function toCredentials(tokens, previous) {
-    const orgId = tokens.org_id;
+    const orgId = tokens['org_id'];
     const workspace = typeof orgId === 'string' && orgId !== '' ? orgId : previous?.orgId;
     return {
         access: tokens.access_token,

package/dist/oauth/providers/xai.js

@@ -4,8 +4,9 @@
  * bearer against the ordinary SpaceXAI API. Refresh tokens rotate, so a renewed
  * refresh token replaces the stored one at once.
  */
+import { z } from 'zod';
 import { rfc8628Flow } from '../device-code.js';
-import { OAuthError, describeResponse } from '../errors.js';
+import { OAuthError, describeResponse, readJsonBody } from '../errors.js';
 import { decodeJwtPayload } from '../jwt.js';
 import { expiryFrom, requestTokens } from '../token-endpoint.js';
 /** The public OAuth client of the Grok CLI, which third-party harnesses sign in through. */
@@ -40,20 +41,28 @@ export function createXaiProvider(options = {}) {
         },
     };
 }
+/** One entry of SpaceXAI's language-model list, as far as the listing reads it; a field of another type reads as absent. */
+const XaiModelSchema = z.object({
+    id: z.string().min(1),
+    aliases: z.array(z.unknown()).optional().catch(undefined),
+    input_modalities: z.array(z.unknown()).optional().catch(undefined),
+});
+/** One of the two keys SpaceXAI lists models under; an entry that does not fit reads as `undefined`. */
+const XaiModelsSchema = z.array(XaiModelSchema.optional().catch(undefined)).nullish();
+/** The models in SpaceXAI's list body, under `models` or `data`; a body that names none has none, and an entry without an id is left out. */
+const XaiModelListSchema = z
+    .object({ models: XaiModelsSchema, data: XaiModelsSchema })
+    .transform(({ models, data }) => (models ?? data ?? []).filter((model) => model !== undefined));
 /** The language models the subscription's token reaches; aliases are listed with their target. */
 async function listXaiModels(fetch, url) {
     const response = await fetch(url);
     if (!response.ok)
         throw new OAuthError('FLOW_FAILED', `SpaceXAI did not list its models: ${await describeResponse(response)}`);
-    const payload = (await response.json());
-    const models = (Array.isArray(payload.models) ? payload.models : Array.isArray(payload.data) ? payload.data : []);
-    return models
-        .filter((model) => typeof model.id === 'string' && model.id !== '')
-        .map((model) => {
-        const aliases = Array.isArray(model.aliases) ? model.aliases.filter((alias) => typeof alias === 'string') : [];
-        const modalities = Array.isArray(model.input_modalities) ? model.input_modalities.filter((kind) => typeof kind === 'string') : [];
+    const models = await readJsonBody(response, XaiModelListSchema, 'the SpaceXAI model list');
+    return models.map((model) => {
+        const aliases = (model.aliases ?? []).filter((alias) => typeof alias === 'string');
         const detail = [
-            modalities.includes('image') ? 'vision' : undefined,
+            model.input_modalities?.includes('image') === true ? 'vision' : undefined,
             aliases.length === 0 ? undefined : `also ${aliases.join(', ')}`,
         ].filter((part) => part !== undefined);
         return { id: model.id, ...(detail.length === 0 ? {} : { detail: detail.join('; ') }) };

package/dist/oauth/token-endpoint.d.ts

@@ -4,13 +4,19 @@
  * wire are coerced defensively: a `NaN` expiry written to disk would poison
  * the credentials file.
  */
+import { z } from 'zod';
 import { type OAuthErrorCode } from './errors.ts';
-export interface TokenResponse {
-    readonly access_token: string;
-    readonly refresh_token?: string;
-    readonly id_token?: string;
-    readonly expires_in?: number;
-}
+/**
+ * A token response. Vendor-specific fields ride along; an optional token of the
+ * wrong type is dropped, and `expires_in` stays raw for `expiryFrom`.
+ */
+declare const TokenResponseSchema: z.ZodObject<{
+    access_token: z.ZodString;
+    refresh_token: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    id_token: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    expires_in: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+export type TokenResponse = z.infer<typeof TokenResponseSchema>;
 export declare function postForm(url: string, params: Record<string, string>, signal?: AbortSignal): Promise<Response>;
 /**
  * Posts a grant and returns the tokens. A 400 or 401 means the grant itself
@@ -19,7 +25,10 @@ export declare function postForm(url: string, params: Record<string, string>, si
  * the failure only; the fetch that called for the refresh appends the remedy.
  */
 export declare function requestTokens(vendor: string, url: string, params: Record<string, string>, rejected?: OAuthErrorCode, signal?: AbortSignal): Promise<TokenResponse>;
+/** The tokens in a token endpoint's JSON body, or undefined when it carries no access token. */
+export declare function parseTokens(body: unknown): TokenResponse | undefined;
 /** A seconds value from the server, or the default when it is missing or not a positive finite number. */
 export declare function positiveSeconds(value: unknown, fallback: number): number;
 /** When a token expires, from `expires_in`; one hour when the server names nothing usable. */
 export declare function expiryFrom(expiresIn: unknown, now?: number): number;
+export {};

package/dist/oauth/token-endpoint.js

@@ -4,7 +4,18 @@
  * wire are coerced defensively: a `NaN` expiry written to disk would poison
  * the credentials file.
  */
-import { OAuthError, describeResponse } from './errors.js';
+import { z } from 'zod';
+import { OAuthError, describeResponse, readJsonBody } from './errors.js';
+/**
+ * A token response. Vendor-specific fields ride along; an optional token of the
+ * wrong type is dropped, and `expires_in` stays raw for `expiryFrom`.
+ */
+const TokenResponseSchema = z.looseObject({
+    access_token: z.string().min(1),
+    refresh_token: z.string().optional().catch(undefined),
+    id_token: z.string().optional().catch(undefined),
+    expires_in: z.unknown().optional(),
+});
 export async function postForm(url, params, signal) {
     return fetch(url, {
         method: 'POST',
@@ -25,11 +36,12 @@ export async function requestTokens(vendor, url, params, rejected = 'FLOW_FAILED
         const code = response.status === 400 || response.status === 401 ? rejected : 'FLOW_FAILED';
         throw new OAuthError(code, `${vendor} token request failed (${await describeResponse(response)})`);
     }
-    const tokens = (await response.json());
-    if (typeof tokens.access_token !== 'string' || tokens.access_token === '') {
-        throw new OAuthError('FLOW_FAILED', `the ${vendor} token response is missing access_token`);
-    }
-    return tokens;
+    return readJsonBody(response, TokenResponseSchema, `the ${vendor} token response`, 'is missing access_token');
+}
+/** The tokens in a token endpoint's JSON body, or undefined when it carries no access token. */
+export function parseTokens(body) {
+    const result = TokenResponseSchema.safeParse(body);
+    return result.success ? result.data : undefined;
 }
 /** A seconds value from the server, or the default when it is missing or not a positive finite number. */
 export function positiveSeconds(value, fallback) {

package/dist/report/code-frame.js

@@ -5,7 +5,7 @@
  */
 import { readFileSync } from 'node:fs';
 import { userFrame } from '../internal/source.js';
-import { bounded, terminalColumns } from './format.js';
+import { bounded, fitColumns, terminalColumns, visibleWidth } from './format.js';
 export { userFrame };
 /** Lines of context on each side of the failing line. */
 const FRAME_RANGE = 2;
@@ -36,10 +36,16 @@ export function codeFrame(frame, pc) {
         const raw = bounded(lines[i] ?? '').replaceAll('\t', ' ');
         if (raw.length > MAX_FRAME_LINE_CHARS)
             return [];
-        const text = raw.length > maxChars ? `${raw.slice(0, maxChars - 1)}…` : raw.trimEnd();
+        const text = fitColumns(raw.trimEnd(), maxChars);
         rows.push(`${gutter(i + 1)}${text === '' ? '' : ` ${text}`}`);
         if (i === index) {
-            rows.push(`${gutter()}${' '.repeat(Math.max(1, frame.column))}${pc.red('^')}`);
+            const prefix = bounded((lines[i] ?? '').slice(0, Math.max(0, frame.column - 1)));
+            const column = visibleWidth(prefix);
+            // A clipped-away location has no visible token to annotate.
+            const limit = text === raw.trimEnd() ? maxChars : visibleWidth(text) - 1;
+            if (column < limit) {
+                rows.push(`${gutter()}${' '.repeat(column + 1)}${pc.red('^')}`);
+            }
         }
     }
     return rows;

package/dist/report/failure-text.d.ts

@@ -55,8 +55,16 @@ export declare function toldAttempt(result: ReportResult, final: Outcome): Attem
 export type FailedStep = ReportStep & {
     readonly status: Exclude<ReportStep['status'], 'passed'>;
 };
-/** The step a failure happened at: the first that did not pass, with its position. */
-export declare function failedStepOf(steps: readonly ReportStep[]): {
+/**
+ * The step whose error ended the attempt, with its position: the step in the
+ * error's phase whose own error carries its code and line, else the last with
+ * its code, since a caught failure comes earlier, else the step a timeout or
+ * interrupt cut.
+ */
+export declare function failedStepOf(attempt: {
+    readonly steps: readonly ReportStep[];
+    readonly error?: ReportError | undefined;
+}): {
     index: number;
     step: FailedStep;
 } | undefined;