e2e 0.15.2 → 0.17.0

package/dist/oauth/opencode-console.js

@@ -0,0 +1,133 @@
+/**
+ * `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 { randomUUID } from 'node:crypto';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { promptCacheKey } from '../agent/model/provider-hints.js';
+import { OAuthError } from './errors.js';
+import { createOAuthFetch } from './fetch.js';
+import { USER_AGENT } from '../internal/client-identity.js';
+import { loginHint } from './providers.js';
+import { createOpencodeConsoleProvider, opencodeConsoleChatRoute, opencodeConsoleRouteFor } from './providers/opencode-console.js';
+import { EnvCredentialStore, defaultCredentialStore } from './store.js';
+const CONFIG_TIMEOUT_MS = 10_000;
+const API_KEY_ENV = 'OPENCODE_API_KEY';
+const BREAKPOINT = { cacheControl: { type: 'ephemeral' } };
+export function opencodeConsole(modelId) {
+    const apiKey = process.env[API_KEY_ENV]?.trim();
+    const fetch = createOAuthFetch(createOpencodeConsoleProvider(), {
+        store: apiKey ? apiKeyStore(apiKey) : defaultCredentialStore(),
+        userAgent: USER_AGENT,
+        loginHint: apiKey ? `check ${API_KEY_ENV}` : loginHint('opencode-console'),
+    });
+    // One per model, so a worker's calls stay on one upstream and its cache.
+    const session = `e2e_${randomUUID()}`;
+    const chatRoute = opencodeConsoleChatRoute(modelId);
+    const chat = { npm: chatRoute.npm, model: chatModel(chatRoute, fetch, session) };
+    let resolved;
+    let pending;
+    // An unreadable config sends that call over chat and is asked again next time.
+    const served = () => {
+        if (resolved !== undefined)
+            return Promise.resolve(resolved);
+        pending ??= (async () => {
+            const route = await opencodeConsoleRouteFor(modelId, fetch, AbortSignal.timeout(CONFIG_TIMEOUT_MS));
+            if (route === undefined)
+                return chat;
+            resolved = { npm: route.npm, model: await sdkModel(route, fetch, session) };
+            return resolved;
+        })().finally(() => {
+            pending = undefined;
+        });
+        return pending;
+    };
+    // Fixed: the runner reads provider and modelId before and after the first call.
+    return {
+        specificationVersion: chat.model.specificationVersion,
+        provider: chatRoute.go ? 'opencode.go' : 'opencode',
+        modelId: chatRoute.modelId,
+        get supportedUrls() {
+            return (resolved ?? chat).model.supportedUrls;
+        },
+        async doGenerate(options) {
+            const { npm, model } = await served();
+            return model.doGenerate(requestFor(npm, options, session));
+        },
+        async doStream(options) {
+            const { npm, model } = await served();
+            return model.doStream(requestFor(npm, options, session));
+        },
+    };
+}
+/** A Console service API key as a login with nothing to refresh. */
+function apiKeyStore(apiKey) {
+    return new EnvCredentialStore(JSON.stringify({ 'opencode-console': { access: apiKey, refresh: '', expires: 0 } }));
+}
+/** `opencode.go` keeps Go's provider options under `opencode`, the name up to the first dot; `apiKey` only satisfies the constructors. */
+function settings(route, fetch, session) {
+    return { name: route.go ? 'opencode.go' : 'opencode', baseURL: route.baseURL, apiKey: 'oauth', fetch, headers: { 'x-opencode-session': session } };
+}
+function chatModel(route, fetch, session) {
+    return createOpenAICompatible({ ...settings(route, fetch, session), includeUsage: true }).chatModel(route.modelId);
+}
+async function sdkModel(route, fetch, session) {
+    switch (route.npm) {
+        case '@ai-sdk/openai': {
+            const { createOpenAI } = await load(() => import('@ai-sdk/openai'), route);
+            return createOpenAI(settings(route, fetch, session)).responses(route.modelId);
+        }
+        case '@ai-sdk/anthropic': {
+            const { createAnthropic } = await load(() => import('@ai-sdk/anthropic'), route);
+            return createAnthropic(settings(route, fetch, session))(route.modelId);
+        }
+        case '@ai-sdk/google': {
+            const { createGoogleGenerativeAI } = await load(() => import('@ai-sdk/google'), route);
+            return createGoogleGenerativeAI(settings(route, fetch, session))(route.modelId);
+        }
+        default:
+            return chatModel(route, fetch, session);
+    }
+}
+/** Responses: no server storage and the runner's prompt cache key. Anthropic: cache breakpoints. */
+function requestFor(npm, options, session) {
+    switch (npm) {
+        case '@ai-sdk/openai': {
+            const system = options.prompt.flatMap((message) => (message.role === 'system' ? [message.content] : [])).join('\n');
+            const cacheKey = system === '' ? session : promptCacheKey(system);
+            return { ...options, providerOptions: { ...options.providerOptions, openai: { promptCacheKey: cacheKey, ...options.providerOptions?.['openai'], store: false } } };
+        }
+        case '@ai-sdk/anthropic':
+            return { ...options, prompt: withBreakpoints(options.prompt, (options.tools?.length ?? 0) > 0) };
+        default:
+            return options;
+    }
+}
+/**
+ * The system prompt, and in a tool loop the newest message, as the runner
+ * marks them; a call without tools is a one-off judgment. A prompt that already
+ * carries a breakpoint is left as the caller placed it.
+ */
+function withBreakpoints(prompt, loop) {
+    if (prompt.some(hasBreakpoint))
+        return prompt;
+    const marked = new Set([prompt.findLastIndex((message) => message.role === 'system'), loop ? prompt.length - 1 : -1]);
+    return prompt.map((message, index) => marked.has(index) ? { ...message, providerOptions: { ...message.providerOptions, anthropic: { ...message.providerOptions?.['anthropic'], ...BREAKPOINT } } } : message);
+}
+function hasBreakpoint(message) {
+    const marked = (providerOptions) => providerOptions?.['anthropic']?.['cacheControl'] !== undefined;
+    return marked(message.providerOptions) || (Array.isArray(message.content) && message.content.some((part) => marked(part.providerOptions)));
+}
+/** Names the missing package when an SDK is not installed. */
+async function load(importer, route) {
+    try {
+        return await importer();
+    }
+    catch (cause) {
+        throw new OAuthError('MISCONFIGURED', `OpenCode Console serves ${route.modelId} through ${route.npm}, which opencodeConsole() loads on demand; install it beside @ai-sdk/openai-compatible`, { cause });
+    }
+}

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,15 @@ 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
+/** The endpoint `copilot()` reaches a Copilot chat model over: chat completions or the Responses API. */
+export type CopilotProtocol = 'chat' | 'responses';
+/**
+ * Which endpoint `copilot()` reaches `modelId` on, read from the Copilot
+ * API's `GET /models`, or `undefined` when the listing could not be read
+ * (an error status, a body that is not JSON, the network, the signal), so
+ * the caller can ask again instead of remembering a guess. A model the
+ * listing does not name, or names with no endpoint `copilot()` speaks, is
+ * chat: the vendor's own error then explains it. A rejected login is not a
+ * missing listing and rejects.
+ */
+export declare function copilotProtocolFor(modelId: string, fetch: FetchFunction, signal: AbortSignal): Promise<CopilotProtocol | undefined>;

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

