e2e 0.15.2 → 0.17.0

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

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

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

package/dist/oauth/copilot.d.ts

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

package/dist/oauth/copilot.js

@@ -1,27 +1,99 @@
 /**
  * `copilot('claude-sonnet-5')`: a GitHub Copilot subscription as an AI SDK
- * model. Copilot serves OpenAI, Anthropic, Google, and SpaceXAI models over the
- * OpenAI chat protocol; the instance is `@ai-sdk/openai-compatible`'s chat
- * model at the Copilot API with a fetch that carries the stored login. An
- * enterprise login stored by `e2e login` routes to its own host.
+ * model. Copilot serves most of its models over the OpenAI chat protocol and
+ * some only over its Responses API; the instance asks the plan's model
+ * listing which on the first call and delegates to the matching model, so
+ * construction stays synchronous and touches the network only when a call
+ * does. An enterprise login stored by `e2e login` routes to its own host.
  */
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { OAuthError } from './errors.js';
 import { createOAuthFetch } from './fetch.js';
-import { USER_AGENT, loginHint } from './providers.js';
-import { COPILOT_API_URL, createCopilotProvider } from './providers/github-copilot.js';
+import { USER_AGENT } from '../internal/client-identity.js';
+import { loginHint } from './providers.js';
+import { COPILOT_API_URL, copilotProtocolFor, createCopilotProvider } 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. */
+const LISTING_TIMEOUT_MS = 10_000;
 export function copilot(modelId) {
     const fetch = createOAuthFetch(createCopilotProvider(), {
         store: defaultCredentialStore(),
         userAgent: USER_AGENT,
         loginHint: loginHint('github-copilot'),
     });
-    return createOpenAICompatible({
+    // The key header is removed per request; the value only satisfies the constructor.
+    const chat = createOpenAICompatible({
         name: 'github-copilot',
         baseURL: COPILOT_API_URL,
         apiKey: 'oauth',
         fetch,
         includeUsage: true,
     }).chatModel(modelId);
+    return protocolDelegate(chat, () => responsesModel(modelId, fetch), () => copilotProtocolFor(modelId, fetch, AbortSignal.timeout(LISTING_TIMEOUT_MS)));
+}
+/**
+ * The Responses model for `modelId`. `@ai-sdk/openai` is imported only here,
+ * so a project that calls only chat models needs no install of it.
+ */
+async function responsesModel(modelId, fetch) {
+    let createOpenAI;
+    try {
+        ({ createOpenAI } = await import('@ai-sdk/openai'));
+    }
+    catch (cause) {
+        throw new OAuthError('MISCONFIGURED', `GitHub Copilot serves ${modelId} only over its Responses API, which copilot() calls through @ai-sdk/openai; install it beside @ai-sdk/openai-compatible`, { cause });
+    }
+    return withoutServerStorage(createOpenAI({ apiKey: 'oauth', baseURL: COPILOT_API_URL, fetch, name: 'github-copilot' }).responses(modelId));
+}
+/**
+ * A model that settles its Copilot protocol on the first call and delegates
+ * to the model for it. One lookup serves every concurrent call, under its
+ * 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.
+ */
+function protocolDelegate(chat, responses, lookup) {
+    let resolved;
+    let pending;
+    const settle = () => {
+        if (resolved !== undefined)
+            return Promise.resolve(resolved);
+        pending ??= (async () => {
+            const protocol = await lookup();
+            if (protocol === undefined)
+                return chat;
+            resolved = protocol === 'responses' ? await responses() : chat;
+            return resolved;
+        })().finally(() => {
+            pending = undefined;
+        });
+        return pending;
+    };
+    return {
+        specificationVersion: chat.specificationVersion,
+        get provider() {
+            return resolved?.provider ?? chat.provider;
+        },
+        get modelId() {
+            return resolved?.modelId ?? chat.modelId;
+        },
+        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),
+    };
+}
+/** Waits for `promise` unless `signal` aborts first, leaving the shared promise running for other callers. */
+function untilAborted(promise, signal) {
+    if (signal === undefined)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
 }
-//# 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

@@ -5,7 +5,8 @@
  */
 import { createXai } from '@ai-sdk/xai';
 import { createOAuthFetch } from './fetch.js';
-import { USER_AGENT, loginHint } from './providers.js';
+import { USER_AGENT } from '../internal/client-identity.js';
+import { loginHint } from './providers.js';
 import { createXaiProvider } from './providers/xai.js';
 import { defaultCredentialStore } from './store.js';
 export function grok(modelId) {
@@ -16,4 +17,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

@@ -1,7 +1,8 @@
 /** Lists the models a stored subscription login serves, through the login's own fetch. */
 import { OAuthError } from './errors.js';
 import { createOAuthFetch } from './fetch.js';
-import { USER_AGENT, getProvider, loginHint } from './providers.js';
+import { USER_AGENT } from '../internal/client-identity.js';
+import { getProvider, loginHint } from './providers.js';
 import { defaultCredentialStore } from './store.js';
 /** The models `providerId`'s stored login serves; `NOT_LOGGED_IN` without one. */
 export async function listModels(providerId, store = defaultCredentialStore()) {
@@ -11,4 +12,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/opencode-console.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `opencodeConsole('deepseek-v4.1-flash')`: an OpenCode Console workspace as
+ * an AI SDK model, Zen for a bare id and Go for a `go/` one. The first call
+ * reads the workspace config for the model's protocol and lazily loads the
+ * SDK for it. Requests get the prompt-cache hints the runner itself adds for
+ * OpenAI and Anthropic, which it cannot do here since the protocol is unknown
+ * until then. `OPENCODE_API_KEY` replaces the stored login when set.
+ */
+import type { LanguageModelV4 } from '@ai-sdk/provider';
+export declare function opencodeConsole(modelId: string): LanguageModelV4;