@frontmcp/sdk 1.3.0 → 1.4.0

package/auth/flows/oauth.auth-ui.flow.d.ts

@@ -0,0 +1,53 @@
+import { FlowBase, type FlowRunOptions } from '../../common';
+declare const extraInputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    request: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
+    response: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
+    next: import("@frontmcp/lazy-zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+}, import("zod/v4/core").$strip>;
+declare const extraStateSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    action: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    pendingAuthId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    csrf: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    payload: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>;
+declare const extraOutputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    kind: import("@frontmcp/lazy-zod").ZodLiteral<"json">;
+    status: import("@frontmcp/lazy-zod").ZodNumber;
+    body: import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>, import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodAny>, import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodAny>]>;
+    contentType: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodString>;
+    headers: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>]>]>>>>;
+    cookies: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        name: import("@frontmcp/lazy-zod").ZodString;
+        value: import("@frontmcp/lazy-zod").ZodString;
+        path: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodString>;
+        domain: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        httpOnly: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
+        sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
+            strict: "strict";
+            none: "none";
+            lax: "lax";
+        }>>;
+        maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
+        expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
+    }, import("zod/v4/core").$strip>>>>;
+}, import("zod/v4/core").$strip>;
+declare const extraPlan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["handleExtra"];
+};
+declare global {
+    interface ExtendFlows {
+        'oauth:auth-ui-extra': FlowRunOptions<OauthAuthUiExtraFlow, typeof extraPlan, typeof extraInputSchema, typeof extraOutputSchema, typeof extraStateSchema>;
+    }
+}
+declare const extraName: "oauth:auth-ui-extra";
+export default class OauthAuthUiExtraFlow extends FlowBase<typeof extraName> {
+    private logger;
+    parseInput(): Promise<void>;
+    handleExtra(): Promise<void>;
+    /** Verify the extra's CSRF token against the pending record + registry. */
+    private verifyExtraCsrf;
+}
+export {};
+//# sourceMappingURL=oauth.auth-ui.flow.d.ts.map

package/auth/flows/oauth.auth-ui.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.auth-ui.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.auth-ui.flow.ts"],"names":[],"mappings":"AAyBA,OAAO,EAEL,QAAQ,EAMR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAQtB,QAAA,MAAM,gBAAgB;;;;gCAAkB,CAAC;AACzC,QAAA,MAAM,gBAAgB;;;;;gCAKpB,CAAC;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;gCAAiB,CAAC;AAEzC,QAAA,MAAM,SAAS;;;CAGsB,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,qBAAqB,EAAE,cAAc,CACnC,oBAAoB,EACpB,OAAO,SAAS,EAChB,OAAO,gBAAgB,EACvB,OAAO,iBAAiB,EACxB,OAAO,gBAAgB,CACxB,CAAC;KACH;CACF;AAED,QAAA,MAAM,SAAS,EAAG,qBAA8B,CAAC;AAcjD,MAAM,CAAC,OAAO,OAAO,oBAAqB,SAAQ,QAAQ,CAAC,OAAO,SAAS,CAAC;IAC1E,OAAO,CAAC,MAAM,CAAmD;IAG3D,UAAU;IA6BV,WAAW;IA2BjB,2EAA2E;YAC7D,eAAe;CAkB9B"}

package/auth/flows/oauth.authorize.flow.d.ts

@@ -49,6 +49,7 @@ declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
     targetAppId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     targetToolId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     existingSessionId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    priorAuthorizedAppIds: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
     requiresFederatedLogin: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
     requiresConsent: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
     isCimdClient: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
