@nylorun/runtime 0.20.0-beta → 0.21.0-beta

package/dist/vault/sources.d.ts

@@ -1,60 +1,32 @@
-import type { CredentialSelection } from "@nylorun/core/contracts";
+/**
+ * Where a session's MCP or HTTP tool credential comes from: the vaults attached to the session,
+ * and nothing else. OSS holds no OAuth client and asks no credential resolver (protocol 10,
+ * D49): a person's own keys live in their user vault, the installation's in its vaults.
+ *
+ * Both authorize sites call this: the gateway (`gates/tenant-vaults.ts`, remote MCP servers and
+ * HTTP tools in the gates service) and the Tenant (`tenant/effects.ts`, the in-process MCP pool
+ * and Tool Gate). The session comes from its row, never from the harness.
+ */
+import { type CredentialSelection } from "@nylorun/core/contracts";
 import type { AuthorizeResult, VaultService } from "./service.js";
-/** The operator's credential resolver (`NYLORUN_RESOLVER_URL`, `NYLORUN_RESOLVER_TOKEN`). */
-export interface ResolverConfig {
-    readonly url: string;
-    readonly token: string;
-}
-/** What the resolver is asked about: the session's row, as stored. */
+/** The session a request is made for: its row, as stored. */
 export interface CredentialSession {
     readonly id: string;
     readonly ownerUserId: string;
-    readonly activeTurnId: string | null;
     readonly vaultIds?: readonly string[];
     readonly credentialSelections?: readonly CredentialSelection[];
 }
-/**
- * One MCP request: the declared server's URL, its name and the agent that declares it. Or, with
- * `kind: "http"`, an HTTP tool's request: its URL and its `credential` name as `serverName`.
- */
+/** One MCP or HTTP tool request: its URL, and the name a credential selection matches. */
 export interface McpCredentialRequest {
-    /** Default `mcp`. */
-    readonly kind?: "mcp" | "http";
     readonly url: string;
     /** The server's name, or the HTTP tool's `credential`: what a credential selection names. */
     readonly serverName?: string;
-    /** The agent used as a tool that declares the server; absent for the session's root agent. */
-    readonly agentId?: string;
-}
-export interface CredentialSourcesOptions {
-    readonly vault: Pick<VaultService, "authorize">;
-    /** Absent: the vaults are the only source, as before F9. */
-    readonly resolver?: ResolverConfig;
-    /** Default `globalThis.fetch`. */
-    readonly fetch?: typeof fetch;
-    /** How long the resolver may take. Default 5 s. */
-    readonly timeoutMs?: number;
-    readonly now?: () => number;
-}
-export declare const RESOLVER_TIMEOUT_MS = 5000;
-/** The longest an answer is kept, whatever its `expiresAt`. */
-export declare const RESOLVER_MAX_CACHE_MS: number;
-/** How long an answer without `expiresAt` (and a 404) is kept. */
-export declare const RESOLVER_DEFAULT_CACHE_MS = 60000;
-/** The refusal reason when the resolver could not answer. */
-export declare const CREDENTIAL_UNAVAILABLE = "credential_unavailable";
-export declare class CredentialSources {
-    private readonly vault;
-    private readonly resolver;
-    private readonly fetchImpl;
-    private readonly timeoutMs;
-    private readonly now;
-    private readonly cache;
-    private readonly pending;
-    constructor(options: CredentialSourcesOptions);
-    /** The credential of one MCP request made for `session`. */
-    authorize(session: CredentialSession, request: McpCredentialRequest): Promise<AuthorizeResult>;
-    private answer;
-    private until;
-    private ask;
 }
+/**
+ * The credential of one request made for `session`: the vault's answer over the session's
+ * attached vaults (`VaultService.authorize`). A credential with an identity header (R2b C2)
+ * gets the session owner's subject in it (Q2), from the session row: the run token names no
+ * owner, so neither the model nor the manifest can change it. A session whose owner is no
+ * person (the reserved `installation`) sends none (Q3).
+ */
+export declare function sessionCredentials(vault: Pick<VaultService, "authorize">, session: CredentialSession, request: McpCredentialRequest): Promise<AuthorizeResult>;

package/dist/vault/sources.js

