e2e 0.16.0 → 0.18.0

package/dist/mcp/session.js

@@ -21,7 +21,7 @@ import { LocatorEngine } from '../locator/engine.js';
 import { allocateAppPorts } from '../run/app-ports.js';
 import { SharedAppProcesses } from '../run/process-pool.js';
 import { outputLayout } from '../run/output.js';
-import { sessionSecrecy } from '../run/secrecy.js';
+import { processSecrets, registerStaticSecrets, sessionSecrecy } from '../run/secrecy.js';
 import { openStandaloneAttempt } from '../run/standalone.js';
 import { createSessionCatalog, isGrammarVerb } from './catalog.js';
 import { describeRecording, SessionRecorder } from './recording.js';
@@ -55,9 +55,13 @@ export class SessionHost {
     get maxSessions() {
         return this.options.maxSessions ?? SESSION_BOUNDS.default;
     }
-    /** The server's tools: the same four whatever the project, the config, or the target. */
+    /** The server's tools: the same four whatever the project, the config, or the target, each redacting what it returns. */
     toolSpecs() {
-        return [this.openSpec(), this.catalogSpec(), this.callSpec(), this.closeSpec()];
+        return [this.openSpec(), this.catalogSpec(), this.callSpec(), this.closeSpec()].map(redacting);
+    }
+    /** Logs a line for the operator and the client, redacted with every secret value the process knows. */
+    log(level, message) {
+        this.options.log(level, processSecrets.redact(message));
     }
     /**
      * Opens a session and returns its opening text: the summary, the catalog,
@@ -65,8 +69,9 @@ export class SessionHost {
      * it, or disconnects, aborts the open and what it started.
      */
     open(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) => {
+        const headed = options.headed ?? this.options.headed;
+        const usage = new SessionUsage(this.sessions.liveCount, headed);
+        return this.sessions.admit((id) => this.openSession(id, options, headed, usage, signal)).catch((cause) => {
             this.options.onSessionEnd?.(usage.openFailed(classifyError(cause).code));
             throw cause;
         });
@@ -99,7 +104,8 @@ export class SessionHost {
             lines.push(`The session step ended with: ${errorMessage(value.outcome.error)}`);
         for (const error of cleanupErrors)
             lines.push(`Cleanup: ${error.code}: ${error.message}`);
-        return lines.join('\n');
+        // Redacted here, not only at the tool boundary: closeAll writes it to stderr.
+        return processSecrets.redact(lines.join('\n'));
     }
     /**
      * Runs `settle` (ending the step, saving a recording), then closes the
@@ -149,7 +155,7 @@ export class SessionHost {
             return redactResult(errorResult(cause), redact);
         });
     }
-    async openSession(id, options, usage, request) {
+    async openSession(id, options, headed, 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.
@@ -159,7 +165,16 @@ export class SessionHost {
         // knows that session's config.
         const configPath = this.options.locateConfig(options.config);
         this.sessions.claimConfig(id, configPath);
-        const loaded = await this.options.loadConfig(configPath);
+        const withhold = this.options.withholdOutput ?? ((load) => load());
+        const loaded = await withhold(async () => {
+            const fresh = await this.options.loadConfig(configPath);
+            // Known to the process before anything can fail with one, so an open
+            // failure and what the config printed while it loaded are redacted
+            // like any other text; a session registers them only once its engine
+            // has launched.
+            registerStaticSecrets(fresh.allSecrets);
+            return fresh;
+        });
         // 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);
@@ -184,12 +199,12 @@ export class SessionHost {
                 // one attempt that closes as passed, so it traces under `on` only.
                 config,
                 target: { ...target, video: { mode: 'off', source: 'default' } },
-                headed: this.options.headed,
+                headed,
                 env: this.options.env,
                 signal: abort.signal,
                 timeoutMs: ttlMs + CLOSE_GRACE_MS,
                 processes: this.apps,
-                notice: (scope, message) => this.options.log('info', `${scope}: ${message}`),
+                notice: (scope, message) => this.log('info', `${scope}: ${message}`),
             });
             // The coding agent is the brain: the step is driven from here, and the
             // configured model stays out of the way.
@@ -207,7 +222,7 @@ export class SessionHost {
                 screen,
                 session: attempt.session,
                 tools: config.agent.tools,
-                redact: attempt.agentRuntime.redact,
+                redaction: { redact: attempt.agentRuntime.redact, redactCut: attempt.agentRuntime.redactCut },
                 recorder,
                 locator: new LocatorEngine({
                     session: attempt.session,
@@ -217,13 +232,14 @@ export class SessionHost {
                     actionTimeout: config.actionTimeout,
                     assertionTimeout: config.assertionTimeout,
                 }),
-                warn: (message) => this.options.log('warning', message),
+                warn: (message) => this.log('warning', message),
                 onActionFailed: (cause) => usage.failed(classifyError(cause).code),
             });
             const live = {
                 id,
                 target,
                 configPath: loaded.configPath,
+                headed,
                 attempt,
                 step,
                 screen,
@@ -257,8 +273,8 @@ export class SessionHost {
     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, endedBy).catch((cause) => this.options.log('error', `closing session ${live.id} failed: ${errorMessage(cause)}`));
+        this.log('warning', `session ${live.id} ended: ${why}`);
+        this.close(why, live.id, endedBy).catch((cause) => this.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) {
@@ -315,7 +331,7 @@ export class SessionHost {
     openingText(live, config, screen) {
         const engine = live.target.engine;
         const lines = [
-            `Session ${live.id} open on target "${live.target.name}" (platform ${live.target.platform}, engine ${engine === undefined ? 'none' : `${engine.name} ${engine.version}`}), ${this.options.headed ? 'headed' : 'headless'}; config ${live.configPath}.`,
+            `Session ${live.id} open on target "${live.target.name}" (platform ${live.target.platform}, engine ${engine === undefined ? 'none' : `${engine.name} ${engine.version}`}), ${live.headed ? 'headed' : 'headless'}; config ${live.configPath}.`,
         ];
         if (live.target.app.base !== undefined) {
             lines.push(`App: ${live.target.app.base.href}.`);
@@ -385,6 +401,10 @@ export class SessionHost {
             inputSchema: z.object({
                 target: z.string().min(1).optional().describe('Target name from the config; required when the config declares several'),
                 config: z.string().min(1).optional().describe("Path to an e2e config file, relative to the server's directory; default: the nearest e2e.config.ts"),
+                headed: z
+                    .boolean()
+                    .optional()
+                    .describe('Show the browser or simulator, when the engine supports it; pass true when the user wants to watch. Default: headless, unless the server was started with --headed'),
             }).strict(),
             readOnly: false,
             call: async (args, extra) => textResult(await this.open(args, extra.signal)),
@@ -427,3 +447,24 @@ export class SessionHost {
         });
     }
 }
+/**
+ * The tool with what it returns redacted with every secret value the process
+ * knows: the static values of each config a session loaded, and every value
+ * a session resolved or derived. A failure becomes a result the agent can
+ * react to, never a protocol error, and is redacted the same way.
+ */
+function redacting(spec) {
+    return {
+        ...spec,
+        call: async (args, extra) => {
+            let result;
+            try {
+                result = await spec.call(args, extra);
+            }
+            catch (cause) {
+                result = errorResult(cause);
+            }
+            return redactResult(result, (text) => processSecrets.redact(text));
+        },
+    };
+}

package/dist/mcp/tools.js

@@ -192,13 +192,15 @@ async function resolveOutput(value) {
  * else is JSON, so a structured output is never lost.
  */
 export async function resultFromOutput(tool, output, input = undefined) {
-    if (typeof output === 'string')
-        return textResult(output);
     if (tool.toModelOutput !== undefined) {
-        const content = contentFromModelOutput(await tool.toModelOutput({ toolCallId: 'mcp', input, output }));
-        if (content !== undefined)
-            return { content };
+        const rendered = await tool.toModelOutput({ toolCallId: 'mcp', input, output });
+        const content = contentFromModelOutput(rendered);
+        if (content !== undefined) {
+            return { content, ...(rendered.type === 'error-text' || rendered.type === 'error-json' ? { isError: true } : {}) };
+        }
     }
+    if (typeof output === 'string')
+        return textResult(output);
     return textResult(output === undefined ? 'Done.' : JSON.stringify(output, null, 2));
 }
 function contentFromModelOutput(output) {

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,25 +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)),
-    };
-}

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. */

package/dist/oauth/copilot.d.ts

@@ -1,9 +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;

package/dist/oauth/copilot.js

@@ -1,26 +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));
+    });
 }

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) {

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()) {

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;

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/providers/github-copilot.d.ts

@@ -36,3 +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>;
+/** 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>;