e2e 0.15.2 → 0.16.0

package/dist/mcp/session.js

@@ -12,11 +12,11 @@
  * restart and the client's tool list never changes.
  */
 import { z } from 'zod';
-import { loadAiSdk } from '../agent/ai-sdk.js';
+import { loadAiSdkIfInstalled } from '../agent/ai-sdk.js';
 import { openInteractiveStep } from '../agent/interactive-step.js';
 import { ScreenPresenter } from '../agent/screen-update.js';
 import { secretHandle } from '../secrets.js';
-import { ConfigurationError, errorMessage, InfrastructureError } from '../internal/errors.js';
+import { classifyError, ConfigurationError, errorMessage, InfrastructureError } from '../internal/errors.js';
 import { LocatorEngine } from '../locator/engine.js';
 import { allocateAppPorts } from '../run/app-ports.js';
 import { SharedAppProcesses } from '../run/process-pool.js';
@@ -26,6 +26,7 @@ import { openStandaloneAttempt } from '../run/standalone.js';
 import { createSessionCatalog, isGrammarVerb } from './catalog.js';
 import { describeRecording, SessionRecorder } from './recording.js';
 import { SessionRegistry } from './sessions.js';
+import { SessionUsage } from './usage.js';
 import { actionResult, catalogLine, defineMcpTool, describeToolDetail, errorResult, invokeTool, redactResult, textResult } from './tools.js';
 /** How long one session may live, whatever happens. */
 const SESSION_TTL_MS = 4 * 60 * 60 * 1000;