@@ -1,196 +1,32 @@
 /**
- * Where a session's MCP or HTTP tool credential comes from (F9 C1): the session's attached
- * vaults first, then the operator's credential resolver, an HTTP service on the operator's own
- * network that holds people's own credentials (OSS never stores them, F9-D7).
+ * Where a session's MCP or HTTP tool credential comes from: the vaults attached to the session,
+ * and nothing else. OSS holds no OAuth client and asks no credential resolver (protocol 10,
+ * D49): a person's own keys live in their user vault, the installation's in its vaults.
  *
  * Both authorize sites call this: the gateway (`gates/tenant-vaults.ts`, remote MCP servers and
  * HTTP tools in the gates service) and the Tenant (`tenant/effects.ts`, the in-process MCP pool
- * and Tool Gate).
- *
- * ## The resolver contract
- *
- * Asked only when the attached vaults hold no credential for the URL (the vault's
- * `unauthenticated`), and only for a person's session (never a reserved owner):
- *
- * ```text
- * POST <resolver url>
- * Authorization: Bearer <resolver token>
- * { "owner": "u:priya", "session": "s_…", "turn": "t_…" | null,
- *   "target": { "kind": "mcp", "server": "github", "agent": "support", "url": "https://…/mcp" } }
- *
- * 200 { "headers": { "authorization": "Bearer …" }, "expiresAt"?: "<ISO time>" } → authorized
- * 404                                         → unauthenticated (the call goes without one)
- * anything else, a bad body, or no answer in 5 s → refused: credential_unavailable
- * ```
- *
- * An HTTP tool's request (R2 M3) names its `credential` instead of a server:
- * `"target": { "kind": "http", "credential": "billing", "agent"?: "support", "url": "https://…" }`.
- *
- * `owner` and `turn` come from the session row, never from the harness. Because authorize runs
- * on every MCP HTTP request, answers (200 and 404) are cached per (owner, url): until
- * `expiresAt`, at most 5 minutes, and 60 s without one. Concurrent misses for one key share one
- * request. Failures are not cached. The resolver's URL is the operator's, so private addresses
- * are allowed; redirects are refused.
+ * and Tool Gate). The session comes from its row, never from the harness.
  */
 import { isSubject } from "@nylorun/core/contracts";