@@ -92,30 +92,47 @@ export async function sendCopilotRequest(request, credentials, upstream) {
         url.host = new URL(copilotBaseUrl(credentials.enterpriseUrl)).host;
     const headers = new Headers(request.headers);
     headers.set('openai-intent', 'conversation-edits');
-    let initiator = 'user';
-    let vision = false;
     const text = request.method === 'POST' ? await request.text() : undefined;
-    if (text !== undefined) {
-        try {
-            const body = JSON.parse(text);
-            const messages = Array.isArray(body.messages) ? body.messages : [];
-            if (messages.at(-1)?.role !== 'user')
-                initiator = 'agent';
-            vision = messages.some((message) => Array.isArray(message.content) && message.content.some((part) => part?.type === 'image_url'));
-        }
-        catch {
-            // Not JSON; the headers stay at their defaults.
-        }
-    }
-    headers.set('x-initiator', initiator);
-    if (vision)
+    const turn = copilotTurn(text);
+    headers.set('x-initiator', turn.initiator);
+    if (turn.vision)
         headers.set('copilot-vision-request', 'true');
     return upstream(new Request(url, { method: request.method, headers, signal: request.signal, ...(text === undefined ? {} : { body: text }) }));
 }
+/**
+ * Reads who initiated the turn and whether images are present, whichever
+ * protocol carried the body. Chat completions put turns in `messages[]` and
+ * images in `image_url` parts; the Responses API puts them in `input[]` with
+ * `input_image`. A body shaped like neither keeps the defaults.
+ */
+function copilotTurn(text) {
+    if (text === undefined)
+        return { initiator: 'user', vision: false };
+    try {
+        const body = 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;
+            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')) };
+    }
+    catch {
+        // Not JSON; the headers stay at their defaults.
+        return { initiator: 'user', vision: false };
+    }
+}
+/** Whether a turn's content carries a part of the given type (`image_url` for chat, `input_image` for Responses). */
+function hasPart(content, type) {
+    return Array.isArray(content) && content.some((part) => part?.type === type);
+}
 /**
  * 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 it cannot call
+ * at all is listed but marked: one the plan has not enabled, or one Copilot
+ * serves only over APIs `copilot()` does not speak (such as Messages). 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 +149,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,
+            copilotProtocol(model) === undefined ? 'no chat or responses' : undefined,
         ].filter((part) => part !== undefined);
         return {
             id: model.id,
@@ -140,4 +159,46 @@ async function listCopilotModels(fetch) {
         };
     });
 }
-//# sourceMappingURL=github-copilot.js.map
+/**
+ * Which endpoint `copilot()` reaches `modelId` on, read from the Copilot
+ * API's `GET /models`, or `undefined` when the listing could not be read
+ * (an error status, a body that is not JSON, the network, the signal), so
+ * the caller can ask again instead of remembering a guess. A model the
+ * listing does not name, or names with no endpoint `copilot()` speaks, is
+ * chat: the vendor's own error then explains it. A rejected login is not a
+ * missing listing and rejects.
+ */
+export async function copilotProtocolFor(modelId, fetch, signal) {
+    try {
+        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))
+            return undefined;
+        return copilotProtocol(payload.data.find((model) => model.id === modelId)) ?? 'chat';
+    }
+    catch (error) {
+        if (error instanceof OAuthError)
+            throw error;
+        return undefined;
+    }
+}
+/**
+ * The protocol one `/models` entry is served on, or `undefined` when
+ * `copilot()` cannot call it. An entry that names no endpoints is chat, as
+ * Copilot's older models are; chat completions wins when both are named, so
+ * a model that worked over chat keeps doing so. Whether the plan enabled the
+ * model is a separate question: Copilot rejects a disabled model the same
+ * way on either endpoint.
+ */
+function copilotProtocol(model) {
+    const endpoints = model?.supported_endpoints;
+    if (model === undefined || !Array.isArray(endpoints))
+        return 'chat';
+    if (endpoints.includes('/chat/completions'))
+        return 'chat';
+    if (endpoints.includes('/responses'))
+        return 'responses';
+    return undefined;
+}

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