@@ -93,8 +94,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -114,8 +115,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -133,8 +134,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -160,7 +161,47 @@ export default class OauthAuthorizeFlow extends FlowBase<typeof name> {
     checkIfAuthorized(): Promise<void>;
     prepareAuthorizationRequest(): Promise<void>;
     buildAuthorizeOutput(): Promise<void>;
+    /**
+     * Render a custom `@AuthUi` slot when one is registered for this scope.
+     *
+     * Mints the per-pending-auth CSRF token (server-owned), persists it onto the
+     * pending authorization record (so the callback can verify it across nodes),
+     * builds the {@link AuthFlowState} via `buildState`, SSRs the registered
+     * component, and responds with the assembled page + CSP / anti-clickjacking
+     * headers. Returns `true` when it handled the slot (caller should `return`),
+     * `false` to fall through to the built-in page (no renderer / build failed).
+     */
+    private tryRenderCustomSlot;
+    /**
+     * Remote mode (`mode: 'remote'`) auto-federation.
+     *
+     * Builds a federated auth session for the SINGLE mandatory upstream provider
+     * registered by {@link LocalPrimaryAuth.registerRemoteProvider}, starts it
+     * (fresh PKCE + state), persists the session, and redirects straight to the
+     * upstream IdP's authorization endpoint. This reuses the exact federated
+     * machinery the multi-provider local path uses (`/oauth/provider/:id/callback`
+     * then completes the exchange, stores upstream tokens, and mints the FrontMCP
+     * session token whose identity comes from the upstream user) — but skips the
+     * in-tree login page and the provider-selection page entirely.
+     *
+     * No identity is collected in-tree: the federated session is created with an
+     * EMPTY `userInfo` so the minted token's `sub`/`email`/`name` derive solely
+     * from the upstream provider (see the provider-callback flow).
+     */
+    private startRemoteFederation;
     validateOutput(): Promise<void>;
+    /**
+     * Enforce the local-AS DCR allowlists (#462) at authorize time. Returns a
+     * human-readable rejection reason, or `undefined` when the request is allowed
+     * (including when no allowlist is configured, or the auth instance does not
+     * expose a DCR registry — e.g. non-local modes).
+     *
+     * - `allowedRedirectUris`: applies to ALL clients (CIMD or not) as an
+     *   open-redirect / lateral-movement guard.
+     * - `allowedClientIds`: applies only to non-CIMD client ids; CIMD URLs are
+     *   validated by the CIMD layer instead.
+     */
+    private checkDcrAllowlist;
     /**
      * Format Zod errors into human-readable strings
      */
@@ -170,7 +211,13 @@ export default class OauthAuthorizeFlow extends FlowBase<typeof name> {
      */
     private respondWithError;
     /**
-     * Render a simple login page using HTMX templates
+     * Render the local login page.
+     *
+     * Honors `auth.login` (Checkpoint 3a): a `login.render` override yields full
+     * custom HTML, `login.fields` extends the built-in form, and otherwise the
+     * unchanged default email/name page is rendered. Rendering is delegated to
+     * the shared `renderLocalLoginPage` helper so the authorize flow and the
+     * callback error re-render stay in sync.
      */
     private renderLoginPage;
     /**
@@ -181,11 +228,6 @@ export default class OauthAuthorizeFlow extends FlowBase<typeof name> {
      * Render federated login page for multiple auth providers using HTMX templates
      */
     private renderFederatedLoginPage;
-    /**
-     * Render consent page for tool selection
-     * This is a placeholder - in production, use Juris/Svelte for the UI
-     */
-    private renderConsentPage;
     /**
      * Render an error page
      */

package/auth/flows/oauth.authorize.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.authorize.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.authorize.flow.ts"],"names":[],"mappings":"AA+BA,OAAO,EAAE,CAAC,EAAiB,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAGL,QAAQ,EAUR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AA6DtB;;GAEG;AACH,QAAA,MAAM,2BAA2B;;;;;;;;;gCAS/B,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,+BAA+B;;;gCAGnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAMxF,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAyBf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIhB,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAQ2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,iBAAiB,EAAE,cAAc,CAC/B,kBAAkB,EAClB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,iBAA0B,CAAC;AAcxC,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACnE,OAAO,CAAC,MAAM,CAAiD;IAGzD,UAAU;IAiEV,aAAa;IAqGb,iBAAiB;IAOjB,2BAA2B;IAmG3B,oBAAoB;IA0GpB,cAAc;IAIpB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAmBvB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyBjC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2BhC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAkRzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAyCxB"}
+{"version":3,"file":"oauth.authorize.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.authorize.flow.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,CAAC,EAAiB,MAAM,oBAAoB,CAAC;AAGtD,OAAO,EAGL,QAAQ,EAWR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAwEtB;;GAEG;AACH,QAAA,MAAM,2BAA2B;;;;;;;;;gCAS/B,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,+BAA+B;;;gCAGnC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAMxF,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAgCf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIhB,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAQ2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,iBAAiB,EAAE,cAAc,CAC/B,kBAAkB,EAClB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,iBAA0B,CAAC;AAkCxC,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACnE,OAAO,CAAC,MAAM,CAAiD;IAGzD,UAAU;IAmFV,aAAa;IAuHb,iBAAiB;IAOjB,2BAA2B;IAoH3B,oBAAoB;IAiL1B;;;;;;;;;OASG;YACW,mBAAmB;IA4CjC;;;;;;;;;;;;;;;OAeG;YACW,qBAAqB;IAsE7B,cAAc;IAIpB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAuBxB;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IA+BvB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAyBjC;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2BhC;;OAEG;IACH,OAAO,CAAC,eAAe;CAyCxB"}

package/auth/flows/oauth.callback.flow.d.ts

@@ -29,16 +29,27 @@ declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
     resource: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     authorizationCode: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     userSub: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    loginFields: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodString>>;
+    customClaims: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>>;
+    credentials: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        key: import("@frontmcp/lazy-zod").ZodString;
+        secret: import("@frontmcp/lazy-zod").ZodString;
+        metadata: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnknown>>;
+    }, import("zod/v4/core").$strip>>>;
     isIncremental: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
     targetAppId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     targetToolId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     existingSessionId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     existingAuthorizationId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    priorAuthorizedAppIds: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
+    authorizedAppIds: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
     isFederated: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
     selectedProviders: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
     skippedProviders: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
     consentEnabled: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
     selectedTools: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
+    consentSubmitted: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    csrf: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
 }, import("zod/v4/core").$strip>;
 declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodObject<{
     kind: import("@frontmcp/lazy-zod").ZodLiteral<"redirect">;
@@ -54,8 +65,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -73,8 +84,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -97,9 +108,33 @@ export default class OauthCallbackFlow extends FlowBase<typeof name> {
     parseInput(): Promise<void>;
     validatePendingAuth(): Promise<void>;
     /**
-     * Handle incremental authorization - expand existing session's token vault
-     * For incremental auth, we add the app to the existing authorization without
-     * requiring full re-authentication
+     * Compute the progressive/incremental authorization grant for the minted
+     * token (the `authorized_apps` claim).
+     *
+     * EXPANSION model (claim-based, enforceable — mirrors how consent/federated
+     * grants already work in this codebase): the authorized-app set lives in the
+     * minted token's `authorized_apps` claim, which `checkToolAuthorization`
+     * enforces. Both the initial login and an incremental authorize mint a token
+     * via the normal code exchange; the difference is the computed grant:
+     *
+     *  - INITIAL login: grant = the apps the client requested via `apps=`
+     *    (`priorAuthorizedAppIds`); if none requested, grant ALL scope apps (a
+     *    plain login keeps working for everything).
+     *  - INCREMENTAL authorize (`mode=incremental&app=B`): grant = the prior apps
+     *    (carried forward via `apps=`) UNION the newly-authorized `targetAppId`.
+     *    So after authorizing app B, a `tools/call` on B's tool succeeds while app
+     *    A keeps working — WITHOUT re-authorizing A.
+     *
+     * This stage ONLY emits a grant when `incrementalAuth.enabled` is true for an
+     * orchestrated scope. When incremental auth is disabled or the scope is not
+     * orchestrated, it leaves `authorizedAppIds` undefined → NO `authorized_apps`
+     * claim is minted → NO app-level gating (the historical allow-all behavior is
+     * preserved exactly). Federated logins mint their token in the provider
+     * callback flow, so this stage is a no-op for them.
+     *
+     * Unknown app ids (not present in the scope) are dropped so a client can never
+     * forge a grant to a non-existent app; app-level gating is per-real-app, so a
+     * bogus id is harmless anyway.
      */
     handleIncrementalAuth(): Promise<void>;
     /**
@@ -112,6 +147,84 @@ export default class OauthCallbackFlow extends FlowBase<typeof name> {
     handleFederatedAuth(): Promise<void>;
     createAuthorizationCode(): Promise<void>;
     redirectToClient(): Promise<void>;
+    /**
+     * Reserved OAuth/flow control params that must never be treated as custom
+     * login fields when collecting input for a custom `authenticate` verifier.
+     */
+    private static readonly RESERVED_LOGIN_PARAMS;
+    /**
+     * Collect submitted login-field values (built-in `email`/`name` plus any
+     * custom `login.fields`) from the GET query and a urlencoded POST body.
+     * Reserved OAuth/flow control params are excluded so they cannot be forwarded
+     * to the verifier as if they were login fields. Only string values are kept.
+     */
+    /**
+     * Defensively read a single param from a urlencoded POST body (some adapters
+     * parse the body into `request.body`). The consent form uses a GET round-trip
+     * (mirroring the federated page) so query params are the primary source; this
+     * is a fallback for adapters that route a POST body instead. Multi-valued
+     * keys keep all values so checkbox groups (`tools`) survive a POST.
+     */
+    private readBodyParam;
+    private collectLoginFields;
+    /**
+     * Build the {@link AuthenticateContext} from the flow scope and invoke the
+     * configured verifier. Verifier exceptions are caught and converted to a
+     * generic failure so a throwing verifier never produces a 500.
+     */
+    private runAuthenticate;
+    /**
+     * Outbound fetch handed to the verifier. Routes through the auth instance's
+     * `fetch` when available (so tests / adapters can intercept it), else the
+     * global fetch.
+     */
+    private contextFetch;
+    /**
+     * Resolve a human-readable client name for the verifier context. Uses the
+     * CIMD `client_name` when the client_id is a CIMD URL and resolvable; falls
+     * back to the raw client_id.
+     */
+    private resolveClientName;
+    /**
+     * Derive a subject from the configured login subject strategy.
+     *
+     * - `per-account`: hash the value of `login.subject.fromField` into a stable
+     *   subject (same account → same `sub`).
+     * - otherwise (`per-session` / unset): return undefined so the caller falls
+     *   back to the anonymous subject.
+     */
+    private deriveSubjectFromStrategy;
+    /**
+     * Re-render the local login page after a failed authenticate(), surfacing the
+     * verifier's message (and pre-selecting `retryField`). Submitted values are
+     * preserved on the form so the user does not have to re-enter everything.
+     */
+    private renderLoginRetryPage;
+    /**
+     * Render a custom `@AuthUi({ slot: 'consent' })` page when one is registered.
+     *
+     * Mints + persists the per-pending-auth CSRF token (reusing any token a prior
+     * custom page already set on the record, so a consent re-render keeps the same
+     * token), builds the consent {@link AuthFlowState} from the SAME tool
+     * projection the built-in screen uses, SSRs the component, and responds with
+     * the assembled page + CSP headers. Returns `true` when handled.
+     */
+    private tryRenderCustomConsent;
+    /**
+     * Render the tool-consent screen.
+     *
+     * The form GETs back to `/oauth/callback` carrying `pending_auth_id`,
+     * `consent_submitted=1`, the resolved identity (`email`/`name` + any custom
+     * `login.fields`), and the chosen `tools=` checkboxes — so the resubmit
+     * re-derives the SAME subject and proceeds to mint.
+     *
+     * Honors the `auth.consent` flags: `groupByApp`, `showDescriptions`,
+     * `customMessage`, `allowSelectAll`, `requireSelection`, `defaultSelectedTools`
+     * (pre-checked), and `excludedTools` (filtered out of the offered set by
+     * {@link projectConsentTools}). `error` re-renders the screen with a banner
+     * (used for an empty `requireSelection` submit).
+     */
+    private renderConsentScreen;
     /**
      * Generate a stable user sub from email
      * In production, this would be the user's ID from the database

package/auth/flows/oauth.callback.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.callback.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.callback.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AAGvC,OAAO,EAEL,QAAQ,EAOR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAGtB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;gCA4Bf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAgD,CAAC;AAEnE,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,gBAAgB,EAAE,cAAc,CAC9B,iBAAiB,EACjB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,gBAAyB,CAAC;AAcvC,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAClE,OAAO,CAAC,MAAM,CAAgD;IAGxD,UAAU;IAsDV,mBAAmB;IAqHzB;;;;OAIG;IAEG,qBAAqB;IAyB3B;;;;;;OAMG;IAEG,mBAAmB;IAiInB,uBAAuB;IAmEvB,gBAAgB;IAqCtB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,eAAe;CAqDxB"}
+{"version":3,"file":"oauth.callback.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.callback.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAgBH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AAGvC,OAAO,EAEL,QAAQ,EAQR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAKtB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA2Df,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAgD,CAAC;AAEnE,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,gBAAgB,EAAE,cAAc,CAC9B,iBAAiB,EACjB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,gBAAyB,CAAC;AAcvC,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAClE,OAAO,CAAC,MAAM,CAAgD;IAGxD,UAAU;IA6EV,mBAAmB;IAoXzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEG,qBAAqB;IA2D3B;;;;;;OAMG;IAEG,mBAAmB;IAiInB,uBAAuB;IA2GvB,gBAAgB;IAyCtB;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAoB1C;IAEH;;;;;OAKG;IACH;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,kBAAkB;IAsB1B;;;;OAIG;YACW,eAAe;IAgC7B;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAQpB;;;;OAIG;YACW,iBAAiB;IAoB/B;;;;;;;OAOG;IACH,OAAO,CAAC,yBAAyB;IAYjC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAmB5B;;;;;;;;OAQG;YACW,sBAAsB;IA0EpC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,mBAAmB;IA8D3B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,eAAe;CAqDxB"}

package/auth/flows/oauth.connect.flow.d.ts

@@ -0,0 +1,89 @@
+/**
+ * OAuth Connect Endpoint — GET|POST /oauth/connect (Checkpoint 3b)
+ *
+ * Mid-session add-credential flow reached via a FRAMEWORK-SIGNED resume URL that
+ * `this.credentials.requireConnect({ key })` hands back when a credential is not
+ * connected.
+ *
+ *   - GET  /oauth/connect?token=…  → verify the signed token, render a single
+ *     add-credential field (reusing the 3a `login.fields` render surface).
+ *   - POST /oauth/connect          → re-verify the token, re-invoke the
+ *     configured `authenticate({ fields, resume: { sub, key, context } })`
+ *     verifier, and ADDITIVELY store the returned credential into the user's
+ *     EXISTING vault. Refuses when there is no live vault (never mints a new one)
+ *     so a stale link cannot resurrect a rotated-away session.
+ *
+ * This is auth-internal: it lives on the existing OAuth flow surface (registered
+ * by LocalPrimaryAuth), not via the public custom-route feature.
+ */
+import { FlowBase, type FlowRunOptions } from '../../common';
+declare const inputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    request: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
+    response: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
+    next: import("@frontmcp/lazy-zod").ZodOptional<import("zod").ZodFunction<import("zod/v4/core").$ZodFunctionArgs, import("zod/v4/core").$ZodFunctionOut>>;
+}, import("zod/v4/core").$strip>;
+declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    method: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    token: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    fields: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodString>>;
+}, import("zod/v4/core").$strip>;
+declare const outputSchema: import("@frontmcp/lazy-zod").ZodObject<{
+    status: import("@frontmcp/lazy-zod").ZodNumber;
+    body: import("@frontmcp/lazy-zod").ZodString;
+    headers: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodRecord<import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodString, import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>]>]>>>>;
+    cookies: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodObject<{
+        name: import("@frontmcp/lazy-zod").ZodString;
+        value: import("@frontmcp/lazy-zod").ZodString;
+        path: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodString>;
+        domain: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+        httpOnly: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+        secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
+        sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
+            strict: "strict";
+            none: "none";
+            lax: "lax";
+        }>>;
+        maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
+        expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
+    }, import("zod/v4/core").$strip>>>>;
+    kind: import("@frontmcp/lazy-zod").ZodLiteral<"html">;
+    contentType: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodLiteral<"text/html; charset=utf-8">>;
+}, import("zod/v4/core").$strip>;
+declare const plan: {
+    readonly pre: ["parseInput"];
+    readonly execute: ["handleConnect"];
+};
+declare global {
+    interface ExtendFlows {
+        'oauth:connect': FlowRunOptions<OauthConnectFlow, typeof plan, typeof inputSchema, typeof outputSchema, typeof stateSchema>;
+    }
+}
+declare const name: "oauth:connect";
+export default class OauthConnectFlow extends FlowBase<typeof name> {
+    private logger;
+    parseInput(): Promise<void>;
+    handleConnect(): Promise<void>;
+    /** Verify the signed resume token against the server secret (constant-time + expiry). */
+    private verifyToken;
+    /** Resolve the single credential field to render from `login.fields` (first field), or a default. */
+    private resolveConnectField;
+    /** Render the single-field connect page (reusing the login field renderer). */
+    private renderConnectPage;
+    /**
+     * Build the {@link AuthenticateContext} and invoke the verifier with the resume
+     * context. A throwing verifier is converted into a clean failure.
+     */
+    private runAuthenticate;
+    /** Outbound fetch handed to the verifier (routes through the auth instance when available). */
+    private contextFetch;
+    /** Fire a `notifications/resources/updated` to connected sessions (best-effort). */
+    private notifyResourcesUpdated;
+    /** Parse a urlencoded/JSON POST body into a flat record. */
+    private coerceBody;
+    /** Collect submitted credential field values from query + body (excluding reserved params). */
+    private collectFields;
+    /** Render a small error page (escaped). */
+    private renderError;
+}
+export {};
+//# sourceMappingURL=oauth.connect.flow.d.ts.map