-export const RESOLVER_TIMEOUT_MS = 5_000;
-/** The longest an answer is kept, whatever its `expiresAt`. */
-export const RESOLVER_MAX_CACHE_MS = 5 * 60_000;
-/** How long an answer without `expiresAt` (and a 404) is kept. */
-export const RESOLVER_DEFAULT_CACHE_MS = 60_000;
-/** The refusal reason when the resolver could not answer. */
-export const CREDENTIAL_UNAVAILABLE = "credential_unavailable";
-/** RFC 9110 field names. */
-const HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-/** Headers the MCP transport owns; a resolver may not set them. */
-const RESERVED_HEADERS = new Set([
-    "host",
-    "content-length",
-    "content-type",
-    "transfer-encoding",
-    "connection",
-    "accept",
-    "mcp-session-id",
-    "mcp-protocol-version",
-]);
-export class CredentialSources {
-    vault;
-    resolver;
-    fetchImpl;
-    timeoutMs;
-    now;
-    cache = new Map();
-    pending = new Map();
-    constructor(options) {
-        this.vault = options.vault;
-        this.resolver = options.resolver;
-        this.fetchImpl = options.fetch ?? globalThis.fetch;
-        this.timeoutMs = options.timeoutMs ?? RESOLVER_TIMEOUT_MS;
-        this.now = options.now ?? Date.now;
-    }
-    /** The credential of one MCP request made for `session`. */
-    async authorize(session, request) {
-        const result = await this.vault.authorize({
-            sessionId: session.id,
-            vaultIds: session.vaultIds ?? [],
-            credentialSelections: session.credentialSelections ?? [],
-            url: request.url,
-            ...(request.serverName === undefined ? {} : { serverName: request.serverName }),
-        });
-        if (result.status !== "unauthenticated" || !this.resolver)
-            return result;
-        // `host` and `installation` are no one: there is no person to resolve for.
-        if (!isSubject(session.ownerUserId))
-            return result;
-        const answer = await this.answer(session, request, result.url);
-        if (answer.kind === "failed")
-            return { status: "refused", url: result.url, credentialIds: [], reason: CREDENTIAL_UNAVAILABLE };
-        if (answer.kind === "none")
-            return result;
-        return { status: "authorized", url: result.url, headers: { ...answer.headers } };
-    }
-    async answer(session, request, url) {
-        const key = JSON.stringify([session.ownerUserId, url]);
-        const cached = this.cache.get(key);
-        if (cached) {
-            if (cached.until > this.now())
-                return cached.answer;
-            this.cache.delete(key);
-        }
-        let pending = this.pending.get(key);
-        if (!pending) {
-            pending = this.ask(session, request, url)
-                .then((answer) => {
-                if (answer.kind !== "failed") {
-                    const until = this.until(answer);
-                    if (until > this.now())
-                        this.cache.set(key, { answer, until });
-                }
-                return answer;
-            })
-                .finally(() => this.pending.delete(key));
-            this.pending.set(key, pending);
-        }
-        return pending;
-    }
-    until(answer) {
-        const now = this.now();
-        const cap = now + RESOLVER_MAX_CACHE_MS;
-        if (answer.kind === "headers" && answer.expiresAt !== undefined)
-            return Math.min(answer.expiresAt, cap);
-        return now + RESOLVER_DEFAULT_CACHE_MS;
-    }
-    async ask(session, request, url) {
-        const resolver = this.resolver;
-        const body = {
-            owner: session.ownerUserId,
-            session: session.id,
-            turn: session.activeTurnId ?? null,
-            target: request.kind === "http"
-                ? {
-                    kind: "http",
-                    ...(request.serverName ? { credential: request.serverName } : {}),
-                    ...(request.agentId ? { agent: request.agentId } : {}),
-                    url,
-                }
-                : {
-                    kind: "mcp",
-                    ...(request.serverName ? { server: request.serverName } : {}),
-                    ...(request.agentId ? { agent: request.agentId } : {}),
-                    url,
-                },
-        };
-        try {
-            const response = await this.fetchImpl(resolver.url, {
-                method: "POST",
-                headers: {
-                    authorization: `Bearer ${resolver.token}`,
-                    "content-type": "application/json",
-                    accept: "application/json",
-                },
-                body: JSON.stringify(body),
-                redirect: "error",
-                signal: AbortSignal.timeout(this.timeoutMs),
-            });
-            if (response.status === 404) {
-                await response.body?.cancel().catch(() => undefined);
-                return { kind: "none" };
-            }
-            if (response.status !== 200) {
-                await response.body?.cancel().catch(() => undefined);
-                return { kind: "failed" };
-            }
-            return parseAnswer(await response.json(), this.now());
-        }
-        catch {
-            return { kind: "failed" };
-        }
-    }
-}
-function parseAnswer(value, now) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return { kind: "failed" };
-    const { headers, expiresAt } = value;
-    if (!headers || typeof headers !== "object" || Array.isArray(headers))
-        return { kind: "failed" };
-    const entries = Object.entries(headers);
-    if (entries.length === 0)
-        return { kind: "failed" };
-    const out = {};
-    for (const [name, item] of entries) {
-        if (!HEADER_NAME.test(name) || RESERVED_HEADERS.has(name.toLowerCase()))
-            return { kind: "failed" };
-        if (typeof item !== "string" || item === "" || /[\r\n\0]/.test(item))
-            return { kind: "failed" };
-        out[name.toLowerCase()] = item;
-    }
-    if (expiresAt === undefined || expiresAt === null)
-        return { kind: "headers", headers: out };
-    if (typeof expiresAt !== "string")
-        return { kind: "failed" };
-    const at = Date.parse(expiresAt);
-    if (Number.isNaN(at))
-        return { kind: "failed" };
-    // An answer that has already expired is used once and not kept.
-    return { kind: "headers", headers: out, expiresAt: Math.max(at, now) };
+/**
+ * The credential of one request made for `session`: the vault's answer over the session's
+ * attached vaults (`VaultService.authorize`). A credential with an identity header (R2b C2)
+ * gets the session owner's subject in it (Q2), from the session row: the run token names no
+ * owner, so neither the model nor the manifest can change it. A session whose owner is no
+ * person (the reserved `installation`) sends none (Q3).
+ */
+export async function sessionCredentials(vault, session, request) {
+    const result = await vault.authorize({
+        sessionId: session.id,
+        vaultIds: session.vaultIds ?? [],
+        credentialSelections: session.credentialSelections ?? [],
+        url: request.url,
+        ...(request.serverName === undefined ? {} : { serverName: request.serverName }),
+    });
+    if (result.status !== "authorized" || !result.identity || !isSubject(session.ownerUserId))
+        return result;
+    return {
+        ...result,
+        headers: { ...result.headers, [result.identity.header]: session.ownerUserId },
+    };
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.20.0-beta";
+export declare const RUNTIME_VERSION = "0.21.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.20.0-beta";
+export const RUNTIME_VERSION = "0.21.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.20.0-beta",
+  "version": "0.21.0-beta",
   "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -65,8 +65,8 @@
     "@hono/node-server": "^2.1.3",
     "@hono/zod-openapi": "^1.6.3",
     "@modelcontextprotocol/sdk": "^1.31.0",
-    "@nylorun/core": "0.16.0-beta",
-    "@nylorun/harness": "0.23.1-beta",
+    "@nylorun/core": "0.17.0-beta",
+    "@nylorun/harness": "0.24.0-beta",
     "@restatedev/restate-sdk": "1.17.2",
     "@s2-dev/streamstore": "0.28.0",
     "aws4fetch": "1.0.20",

package/dist/vault/oauth.d.ts

@@ -1,55 +0,0 @@
-import type { AuthorizationServerMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
-import { HttpError } from "../tenant/http.js";
-export type TokenEndpointAuth = "none" | "client_secret_basic" | "client_secret_post";
-/** Where and how to sign in to an MCP server. */
-export interface OAuthServer {
-    readonly authorizationServerUrl: string;
-    readonly metadata: AuthorizationServerMetadata;
-    /** The protected resource's own `resource` (RFC 9728), sent as the RFC 8707 indicator. */
-    readonly resource?: string;
-    /** The scopes the protected resource names, space separated. */
-    readonly scope?: string;
-}
-/** The client this installation signs in as. */
-export interface OAuthClient {
-    readonly clientId: string;
-    readonly clientSecret?: string;
-    readonly tokenEndpointAuth: TokenEndpointAuth;
-}
-/** A failed step, as the Tenant API answers it: a refused address is the Host's rule (400). */
-export declare function oauthFailure(step: string, error: unknown): HttpError;
-/**
- * RFC 9728 protected resource metadata, then RFC 8414 (or OpenID) metadata of its first
- * authorization server. A server without the former is its own authorization server (the MCP
- * spec's fallback); a refused address is never a fallback.
- */
-export declare function discoverOAuthServer(url: string, fetchFn: typeof fetch): Promise<OAuthServer>;
-/**
- * The client to sign in as: the operator's `clientId` (a public client) when given, else one
- * registered now (RFC 7591) when the server offers registration, else `oauth_client_required`.
- */
-export declare function oauthClient(server: OAuthServer, options: {
-    clientId?: string;
-    redirectUri: string;
-    fetchFn: typeof fetch;
-}): Promise<OAuthClient>;
-/** The authorization URL, with a fresh S256 PKCE verifier. */
-export declare function authorizationUrl(server: OAuthServer, client: OAuthClient, options: {
-    redirectUri: string;
-    state: string;
-}): Promise<{
-    authorizeUrl: string;
-    codeVerifier: string;
-}>;
-/** Adds the client's authentication to a token request, as `tokenEndpointAuth` says. */
-export declare function addClientAuthentication(client: OAuthClient, headers: Headers, params: URLSearchParams): void;
-/** Exchanges the authorization code (with its PKCE verifier) for tokens. */
-export declare function exchangeCode(options: {
-    tokenEndpoint: string;
-    client: OAuthClient;
-    code: string;
-    codeVerifier: string;
-    redirectUri: string;
-    resource?: string;
-    fetchFn: typeof fetch;
-}): Promise<OAuthTokens>;

package/dist/vault/oauth.js

@@ -1,186 +0,0 @@
-/**
- * The network half of an MCP OAuth connect (F9 C2): discovery, dynamic client registration,
- * the authorization URL and the code exchange, with the MCP SDK's auth helpers over the fetch
- * it is given (the Host's `guardedFetch` in the gateway). `VaultService.startOAuth` and
- * `finishOAuth` call these outside any transaction and hold the secrets; nothing here stores
- * or logs one.
- */
-import { discoverAuthorizationServerMetadata, discoverOAuthProtectedResourceMetadata, exchangeAuthorization, registerClient, startAuthorization, } from "@modelcontextprotocol/sdk/client/auth.js";
-import { OAuthError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
-import { checkResourceAllowed } from "@modelcontextprotocol/sdk/shared/auth-utils.js";
-import { HttpError } from "../tenant/http.js";
-import { OutboundFailed, OutboundRefused } from "../tenant/outbound.js";
-/** A failed step, as the Tenant API answers it: a refused address is the Host's rule (400). */
-export function oauthFailure(step, error) {
-    if (error instanceof HttpError)
-        return error;
-    if (error instanceof OutboundRefused)
-        return new HttpError(400, `${error.message} (OAuth ${step})`, { code: "request_rejected" });
-    if (error instanceof OAuthError)
-        return new HttpError(502, `The authorization server refused the ${step} (${error.errorCode})`, {
-            code: "oauth_failed",
-        });
-    if (error instanceof OutboundFailed)
-        return new HttpError(502, `The OAuth ${step} failed: ${error.message}`, { code: "oauth_failed" });
-    return new HttpError(502, `The OAuth ${step} failed: the authorization server's answer was not usable`, {
-        code: "oauth_failed",
-    });
-}
-function httpUrl(value, what) {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        throw new HttpError(502, `The authorization server's ${what} is not a URL`, { code: "oauth_failed" });
-    }
-    if (url.protocol !== "https:" && url.protocol !== "http:")
-        throw new HttpError(502, `The authorization server's ${what} is not an http(s) URL`, {
-            code: "oauth_failed",
-        });
-    return url;
-}
-/**
- * RFC 9728 protected resource metadata, then RFC 8414 (or OpenID) metadata of its first
- * authorization server. A server without the former is its own authorization server (the MCP
- * spec's fallback); a refused address is never a fallback.
- */
-export async function discoverOAuthServer(url, fetchFn) {
-    let authorizationServerUrl;
-    let resource;
-    let scope;
-    try {
-        const protectedResource = await discoverOAuthProtectedResourceMetadata(url, {}, fetchFn);
-        authorizationServerUrl = protectedResource.authorization_servers?.[0];
-        if (protectedResource.resource) {
-            if (!checkResourceAllowed({ requestedResource: url, configuredResource: protectedResource.resource }))
-                throw new HttpError(502, `The MCP server's protected resource metadata names another resource (${protectedResource.resource})`, { code: "oauth_failed" });
-            resource = protectedResource.resource;
-        }
-        if (protectedResource.scopes_supported?.length)
-            scope = protectedResource.scopes_supported.join(" ");
-    }
-    catch (error) {
-        if (error instanceof OutboundRefused || error instanceof HttpError)
-            throw oauthFailure("discovery", error);
-        // No RFC 9728 metadata: the MCP server is its own authorization server.
-    }
-    authorizationServerUrl ??= new URL("/", url).href;
-    httpUrl(authorizationServerUrl, "address");
-    let metadata;
-    try {
-        metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
-    }
-    catch (error) {
-        throw oauthFailure("discovery", error);
-    }
-    if (!metadata)
-        throw new HttpError(502, `No OAuth authorization server metadata at ${new URL(authorizationServerUrl).origin}: the MCP server does not support OAuth sign-in`, { code: "oauth_failed" });
-    httpUrl(metadata.authorization_endpoint, "authorization endpoint");
-    httpUrl(metadata.token_endpoint, "token endpoint");
-    return {
-        authorizationServerUrl,
-        metadata,
-        ...(resource === undefined ? {} : { resource }),
-        ...(scope === undefined ? {} : { scope }),
-    };
-}
-function authMethodOf(value, secret) {
-    if (value === undefined)
-        return secret ? "client_secret_basic" : "none";
-    if (value === "none" || value === "client_secret_basic" || value === "client_secret_post") {
-        if (value !== "none" && !secret)
-            throw new HttpError(502, "The authorization server registered a confidential client without a secret", {
-                code: "oauth_failed",
-            });
-        return value;
-    }
-    throw new HttpError(502, `The authorization server's client authentication ${String(value)} is not supported`, {
-        code: "oauth_failed",
-    });
-}
-/**
- * The client to sign in as: the operator's `clientId` (a public client) when given, else one
- * registered now (RFC 7591) when the server offers registration, else `oauth_client_required`.
- */
-export async function oauthClient(server, options) {
-    if (options.clientId)
-        return { clientId: options.clientId, tokenEndpointAuth: "none" };
-    if (!server.metadata.registration_endpoint)
-        throw new HttpError(400, "The authorization server offers no dynamic client registration: register a client with it and pass its id (--client-id)", { code: "oauth_client_required" });
-    httpUrl(server.metadata.registration_endpoint, "registration endpoint");
-    try {
-        const registered = await registerClient(server.authorizationServerUrl, {
-            metadata: server.metadata,
-            clientMetadata: {
-                client_name: "Nylorun",
-                redirect_uris: [options.redirectUri],
-                grant_types: ["authorization_code", "refresh_token"],
-                response_types: ["code"],
-                token_endpoint_auth_method: "none",
-            },
-            ...(server.scope === undefined ? {} : { scope: server.scope }),
-            fetchFn: options.fetchFn,
-        });
-        return {
-            clientId: registered.client_id,
-            ...(registered.client_secret ? { clientSecret: registered.client_secret } : {}),
-            tokenEndpointAuth: authMethodOf(registered.token_endpoint_auth_method, registered.client_secret),
-        };
-    }
-    catch (error) {
-        throw oauthFailure("client registration", error);
-    }
-}
-/** The authorization URL, with a fresh S256 PKCE verifier. */
-export async function authorizationUrl(server, client, options) {
-    try {
-        const started = await startAuthorization(server.authorizationServerUrl, {
-            metadata: server.metadata,
-            clientInformation: { client_id: client.clientId },
-            redirectUrl: options.redirectUri,
-            state: options.state,
-            ...(server.scope === undefined ? {} : { scope: server.scope }),
-            ...(server.resource === undefined ? {} : { resource: server.resource }),
-        });
-        return { authorizeUrl: started.authorizationUrl.href, codeVerifier: started.codeVerifier };
-    }
-    catch (error) {
-        throw oauthFailure("authorization request", error);
-    }
-}
-/** Adds the client's authentication to a token request, as `tokenEndpointAuth` says. */
-export function addClientAuthentication(client, headers, params) {
-    if (client.tokenEndpointAuth === "client_secret_basic") {
-        const encoded = Buffer.from(`${encodeURIComponent(client.clientId)}:${encodeURIComponent(client.clientSecret ?? "")}`).toString("base64");
-        headers.set("authorization", `Basic ${encoded}`);
-        return;
-    }
-    params.set("client_id", client.clientId);
-    if (client.tokenEndpointAuth === "client_secret_post")
-        params.set("client_secret", client.clientSecret ?? "");
-}
-/** Exchanges the authorization code (with its PKCE verifier) for tokens. */
-export async function exchangeCode(options) {
-    const { client } = options;
-    const clientInformation = {
-        client_id: client.clientId,
-        ...(client.clientSecret ? { client_secret: client.clientSecret } : {}),
-    };
-    try {
-        return await exchangeAuthorization(options.tokenEndpoint, {
-            // Only the token endpoint is read from it.
-            metadata: { token_endpoint: options.tokenEndpoint },
-            clientInformation,
-            authorizationCode: options.code,
-            codeVerifier: options.codeVerifier,
-            redirectUri: options.redirectUri,
-            ...(options.resource === undefined ? {} : { resource: options.resource }),
-            addClientAuthentication: (headers, params) => addClientAuthentication(client, headers, params),
-            fetchFn: options.fetchFn,
-        });
-    }
-    catch (error) {
-        throw oauthFailure("code exchange", error);
-    }
-}