@@ -46,4 +46,3 @@ export declare function sendCodexRequest(request: Request, credentials: CodexCre
     originator: string;
     apiUrl: string;
 }): Promise<Response>;
-//# sourceMappingURL=openai.d.ts.map

package/dist/oauth/providers/openai.js

@@ -29,7 +29,7 @@ const REQUIRED_INSTRUCTIONS = 'Follow the user request.';
  * client is too old for. This is the Codex CLI release current when the list
  * was last checked; bump it when a model the ChatGPT app shows is missing.
  */
-const CODEX_CLIENT_VERSION = '0.155.1';
+const CODEX_CLIENT_VERSION = '0.160.0';
 export function createCodexProvider(options = {}) {
     const originator = options.originator ?? 'e2e';
     const issuer = options.issuer ?? ISSUER;
@@ -286,4 +286,3 @@ async function listCodexModels(fetch, apiUrl) {
         };
     });
 }
-//# sourceMappingURL=openai.js.map

package/dist/oauth/providers/opencode-console.d.ts

@@ -0,0 +1,31 @@
+/**
+ * OpenCode Zen and Go through an OpenCode Console sign-in. Console speaks RFC
+ * 8628 device authorization; approving the code binds the login to one
+ * workspace, and its token is a bearer for both the Console API and inference.
+ * Refresh tokens rotate. The workspace config says which models are served and
+ * 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 type { FetchFunction, OAuthCredentials, OAuthProvider } from '../types.ts';
+export interface OpencodeConsoleCredentials extends OAuthCredentials {
+    /** The workspace the login is bound to; absent for a service API key. */
+    readonly orgId?: string;
+}
+export interface OpencodeConsoleProviderOptions {
+    /** Test seam. */
+    readonly consoleUrl?: string;
+}
+export declare function createOpencodeConsoleProvider(options?: OpencodeConsoleProviderOptions): OAuthProvider<OpencodeConsoleCredentials, Record<string, never>>;
+export interface OpencodeConsoleRoute {
+    readonly go: boolean;
+    readonly npm: string;
+    readonly baseURL: string;
+    readonly modelId: string;
+}
+/** The plan's chat completions route, used until the config is read. */
+export declare function opencodeConsoleChatRoute(modelId: string): OpencodeConsoleRoute;
+/**
+ * The model's route from the workspace config, or `undefined` when the config
+ * could not be read, so the caller asks again rather than remembering a guess.
+ */
+export declare function opencodeConsoleRouteFor(modelId: string, fetch: FetchFunction, signal: AbortSignal): Promise<OpencodeConsoleRoute | undefined>;

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