package/auth/flows/oauth.connect.flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.connect.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.connect.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAgBH,OAAO,EAEL,QAAQ,EAMR,KAAK,cAAc,EAEpB,MAAM,cAAc,CAAC;AAGtB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;gCAOf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;gCAAiB,CAAC;AAEpC,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,eAAe,EAAE,cAAc,CAC7B,gBAAgB,EAChB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,eAAwB,CAAC;AAiBtC,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IACjE,OAAO,CAAC,MAAM,CAA+C;IAGvD,UAAU;IAeV,aAAa;IAwHnB,yFAAyF;IACzF,OAAO,CAAC,WAAW;IAKnB,qGAAqG;IACrG,OAAO,CAAC,mBAAmB;IAW3B,+EAA+E;IAC/E,OAAO,CAAC,iBAAiB;IAoBzB;;;OAGG;YACW,eAAe;IA4B7B,+FAA+F;IAC/F,OAAO,CAAC,YAAY;IAQpB,oFAAoF;IACpF,OAAO,CAAC,sBAAsB;IAiB9B,4DAA4D;IAC5D,OAAO,CAAC,UAAU;IAyBlB,+FAA+F;IAC/F,OAAO,CAAC,aAAa;IAerB,2CAA2C;IAC3C,OAAO,CAAC,WAAW;CAQpB"}