@@ -64,21 +65,25 @@ export class SessionHost {
      * it, or disconnects, aborts the open and what it started.
      */
     open(options, signal) {
-        return this.sessions.admit((id) => this.openSession(id, options, signal));
+        const usage = new SessionUsage(this.sessions.liveCount, this.options.headed);
+        return this.sessions.admit((id) => this.openSession(id, options, usage, signal)).catch((cause) => {
+            this.options.onSessionEnd?.(usage.openFailed(classifyError(cause).code));
+            throw cause;
+        });
     }
     /** Closes one session, the only one when `session` is omitted, and returns what happened; a session already closing returns that close. */
-    async close(reason, session) {
+    async close(reason, session, endedBy = 'agent') {
         if (session === undefined && !this.sessions.hasLive)
             return 'No session is open.';
-        return this.sessions.close(session, reason, (live) => this.teardown(live, reason));
+        return this.sessions.close(session, reason, (live) => this.teardown(live, reason, endedBy));
     }
     /** Closes every session, for a server that is shutting down; undefined when none was open. */
     async closeAll(reason) {
         this.shutdown.abort();
-        const summaries = await this.sessions.closeAll(reason, (live) => this.teardown(live, reason));
+        const summaries = await this.sessions.closeAll(reason, (live) => this.teardown(live, reason, 'server'));
         return summaries.length === 0 ? undefined : summaries.join('\n');
     }
-    async teardown(live, reason) {
+    async teardown(live, reason, endedBy) {
         if (live.idleTimer !== undefined)
             clearTimeout(live.idleTimer);
         const { value, cleanupErrors } = await this.closeAttempt(live.attempt, live.abort, async () => {
@@ -86,7 +91,7 @@ export class SessionHost {
             const outcome = await live.step.done;
             // The recorder runs this after a start or stop still in flight, even one the step's deadline abandoned.
             return { outcome, saved: await this.saveRecording(live) };
-        });
+        }).finally(() => this.options.onSessionEnd?.(live.usage.closed(endedBy)));
         const lines = [`Session ${live.id} closed (${reason}); ${live.actions} tool calls ran.`];
         if (value.saved !== undefined)
             lines.push(value.saved);
@@ -124,16 +129,31 @@ export class SessionHost {
     call(session, name, args, extra) {
         const live = this.sessions.resolve(session);
         const tool = live.catalog.tools[name];
-        if (tool === undefined)
-            throw this.unknownTool(live, name);
+        live.usage.called(name, live.catalog.project.has(name));
+        if (tool === undefined) {
+            const error = this.unknownTool(live, name);
+            live.usage.failed(error.code);
+            throw error;
+        }
         const redact = live.attempt.agentRuntime.redact;
-        return this.run(live, () => invokeTool(name, tool, args, extra)).then((result) => redactResult(isGrammarVerb(name) ? actionResult(name, result) : result, redact), (cause) => redactResult(errorResult(cause), redact));
+        return this.run(live, () => invokeTool(name, tool, args, extra)).then((result) => {
+            if (!isGrammarVerb(name)) {
+                // A grammar action's failure was counted with its code as it happened; a project tool's result carries none.
+                if (result.isError === true)
+                    live.usage.failed(undefined);
+                return redactResult(result, redact);
+            }
+            return redactResult(actionResult(name, result), redact);
+        }, (cause) => {
+            live.usage.failed(classifyError(cause).code);
+            return redactResult(errorResult(cause), redact);
+        });
     }
-    async openSession(id, options, request) {
-        // The catalog reads the tools' schemas through the AI SDK, synchronously
-        // and on every render, so the optional SDK is loaded once here: a project
-        // without it learns so before an attempt opens a browser.
-        await loadAiSdk();
+    async openSession(id, options, usage, request) {
+        // The catalog renders synchronously, so the optional SDK is loaded once
+        // here when installed. Without it the catalog reads the tools' Standard
+        // Schemas, and only a model-backed call needs the package.
+        await loadAiSdkIfInstalled();
         // The config is claimed before it evaluates: its top-level code resolves
         // secrets against the registry an open session installed, which only
         // knows that session's config.
@@ -143,6 +163,7 @@ export class SessionHost {
         // A session is its own run: a URL declared with port 0 gets a port here.
         const config = await allocateAppPorts(loaded);
         const target = this.resolveTarget(config, options.target);
+        usage.resolved(target.platform, target.engine);
         this.sessions.claimEngine(id, target.name, target.engine);
         const ttlMs = this.options.ttlMs ?? SESSION_TTL_MS;
         const abort = new AbortController();
@@ -197,6 +218,7 @@ export class SessionHost {
                     assertionTimeout: config.assertionTimeout,
                 }),
                 warn: (message) => this.options.log('warning', message),
+                onActionFailed: (cause) => usage.failed(classifyError(cause).code),
             });
             const live = {
                 id,
@@ -210,6 +232,7 @@ export class SessionHost {
                 abort,
                 idleTimer: undefined,
                 actions: 0,
+                usage,
             };
             const text = this.openingText(live, config, await this.firstScreen(live));
             // A first screen that came back despite the cancel must not become a live session nobody asked for.
@@ -218,7 +241,7 @@ export class SessionHost {
             opening.removeEventListener('abort', cancel);
             this.sessions.activate(live);
             // A step that ends on its own (the TTL, a hard stop) ends the session.
-            void step.done.then((outcome) => this.endOnItsOwn(live, outcome.error === undefined ? 'the session step concluded' : errorMessage(outcome.error)));
+            void step.done.then((outcome) => this.endOnItsOwn(live, outcome.error === undefined ? 'the session step concluded' : errorMessage(outcome.error), 'step'));
             this.touch(live);
             return text;
         }
@@ -231,11 +254,11 @@ export class SessionHost {
         }
     }
     /** Closes a live session that ended without a close_session: its step concluded, or it sat idle. */
-    endOnItsOwn(live, why) {
+    endOnItsOwn(live, why, endedBy) {
         if (!this.sessions.isLive(live.id))
             return;
         this.options.log('warning', `session ${live.id} ended: ${why}`);
-        this.close(why, live.id).catch((cause) => this.options.log('error', `closing session ${live.id} failed: ${errorMessage(cause)}`));
+        this.close(why, live.id, endedBy).catch((cause) => this.options.log('error', `closing session ${live.id} failed: ${errorMessage(cause)}`));
     }
     /** A recorder writing to `<output>/videos/<session>/`, when the engine records video. */
     recorder(id, config, attempt) {
@@ -345,7 +368,7 @@ export class SessionHost {
         if (live.idleTimer !== undefined)
             clearTimeout(live.idleTimer);
         const idleMs = this.options.idleMs ?? SESSION_IDLE_MS;
-        live.idleTimer = setTimeout(() => this.endOnItsOwn(live, `idle for ${Math.round(idleMs / 60_000)} minutes`), idleMs);
+        live.idleTimer = setTimeout(() => this.endOnItsOwn(live, `idle for ${Math.round(idleMs / 60_000)} minutes`, 'idle'), idleMs);
         live.idleTimer.unref();
     }
     /** Runs one tool body inside the live session's step. */
@@ -404,4 +427,3 @@ export class SessionHost {
         });
     }
 }
-//# sourceMappingURL=session.js.map

package/dist/mcp/sessions.d.ts

@@ -25,6 +25,8 @@ export declare class SessionRegistry<S extends NamedSession> {
     constructor(limit: number);
     /** Whether any session is live. */
     get hasLive(): boolean;
+    /** How many sessions are live. */
+    get liveCount(): number;
     /**
      * Admits a session and runs `open` for it under a fresh id. A session whose
      * open fails leaves once `open` has settled, after the host tore down what
@@ -63,4 +65,3 @@ export declare class SessionRegistry<S extends NamedSession> {
     /** Keeps why a session ended, forgetting the oldest beyond `ENDED_KEPT`. */
     private remember;
 }
-//# sourceMappingURL=sessions.d.ts.map

package/dist/mcp/sessions.js

@@ -23,7 +23,11 @@ export class SessionRegistry {
     }
     /** Whether any session is live. */
     get hasLive() {
-        return this.live().length > 0;
+        return this.liveCount > 0;
+    }
+    /** How many sessions are live. */
+    get liveCount() {
+        return this.live().length;
     }
     /**
      * Admits a session and runs `open` for it under a fresh id. A session whose
@@ -156,4 +160,3 @@ export class SessionRegistry {
 function describe(sessions) {
     return sessions.map((session) => `${session.id} on "${session.target.name}"`).join(', ');
 }
-//# sourceMappingURL=sessions.js.map

package/dist/mcp/tools.d.ts

@@ -8,10 +8,11 @@
  * validates the arguments against the schema, runs the tool, and renders its
  * output in the MCP result envelope.
  *
- * The schemas are read through the AI SDK's `asSchema`, and the SDK is an
- * optional peer dependency: this module reaches it only through the lazy
- * loader, never a static import, since the CLI loads this module for every
- * command and `e2e init` runs before `ai` is installed.
+ * The schemas are read through the AI SDK's `asSchema` when it is installed,
+ * and through the schema's own Standard Schema (zod's, among others) when it
+ * is not. The SDK is an optional peer dependency: this module reaches it only
+ * through the lazy loader, never a static import, since the CLI loads this
+ * module for every command and `e2e init` runs before `ai` is installed.
  */
 import type { JSONSchema7, ToolSet } from 'ai';
 import type { z } from 'zod';
@@ -66,7 +67,8 @@ export declare function redactResult(result: McpToolResult, redact: (text: strin
  * never need. A zod schema converts synchronously; a schema that only
  * resolves lazily is shown as an open object rather than awaited, since the
  * catalog is rendered inline. Synchronous, so the session that renders the
- * catalog has loaded the SDK first.
+ * catalog has loaded the SDK first when it is installed; without it, the
+ * schema's Standard JSON Schema converter is read instead.
  */
 export declare function toolJsonSchema(tool: ToolSet[string]): JSONSchema7;
 /**
@@ -89,4 +91,3 @@ export declare function invokeTool(name: string, tool: ToolSet[string], args: Re
  * else is JSON, so a structured output is never lost.
  */
 export declare function resultFromOutput(tool: ToolSet[string], output: unknown, input?: unknown): Promise<McpToolResult>;
-//# sourceMappingURL=tools.d.ts.map

package/dist/mcp/tools.js

@@ -8,14 +8,16 @@
  * validates the arguments against the schema, runs the tool, and renders its
  * output in the MCP result envelope.
  *
- * The schemas are read through the AI SDK's `asSchema`, and the SDK is an
- * optional peer dependency: this module reaches it only through the lazy
- * loader, never a static import, since the CLI loads this module for every
- * command and `e2e init` runs before `ai` is installed.
+ * The schemas are read through the AI SDK's `asSchema` when it is installed,
+ * and through the schema's own Standard Schema (zod's, among others) when it
+ * is not. The SDK is an optional peer dependency: this module reaches it only
+ * through the lazy loader, never a static import, since the CLI loads this
+ * module for every command and `e2e init` runs before `ai` is installed.
  */
-import { aiSdk, loadAiSdk } from '../agent/ai-sdk.js';
+import { loadAiSdk, loadAiSdkIfInstalled, loadedAiSdk } from '../agent/ai-sdk.js';
 import { isFailedResult } from '../agent/loop-guards.js';
 import { codedMessage, ConfigurationError, errorMessage } from '../internal/errors.js';
+import { describeIssue } from '../internal/standard-schema.js';
 /** Declares one fixed tool with `call` typed from its `inputSchema`. */
 export function defineMcpTool(spec) {
     return spec;
@@ -54,15 +56,26 @@ const CATALOG_SENTENCE_MAX = 160;
  * never need. A zod schema converts synchronously; a schema that only
  * resolves lazily is shown as an open object rather than awaited, since the
  * catalog is rendered inline. Synchronous, so the session that renders the
- * catalog has loaded the SDK first.
+ * catalog has loaded the SDK first when it is installed; without it, the
+ * schema's Standard JSON Schema converter is read instead.
  */
 export function toolJsonSchema(tool) {
-    const raw = aiSdk().asSchema(tool.inputSchema).jsonSchema;
-    if (typeof raw.then === 'function')
+    const sdk = loadedAiSdk();
+    const raw = sdk === undefined ? standardJsonSchema(tool.inputSchema) : sdk.asSchema(tool.inputSchema).jsonSchema;
+    if (raw === undefined || typeof raw.then === 'function')
         return { type: 'object' };
     const { $schema: _draft, ...schema } = raw;
     return schema;
 }
+/** The tool schema as a Standard Schema v1, or undefined for a schema the AI SDK built. */
+function standardSchemaOf(schema) {
+    const props = schema?.['~standard'];
+    return typeof props === 'object' && props !== null && typeof props.validate === 'function' ? schema : undefined;
+}
+/** The draft-07 JSON Schema a Standard Schema's own converter produces, or undefined without one. */
+function standardJsonSchema(schema) {
+    return standardSchemaOf(schema)?.['~standard'].jsonSchema?.input({ target: 'draft-07' });
+}
 /**
  * One catalog line: the name, the argument names (`?` marks an optional
  * one), the first sentence of the description, and the read-only mark.
@@ -119,14 +132,27 @@ export async function invokeTool(name, tool, args, extra) {
     return resultFromOutput(tool, await resolveOutput(await tool.execute(input, options)), input);
 }
 async function validateArgs(name, tool, args) {
-    const { asSchema } = await loadAiSdk();
+    const sdk = await loadAiSdkIfInstalled();
+    const standard = standardSchemaOf(tool.inputSchema);
+    if (sdk === undefined && standard !== undefined) {
+        const result = await standard['~standard'].validate(args);
+        if (result.issues === undefined)
+            return result.value;
+        throw invalidArgs(name, result.issues.map(describeIssue).join('; '));
+    }
+    // A schema the SDK built (`jsonSchema()`, a lazy schema) only exists with the SDK installed.
+    const { asSchema } = sdk ?? (await loadAiSdk());
     const schema = asSchema(tool.inputSchema);
     if (schema.validate === undefined)
         return args;
     const result = await schema.validate(args);
     if (result.success)
         return result.value;
-    throw new ConfigurationError('INVALID_ARGUMENT', `call ${name}: ${describeValidationError(result.error)}; tools {tool: ${JSON.stringify(name)}} shows its arguments`);
+    throw invalidArgs(name, describeValidationError(result.error));
+}
+/** The failure a `call` with arguments its tool's schema rejects gets. */
+function invalidArgs(name, issues) {
+    return new ConfigurationError('INVALID_ARGUMENT', `call ${name}: ${issues}; tools {tool: ${JSON.stringify(name)}} shows its arguments`);
 }
 /**
  * The issues a zod (or any standard schema) failure carries, one per line;
@@ -200,4 +226,3 @@ function contentFromModelOutput(output) {
             return undefined;
     }
 }
-//# sourceMappingURL=tools.js.map

package/dist/mcp/usage.d.ts

@@ -0,0 +1,61 @@
+/**
+ * What one `e2e mcp` session did, kept beside it for whoever is told when it
+ * ends: the CLI turns it into telemetry. The host fills it from facts it
+ * already holds; nothing here reads an argument, a result, or a screen. A
+ * project tool counts under one number, never its name, and an error under
+ * its runner code alone.
+ */
+/** How a session ended: the agent's `close_session`, idleness, its step concluding (the TTL), or the server going away. */
+export type SessionEndedBy = 'agent' | 'idle' | 'step' | 'server';
+/** One session, from `open_session` to its close or failed open. */
+export interface McpSessionSummary {
+    /** `closed` for a session that went live, `open-failed` for an `open_session` that did not. */
+    readonly outcome: 'closed' | 'open-failed';
+    /** Undefined for a failed open. */
+    readonly endedBy: SessionEndedBy | undefined;
+    /** The runner code an open failed with; undefined for a session that went live. */
+    readonly openErrorCode: string | undefined;
+    /** Undefined when the open failed before the target resolved. */
+    readonly platform: string | undefined;
+    /** Undefined before the target resolved, and for a target without an engine. */
+    readonly engine: SessionEngine | undefined;
+    readonly headed: boolean;
+    readonly durationMs: number;
+    /** Sessions live beside this one when it opened. */
+    readonly concurrent: number;
+    /** Calls of every other name, the built-in catalog tools and names the session does not have, by name; telemetry folds the latter. */
+    readonly toolCalls: ReadonlyMap<string, number>;
+    /** Calls of the project's own tools, together. */
+    readonly projectToolCalls: number;
+    /** Calls whose result was an error. */
+    readonly failedCalls: number;
+    /** How often each runner code failed a call. */
+    readonly errorCodes: ReadonlyMap<string, number>;
+}
+/** The engine a session's target declares, by its own name and version. */
+export interface SessionEngine {
+    readonly name: string;
+    readonly version: string;
+}
+/** The live counters of one session. */
+export declare class SessionUsage {
+    private readonly concurrent;
+    private readonly headed;
+    private readonly startedAt;
+    private readonly toolCalls;
+    private projectToolCalls;
+    private failedCalls;
+    private readonly errorCodes;
+    private target;
+    constructor(concurrent: number, headed: boolean);
+    /** Notes the target once the open resolved it, so a later failure still names the platform it failed on. */
+    resolved(platform: string, engine: SessionEngine | undefined): void;
+    /** Counts one call of a catalog tool. */
+    called(name: string, project: boolean): void;
+    /** Counts one failed call, under its code when it has one. */
+    failed(code: string | undefined): void;
+    /** The summary of a session that went live and has now closed. */
+    closed(endedBy: SessionEndedBy): McpSessionSummary;
+    /** The summary of an `open_session` that failed with `code`. */
+    openFailed(code: string): McpSessionSummary;
+}

package/dist/mcp/usage.js

@@ -0,0 +1,73 @@
+/**
+ * What one `e2e mcp` session did, kept beside it for whoever is told when it
+ * ends: the CLI turns it into telemetry. The host fills it from facts it
+ * already holds; nothing here reads an argument, a result, or a screen. A
+ * project tool counts under one number, never its name, and an error under
+ * its runner code alone.
+ */
+/** The live counters of one session. */
+export class SessionUsage {
+    concurrent;
+    headed;
+    startedAt = Date.now();
+    toolCalls = new Map();
+    projectToolCalls = 0;
+    failedCalls = 0;
+    errorCodes = new Map();
+    target;
+    constructor(concurrent, headed) {
+        this.concurrent = concurrent;
+        this.headed = headed;
+    }
+    /** Notes the target once the open resolved it, so a later failure still names the platform it failed on. */
+    resolved(platform, engine) {
+        this.target = { platform, engine };
+    }
+    /** Counts one call of a catalog tool. */
+    called(name, project) {
+        if (project)
+            this.projectToolCalls += 1;
+        else
+            this.toolCalls.set(name, (this.toolCalls.get(name) ?? 0) + 1);
+    }
+    /** Counts one failed call, under its code when it has one. */
+    failed(code) {
+        this.failedCalls += 1;
+        if (code !== undefined)
+            this.errorCodes.set(code, (this.errorCodes.get(code) ?? 0) + 1);
+    }
+    /** The summary of a session that went live and has now closed. */
+    closed(endedBy) {
+        return {
+            outcome: 'closed',
+            endedBy,
+            openErrorCode: undefined,
+            platform: this.target?.platform,
+            engine: this.target?.engine,
+            headed: this.headed,
+            durationMs: Date.now() - this.startedAt,
+            concurrent: this.concurrent,
+            toolCalls: new Map(this.toolCalls),
+            projectToolCalls: this.projectToolCalls,
+            failedCalls: this.failedCalls,
+            errorCodes: new Map(this.errorCodes),
+        };
+    }
+    /** The summary of an `open_session` that failed with `code`. */
+    openFailed(code) {
+        return {
+            outcome: 'open-failed',
+            endedBy: undefined,
+            openErrorCode: code,
+            platform: this.target?.platform,
+            engine: this.target?.engine,
+            headed: this.headed,
+            durationMs: Date.now() - this.startedAt,
+            concurrent: this.concurrent,
+            toolCalls: new Map(),
+            projectToolCalls: 0,
+            failedCalls: 0,
+            errorCodes: new Map(),
+        };
+    }
+}

package/dist/oauth/callback-server.d.ts

@@ -23,4 +23,3 @@ export interface CallbackServer {
     close(): void;
 }
 export declare function startCallbackServer(options: CallbackServerOptions): Promise<CallbackServer | undefined>;
-//# sourceMappingURL=callback-server.d.ts.map

package/dist/oauth/callback-server.js

@@ -100,4 +100,3 @@ function renderPage(productName, heading, message) {
 <body><main><h1>${escapeHtml(heading)}</h1><p>${escapeHtml(message)}</p></main></body>
 </html>`;
 }
-//# sourceMappingURL=callback-server.js.map

package/dist/oauth/chatgpt.d.ts

@@ -6,4 +6,3 @@
  */
 import type { LanguageModelV4 } from '@ai-sdk/provider';
 export declare function chatgpt(modelId: string): LanguageModelV4;
-//# sourceMappingURL=chatgpt.d.ts.map

package/dist/oauth/chatgpt.js

@@ -40,4 +40,3 @@ function withoutServerStorage(model) {
         doStream: (options) => model.doStream(storeOff(options)),
     };
 }
-//# sourceMappingURL=chatgpt.js.map

package/dist/oauth/cli.d.ts

@@ -31,4 +31,3 @@ export declare function runLogout(providerId: string | undefined, io?: CliIo): P
  * terminal controls stripped. `list` is a test seam.
  */
 export declare function runModels(providerId: string | undefined, io?: CliIo, list?: (id: ProviderId) => Promise<SubscriptionModel[]>): Promise<number>;
-//# sourceMappingURL=cli.d.ts.map

package/dist/oauth/cli.js

@@ -258,4 +258,3 @@ function openInBrowser(url) {
         // The printed URL is the fallback.
     }
 }
-//# sourceMappingURL=cli.js.map

package/dist/oauth/copilot.d.ts

@@ -7,4 +7,3 @@
  */
 import type { LanguageModelV4 } from '@ai-sdk/provider';
 export declare function copilot(modelId: string): LanguageModelV4;
-//# sourceMappingURL=copilot.d.ts.map

package/dist/oauth/copilot.js

@@ -24,4 +24,3 @@ export function copilot(modelId) {
         includeUsage: true,
     }).chatModel(modelId);
 }
-//# sourceMappingURL=copilot.js.map

package/dist/oauth/device-code.d.ts

@@ -53,4 +53,3 @@ export interface Rfc8628Options {
 }
 /** The standard device flow; the poll reads the body before the status, since vendors disagree on the status for "pending". */
 export declare function rfc8628Flow(options: Rfc8628Options): Promise<TokenResponse>;
-//# sourceMappingURL=device-code.d.ts.map

package/dist/oauth/device-code.js

@@ -110,4 +110,3 @@ function abortableSleep(ms, signal) {
         signal?.addEventListener('abort', onAbort, { once: true });
     });
 }
-//# sourceMappingURL=device-code.js.map

package/dist/oauth/errors.d.ts

@@ -20,4 +20,3 @@ export declare class OAuthError extends Error {
 }
 /** Reads an error body for a message without assuming JSON. */
 export declare function describeResponse(response: Response): Promise<string>;
-//# sourceMappingURL=errors.d.ts.map

package/dist/oauth/errors.js

@@ -29,4 +29,3 @@ export async function describeResponse(response) {
         return `${response.status}: ${text.slice(0, 200)}`;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/oauth/fetch.d.ts

@@ -17,4 +17,3 @@ export interface OAuthFetchOptions {
     readonly loginHint?: string;
 }
 export declare function createOAuthFetch<Credentials extends OAuthCredentials>(provider: OAuthProvider<Credentials, never>, options: OAuthFetchOptions): FetchFunction;
-//# sourceMappingURL=fetch.d.ts.map

package/dist/oauth/fetch.js

@@ -115,4 +115,3 @@ export function createOAuthFetch(provider, options) {
 function expiring(credentials) {
     return credentials.expires !== 0 && credentials.expires - REFRESH_SKEW_MS <= Date.now();
 }
-//# sourceMappingURL=fetch.js.map

package/dist/oauth/grok.d.ts

@@ -5,4 +5,3 @@
  */
 import type { LanguageModelV4 } from '@ai-sdk/provider';
 export declare function grok(modelId: string): LanguageModelV4;
-//# sourceMappingURL=grok.d.ts.map

package/dist/oauth/grok.js

@@ -16,4 +16,3 @@ export function grok(modelId) {
     });
     return createXai({ apiKey: 'oauth', fetch })(modelId);
 }
-//# sourceMappingURL=grok.js.map

package/dist/oauth/jwt.d.ts

@@ -1,3 +1,2 @@
 /** The payload of a JWT, or undefined when the token is not one. Signatures are not checked: the values only steer requests. */
 export declare function decodeJwtPayload(token: string): Record<string, unknown> | undefined;
-//# sourceMappingURL=jwt.d.ts.map

package/dist/oauth/jwt.js

@@ -11,4 +11,3 @@ export function decodeJwtPayload(token) {
         return undefined;
     }
 }
-//# sourceMappingURL=jwt.js.map

package/dist/oauth/login.d.ts

@@ -9,4 +9,3 @@ export interface LoginInput<Id extends ProviderId> {
 export declare function login<Id extends ProviderId>(providerId: Id, input: LoginInput<Id>): Promise<OAuthCredentials>;
 /** Forgets a stored login; true when there was one. */
 export declare function logout(providerId: ProviderId, store?: CredentialStore): Promise<boolean>;
-//# sourceMappingURL=login.d.ts.map

package/dist/oauth/login.js

@@ -14,4 +14,3 @@ export async function logout(providerId, store = defaultCredentialStore()) {
     await store.remove(providerId);
     return true;
 }
-//# sourceMappingURL=login.js.map

package/dist/oauth/models.d.ts

@@ -3,4 +3,3 @@ import { type ProviderId } from './providers.ts';
 import type { CredentialStore, SubscriptionModel } from './types.ts';
 /** The models `providerId`'s stored login serves; `NOT_LOGGED_IN` without one. */
 export declare function listModels(providerId: ProviderId, store?: CredentialStore): Promise<SubscriptionModel[]>;
-//# sourceMappingURL=models.d.ts.map

package/dist/oauth/models.js

@@ -11,4 +11,3 @@ export async function listModels(providerId, store = defaultCredentialStore()) {
     const fetch = createOAuthFetch(provider, { store, userAgent: USER_AGENT, loginHint: loginHint(providerId) });
     return provider.models(fetch);
 }
-//# sourceMappingURL=models.js.map

package/dist/oauth/pkce.d.ts

@@ -5,4 +5,3 @@ export interface Pkce {
 }
 export declare function generatePkce(): Promise<Pkce>;
 export declare function randomState(): string;
-//# sourceMappingURL=pkce.d.ts.map

package/dist/oauth/pkce.js

@@ -10,4 +10,3 @@ export async function generatePkce() {
 export function randomState() {
     return base64url(crypto.getRandomValues(new Uint8Array(24)));
 }
-//# sourceMappingURL=pkce.js.map

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

@@ -36,4 +36,3 @@ export declare function copilotBaseUrl(enterpriseUrl?: string): string;
 export declare function createCopilotProvider(options?: CopilotProviderOptions): OAuthProvider<CopilotCredentials, CopilotLoginOptions>;
 /** Routes an enterprise login at its host and adds Copilot's headers: who initiated the turn, and that images are present. */
 export declare function sendCopilotRequest(request: Request, credentials: CopilotCredentials, upstream: FetchFunction): Promise<Response>;
-//# sourceMappingURL=github-copilot.d.ts.map

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

@@ -114,8 +114,10 @@ export async function sendCopilotRequest(request, credentials, upstream) {
 }
 /**
  * The chat models the Copilot plan serves; embeddings and other kinds are
- * left out because only chat models fit `copilot()`. The request goes through
- * `send`, so an enterprise login lists its own host.
+ * left out because only chat models fit `copilot()`. A model the plan has
+ * not enabled, or one Copilot serves without `/chat/completions`, is listed
+ * but marked: `copilot()` posts to `/chat/completions`, which rejects both. The
+ * request goes through `send`, so an enterprise login lists its own host.
  */
 async function listCopilotModels(fetch) {
     const response = await fetch(`${COPILOT_API_URL}/models`);
@@ -132,6 +134,8 @@ async function listCopilotModels(fetch) {
             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,
+            servesChatCompletions(model) ? undefined : 'no chat completions',
         ].filter((part) => part !== undefined);
         return {
             id: model.id,
@@ -140,4 +144,7 @@ async function listCopilotModels(fetch) {
         };
     });
 }
-//# sourceMappingURL=github-copilot.js.map
+/** Whether `copilot()` can reach the model; an entry that names no endpoints is served over chat completions. */
+function servesChatCompletions(model) {
+    return !Array.isArray(model.supported_endpoints) || model.supported_endpoints.includes('/chat/completions');
+}