@@ -0,0 +1,148 @@
+/**
+ * OpenCode Zen and Go through an OpenCode Console sign-in. Console speaks RFC
+ * 8628 device authorization; approving the code binds the login to one
+ * workspace, and its token is a bearer for both the Console API and inference.
+ * Refresh tokens rotate. The workspace config says which models are served and
+ * 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 { rfc8628Flow } from '../device-code.js';
+import { OAuthError, describeResponse } from '../errors.js';
+import { expiryFrom, requestTokens } from '../token-endpoint.js';
+/** Console accepts any client id. */
+const CLIENT_ID = 'e2e';
+const CONSOLE_URL = 'https://opencode.ai/console';
+const INFERENCE_URL = 'https://opencode.ai/inference';
+const GO_PREFIX = 'go/';
+const ZEN_PROVIDER = 'opencode';
+const GO_PROVIDER = 'opencode-go';
+export function createOpencodeConsoleProvider(options = {}) {
+    const consoleUrl = options.consoleUrl ?? CONSOLE_URL;
+    const tokenUrl = `${consoleUrl}/auth/device/token`;
+    return {
+        id: 'opencode-console',
+        name: 'OpenCode Console',
+        async login(callbacks) {
+            const deviceCodeUrl = `${consoleUrl}/auth/device/code`;
+            const tokens = await rfc8628Flow({
+                vendor: 'OpenCode Console',
+                deviceCodeUrl,
+                tokenUrl,
+                clientId: CLIENT_ID,
+                request: { supports_org_scope: 'true' },
+                // Console answers with a relative verification URL.
+                callbacks: {
+                    ...callbacks,
+                    onAuth: (info) => {
+                        const url = new URL(info.url, deviceCodeUrl).href;
+                        callbacks.onAuth({
+                            ...info,
+                            url,
+                            instructions: `Open ${url} on any device, pick the workspace to sign in to${info.userCode === undefined ? '' : `, and confirm the code ${info.userCode}`}.`,
+                        });
+                    },
+                },
+            });
+            return toCredentials(tokens);
+        },
+        async refresh(credentials) {
+            if (credentials.refresh === '')
+                throw new OAuthError('LOGIN_REQUIRED', 'OpenCode Console has no refresh token for this login');
+            const tokens = await requestTokens('OpenCode Console', tokenUrl, { grant_type: 'refresh_token', refresh_token: credentials.refresh, client_id: CLIENT_ID }, 'LOGIN_REQUIRED');
+            return toCredentials(tokens, credentials);
+        },
+        send(request, credentials, upstream) {
+            return sendOpencodeConsoleRequest(request, credentials, upstream, consoleUrl);
+        },
+        models(fetch) {
+            return listOpencodeConsoleModels(fetch, consoleUrl);
+        },
+    };
+}
+/** Names the workspace as each API expects, and drops the Google SDK's placeholder key header. */
+async function sendOpencodeConsoleRequest(request, credentials, upstream, consoleUrl) {
+    const headers = new Headers(request.headers);
+    headers.delete('x-goog-api-key');
+    if (credentials.orgId !== undefined)
+        headers.set(request.url.startsWith(`${consoleUrl}/`) ? 'x-org-id' : 'x-opencode-org-id', credentials.orgId);
+    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 }) }));
+}
+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 : {};
+}
+/** 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 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,
+        ].filter((part) => part !== undefined);
+        return { id: `${prefix}${id}`, ...(typeof model.name === 'string' && model.name !== '' ? { name: model.name } : {}), detail: detail.join(', ') };
+    });
+    return [...listed(ZEN_PROVIDER, '', 'Zen'), ...listed(GO_PROVIDER, GO_PREFIX, 'Go')];
+}
+function isFree(model) {
+    return model.cost?.input === 0 && model.cost.output === 0;
+}
+const CHAT_NPM = '@ai-sdk/openai-compatible';
+function splitModelId(modelId) {
+    const go = modelId.startsWith(GO_PREFIX);
+    return { go, id: go ? modelId.slice(GO_PREFIX.length) : modelId };
+}
+/** The plan's chat completions route, used until the config is read. */
+export function opencodeConsoleChatRoute(modelId) {
+    const { go, id } = splitModelId(modelId);
+    return { go, npm: CHAT_NPM, baseURL: `${INFERENCE_URL}${go ? '/go' : ''}/openai/v1`, modelId: id };
+}
+/**
+ * The model's route from the workspace config, or `undefined` when the config
+ * could not be read, so the caller asks again rather than remembering a guess.
+ */
+export async function opencodeConsoleRouteFor(modelId, fetch, signal) {
+    let providers;
+    try {
+        providers = await readConfig(fetch, CONSOLE_URL, signal);
+    }
+    catch (error) {
+        if (error instanceof OAuthError && error.code !== 'FLOW_FAILED')
+            throw error;
+        return undefined;
+    }
+    const { go, id } = splitModelId(modelId);
+    const provider = providers[go ? GO_PROVIDER : ZEN_PROVIDER];
+    if (provider === undefined) {
+        throw new OAuthError('MISCONFIGURED', go
+            ? 'OpenCode Go is not available to this login: the workspace has no Go subscription, or the signed-in user is not its subscriber; sign in to the Go workspace with `npx e2e login opencode-console`'
+            : 'OpenCode Zen is turned off for this OpenCode Console workspace');
+    }
+    const model = provider.models?.[id];
+    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')
+        return undefined;
+    return { go, npm, baseURL, modelId: typeof model.id === 'string' && model.id !== '' ? model.id : 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 workspace = typeof orgId === 'string' && orgId !== '' ? orgId : previous?.orgId;
+    return {
+        access: tokens.access_token,
+        refresh: tokens.refresh_token ?? previous?.refresh ?? '',
+        expires: expiryFrom(tokens.expires_in),
+        ...(workspace === undefined ? {} : { orgId: workspace }),
+    };
+}

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

@@ -14,4 +14,3 @@ export interface XaiProviderOptions {
     readonly modelsUrl?: string;
 }
 export declare function createXaiProvider(options?: XaiProviderOptions): OAuthProvider<OAuthCredentials, Record<string, never>>;
-//# sourceMappingURL=xai.d.ts.map

package/dist/oauth/providers/xai.js

@@ -65,4 +65,3 @@ function toCredentials(tokens, previousRefresh) {
     const expires = typeof exp === 'number' && exp > 0 ? exp * 1000 : expiryFrom(tokens.expires_in);
     return { access: tokens.access_token, refresh: tokens.refresh_token ?? previousRefresh, expires };
 }
-//# sourceMappingURL=xai.js.map

package/dist/oauth/providers.d.ts

@@ -5,17 +5,12 @@ import type { OAuthProvider } from './types.ts';
 export interface LoginOptionsById {
     readonly openai: CodexLoginOptions;
     readonly 'github-copilot': CopilotLoginOptions;
+    readonly 'opencode-console': Record<string, never>;
     readonly spacexai: Record<string, never>;
 }
 export type ProviderId = keyof LoginOptionsById;
-export declare const PROVIDER_IDS: readonly ["openai", "github-copilot", "spacexai"];
+export declare const PROVIDER_IDS: readonly ["openai", "github-copilot", "opencode-console", "spacexai"];
 export declare function isProviderId(id: string): id is ProviderId;
 export declare function getProvider(id: ProviderId): OAuthProvider;
-/**
- * How requests identify this harness to a vendor: `e2e/<version> (<platform>; <arch>)`,
- * alongside the `originator` (ChatGPT) and `referrer` (SpaceXAI) the flows send. Never another client's name.
- */
-export declare const USER_AGENT: string;
 /** How a missing login is described to the user: the CLI command that fixes it. */
 export declare function loginHint(id: ProviderId): string;
-//# sourceMappingURL=providers.d.ts.map

package/dist/oauth/providers.js

@@ -1,13 +1,14 @@
 /** The built-in providers by id, and the login options each one takes. */
-import { packageVersion } from '../internal/package-version.js';
 import { createCodexProvider } from './providers/openai.js';
 import { createCopilotProvider } from './providers/github-copilot.js';
+import { createOpencodeConsoleProvider } from './providers/opencode-console.js';
 import { createXaiProvider } from './providers/xai.js';
-export const PROVIDER_IDS = ['openai', 'github-copilot', 'spacexai'];
+export const PROVIDER_IDS = ['openai', 'github-copilot', 'opencode-console', 'spacexai'];
 // Method shorthand is bivariant, so each specialised provider fits the base interface without a cast.
 const PROVIDERS = {
     openai: createCodexProvider(),
     'github-copilot': createCopilotProvider(),
+    'opencode-console': createOpencodeConsoleProvider(),
     spacexai: createXaiProvider(),
 };
 export function isProviderId(id) {
@@ -16,13 +17,7 @@ export function isProviderId(id) {
 export function getProvider(id) {
     return PROVIDERS[id];
 }
-/**
- * How requests identify this harness to a vendor: `e2e/<version> (<platform>; <arch>)`,
- * alongside the `originator` (ChatGPT) and `referrer` (SpaceXAI) the flows send. Never another client's name.
- */
-export const USER_AGENT = `e2e/${packageVersion(import.meta.url, '../../package.json', '0.0.0')} (${process.platform}; ${process.arch})`;
 /** How a missing login is described to the user: the CLI command that fixes it. */
 export function loginHint(id) {
     return `run \`npx e2e login ${id}\``;
 }
-//# sourceMappingURL=providers.js.map

package/dist/oauth/responses.d.ts

@@ -0,0 +1,9 @@
+/** Helpers shared by the subscription models that ride the Responses API. */
+import type { LanguageModelV4 } from '@ai-sdk/provider';
+/**
+ * Tells the SDK what a subscription 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.
+ */
+export declare function withoutServerStorage(model: LanguageModelV4): LanguageModelV4;

package/dist/oauth/responses.js

@@ -0,0 +1,23 @@
+/** Helpers shared by the subscription models that ride the Responses API. */
+/**
+ * Tells the SDK what a subscription 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.
+ */
+export function withoutServerStorage(model) {
+    const storeOff = (options) => ({
+        ...options,
+        providerOptions: { ...options.providerOptions, openai: { ...options.providerOptions?.['openai'], store: false } },
+    });
+    return {
+        specificationVersion: model.specificationVersion,
+        provider: model.provider,
+        modelId: model.modelId,
+        get supportedUrls() {
+            return model.supportedUrls;
+        },
+        doGenerate: (options) => model.doGenerate(storeOff(options)),
+        doStream: (options) => model.doStream(storeOff(options)),
+    };
+}

package/dist/oauth/sse.d.ts

@@ -19,4 +19,3 @@ export interface SseEvent {
 /** Splits a text/event-stream body into events, tolerating either newline convention. */
 export declare function parseSse(text: string): SseEvent[];
 export declare function foldResponsesStream(response: Response): Promise<Response>;
-//# sourceMappingURL=sse.d.ts.map

package/dist/oauth/sse.js

@@ -86,4 +86,3 @@ function withOutput(response, items) {
 function json(status, body) {
     return new Response(JSON.stringify(body), { status, headers: { 'content-type': 'application/json' } });
 }
-//# sourceMappingURL=sse.js.map

package/dist/oauth/store.d.ts

@@ -38,4 +38,3 @@ export declare class EnvCredentialStore implements CredentialStore {
     remove(): Promise<void>;
     list(): Promise<string[]>;
 }
-//# sourceMappingURL=store.d.ts.map

package/dist/oauth/store.js

@@ -166,4 +166,3 @@ function isCredentials(value) {
     const record = value;
     return typeof record['access'] === 'string' && typeof record['refresh'] === 'string' && typeof record['expires'] === 'number';
 }
-//# sourceMappingURL=store.js.map

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

@@ -23,4 +23,3 @@ export declare function requestTokens(vendor: string, url: string, params: Recor
 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;
-//# sourceMappingURL=token-endpoint.d.ts.map

package/dist/oauth/token-endpoint.js

@@ -41,4 +41,3 @@ export function expiryFrom(expiresIn, now = Date.now()) {
     const expiry = now + positiveSeconds(expiresIn, 3600) * 1000;
     return Number.isFinite(expiry) ? expiry : now + 3600 * 1000;
 }
-//# sourceMappingURL=token-endpoint.js.map

package/dist/oauth/types.d.ts

@@ -73,4 +73,3 @@ export interface CredentialStore {
     /** Every provider id with stored credentials. */
     list(): Promise<string[]>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/oauth/types.js

@@ -6,4 +6,3 @@
  * constructors) is shared.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/params.d.ts

@@ -19,4 +19,3 @@ export interface Unique {
  */
 export declare function unique(value: string): Unique;
 export declare function isUnique(value: unknown): value is Unique;
-//# sourceMappingURL=params.d.ts.map

package/dist/params.js

@@ -25,4 +25,3 @@ export function unique(value) {
 export function isUnique(value) {
     return typeof value === 'object' && value !== null && value[uniqueBrand] === true;
 }
-//# sourceMappingURL=params.js.map