package/auth/flows/oauth.provider-callback.flow.d.ts

@@ -34,6 +34,9 @@ declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
     federatedSession: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnknown>;
     providerTokens: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnknown>;
     providerUserInfo: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodUnknown>;
+    consentSessionId: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
+    consentSubmitted: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodBoolean>;
+    selectedTools: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodArray<import("@frontmcp/lazy-zod").ZodString>>;
 }, import("zod/v4/core").$strip>;
 declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [import("@frontmcp/lazy-zod").ZodObject<{
     kind: import("@frontmcp/lazy-zod").ZodLiteral<"redirect">;
@@ -49,8 +52,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -68,8 +71,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -78,7 +81,7 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodUnion<readonly [impo
     contentType: import("@frontmcp/lazy-zod").ZodDefault<import("@frontmcp/lazy-zod").ZodLiteral<"text/html; charset=utf-8">>;
 }, import("zod/v4/core").$strip>]>;
 declare const plan: {
-    readonly pre: ["parseInput", "loadFederatedSession", "validateProviderCallback"];
+    readonly pre: ["parseInput", "handleConsentSubmission", "loadFederatedSession", "validateProviderCallback"];
     readonly execute: ["exchangeProviderCode", "storeProviderTokens", "handleNextProviderOrComplete"];
 };
 declare global {
@@ -95,15 +98,42 @@ export default class OauthProviderCallbackFlow extends FlowBase<typeof name> {
      */
     private getLocalAuth;
     parseInput(): Promise<void>;
+    /**
+     * Handle a consent-screen submission for a federated login.
+     *
+     * Federated logins complete (mint the code) here, AFTER all providers are
+     * linked. When consent mode is enabled, {@link completeFederatedAuth} first
+     * renders the consent screen, which GETs back to this endpoint with
+     * `consent_session=<sessionId>` + `tools=`. This stage loads that still alive
+     * session, applies the selection (validating + `requireSelection`), and
+     * completes the mint — short-circuiting the provider-code path entirely.
+     */
+    handleConsentSubmission(): Promise<void>;
     loadFederatedSession(): Promise<void>;
     validateProviderCallback(): Promise<void>;
     exchangeProviderCode(): Promise<void>;
     storeProviderTokens(): Promise<void>;
     handleNextProviderOrComplete(): Promise<void>;
     /**
-     * Complete the federated auth flow and issue FrontMCP JWT
+     * Complete the federated auth flow and issue FrontMCP JWT.
+     *
+     * When consent mode is enabled this runs in two passes:
+     *  1. First reach (no `consent.consentSubmitted`): render the consent screen,
+     *     which GETs back to this endpoint with `consent_session` + `tools=`. The
+     *     federated session is kept ALIVE for the round-trip.
+     *  2. Resubmit (`consent.consentSubmitted` true): validate the selection
+     *     (honoring `requireSelection`) and mint the code with the consented set.
+     *
+     * With consent disabled, it mints immediately (historical behavior).
      */
     private completeFederatedAuth;
+    /**
+     * Render the federated consent screen. The form GETs back to this provider
+     * callback endpoint with `consent_session=<sessionId>` + the chosen `tools=`
+     * (and `consent_submitted=1`), so {@link handleConsentSubmission} completes
+     * the mint. Honors the same `auth.consent` flags as the non-federated path.
+     */
+    private renderConsentScreen;
     /**
      * Generate a deterministic user sub from email
      */

package/auth/flows/oauth.provider-callback.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.provider-callback.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.provider-callback.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAaH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AAGvC,OAAO,EAEL,QAAQ,EAQR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAItB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;gCAcf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAgD,CAAC;AAEnE,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,yBAAyB,EAAE,cAAc,CACvC,yBAAyB,EACzB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,yBAAkC,CAAC;AAchD,MAAM,CAAC,OAAO,OAAO,yBAA0B,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC1E,OAAO,CAAC,MAAM,CAAwD;IAEtE;;;OAGG;IACH,OAAO,CAAC,YAAY;IASd,UAAU;IA0BV,oBAAoB;IAkEpB,wBAAwB;IAmDxB,oBAAoB;IA0EpB,mBAAmB;IAkDnB,4BAA4B;IAkElC;;OAEG;YACW,qBAAqB;IA8CnC;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqDvB,OAAO,CAAC,kBAAkB;CAO3B"}
+{"version":3,"file":"oauth.provider-callback.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.provider-callback.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAeH,OAAO,EAAE,CAAC,EAAE,MAAM,oBAAoB,CAAC;AAGvC,OAAO,EAEL,QAAQ,EAQR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAKtB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AAEpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;gCAmBf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAgD,CAAC;AAEnE,QAAA,MAAM,IAAI;;;CAG2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,yBAAyB,EAAE,cAAc,CACvC,yBAAyB,EACzB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,yBAAkC,CAAC;AAchD,MAAM,CAAC,OAAO,OAAO,yBAA0B,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAC1E,OAAO,CAAC,MAAM,CAAwD;IAEtE;;;OAGG;IACH,OAAO,CAAC,YAAY;IASd,UAAU;IAoChB;;;;;;;;;OASG;IAEG,uBAAuB;IAyCvB,oBAAoB;IAkEpB,wBAAwB;IAmDxB,oBAAoB;IA0EpB,mBAAmB;IAoEnB,4BAA4B;IAkElC;;;;;;;;;;;OAWG;YACW,qBAAqB;IAkKnC;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAsC3B;;OAEG;IACH,OAAO,CAAC,eAAe;IAQvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqDvB,OAAO,CAAC,kBAAkB;CAO3B"}

package/auth/flows/oauth.register.flow.d.ts

@@ -4,26 +4,20 @@
  * Who calls: Developers/automation.
  *
  * Purpose: Let clients register programmatically (redirect URIs, grant types, etc.).
+ *
+ * Control surface (#462): the LOCAL Authorization Server's DCR is governed by
+ * the declarative `auth.dcr` block. When `dcr` is omitted the historical
+ * behavior is preserved exactly — registration is enabled in development and
+ * disabled in production (via `isProduction()`), with no allowlist and no
+ * initial access token. When configured, this flow enforces:
+ *   - `dcr.enabled === false` → 404 (behave as if the endpoint does not exist)
+ *   - `dcr.initialAccessToken` → require `Authorization: Bearer <token>` (401)
+ *   - `dcr.allowedClientIds` → registrations are pinned to an allowed id (400)
+ *   - `dcr.allowedRedirectUris` → reject unlisted redirect_uris (400)
+ * Registered clients are stored on the per-instance {@link DcrClientRegistry}
+ * (LocalPrimaryAuth), so the authorize/token flows can validate them.
  */
 import { FlowBase, type FlowRunOptions } from '../../common';
-/** Simple in-memory registry (dev only) */
-type RegisteredClient = {
-    client_id: string;
-    client_secret?: string;
-    token_endpoint_auth_method: 'none' | 'client_secret_basic' | 'client_secret_post' | 'private_key_jwt' | 'tls_client_auth';
-    grant_types: string[];
-    response_types: string[];
-    redirect_uris: string[];
-    client_name?: string;
-    scope?: string;
-    created_at: number;
-    dev: boolean;
-};
-/** Optional: export getters so other flows can validate client_id */
-export declare const DevClientRegistry: {
-    get(client_id: string): RegisteredClient | undefined;
-    has(client_id: string): boolean;
-};
 declare const inputSchema: import("@frontmcp/lazy-zod").ZodObject<{
     request: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
     response: import("@frontmcp/lazy-zod").ZodObject<{}, import("zod/v4/core").$loose>;
@@ -44,8 +38,8 @@ declare const outputSchema: import("@frontmcp/lazy-zod").ZodObject<{
         secure: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodBoolean>;
         sameSite: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodEnum<{
             strict: "strict";
-            lax: "lax";
             none: "none";
+            lax: "lax";
         }>>;
         maxAge: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodNumber>;
         expires: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodDate>;
@@ -72,7 +66,7 @@ declare const stateSchema: import("@frontmcp/lazy-zod").ZodObject<{
         client_name: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
         scope: import("@frontmcp/lazy-zod").ZodOptional<import("@frontmcp/lazy-zod").ZodString>;
     }, import("zod/v4/core").$loose>;
-    isDev: import("@frontmcp/lazy-zod").ZodBoolean;
+    dcrEnabled: import("@frontmcp/lazy-zod").ZodBoolean;
 }, import("zod/v4/core").$strip>;
 declare const plan: {
     readonly pre: ["parseInput", "validateInput"];
@@ -87,6 +81,8 @@ declare global {
 declare const name: "oauth:register";
 export default class OauthRegisterFlow extends FlowBase<typeof name> {
     private registered?;
+    /** The local AS primary auth, which owns the DCR client registry (#462). */
+    private get localAuth();
     parseInput(): Promise<void>;
     validateInput(): Promise<void>;
     registerClient(): Promise<void>;

package/auth/flows/oauth.register.flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.register.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.register.flow.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAkBH,OAAO,EAEL,QAAQ,EAMR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,2CAA2C;AAC3C,KAAK,gBAAgB,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0BAA0B,EACtB,MAAM,GACN,qBAAqB,GACrB,oBAAoB,GACpB,iBAAiB,GACjB,iBAAiB,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,OAAO,CAAC;CACd,CAAC;AAIF,qEAAqE;AACrE,eAAO,MAAM,iBAAiB;mBACb,MAAM;mBAGN,MAAM;CAGtB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AACpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;gCAAiB,CAAC;AAkBpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;gCAGf,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAI2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,gBAAgB,EAAE,cAAc,CAC9B,iBAAiB,EACjB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,gBAAyB,CAAC;AAcvC,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAClE,OAAO,CAAC,UAAU,CAAC,CAAmB;IAGhC,UAAU;IAaV,aAAa;IAwEb,cAAc;IA6Bd,mBAAmB;IAqBnB,cAAc;CAGrB"}
+{"version":3,"file":"oauth.register.flow.d.ts","sourceRoot":"","sources":["../../../src/auth/flows/oauth.register.flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAmBH,OAAO,EAEL,QAAQ,EAMR,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAGtB,QAAA,MAAM,WAAW;;;;gCAAkB,CAAC;AACpC,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;gCAAiB,CAAC;AAkBpC,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;gCAIf,CAAC;AAEH,QAAA,MAAM,IAAI;;;;CAI2B,CAAC;AAEtC,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,WAAW;QACnB,gBAAgB,EAAE,cAAc,CAC9B,iBAAiB,EACjB,OAAO,IAAI,EACX,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,OAAO,WAAW,CACnB,CAAC;KACH;CACF;AAED,QAAA,MAAM,IAAI,EAAG,gBAAyB,CAAC;AAsBvC,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,QAAQ,CAAC,OAAO,IAAI,CAAC;IAClE,OAAO,CAAC,UAAU,CAAC,CAAmB;IAEtC,4EAA4E;IAC5E,OAAO,KAAK,SAAS,GAEpB;IAGK,UAAU;IAeV,aAAa;IAyIb,cAAc;IA6Bd,mBAAmB;IA8BnB,cAAc;CAGrB"}