@adonis-agora/authkit-server 0.75.0 → 0.76.0

package/build/src/host/controllers/agent_consent_controller.d.ts

@@ -0,0 +1,17 @@
+import '../augmentations.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Tela de consentimento da delegação (PACT §5.3) — o `verification_uri` do
+ * device flow. Montada atrás do `accountGuard`: sem sessão o usuário passa pelo
+ * login DESTE app e volta com o `user_code` no `return_to`. O agente nunca vê
+ * esse login.
+ *
+ * Durante uma impersonation a tela recusa: um admin personificando alguém não
+ * pode entregar a conta dessa pessoa a um agente.
+ */
+export default class AgentConsentController {
+    /** GET {prefix}/consent?user_code=XXXX-XXXX */
+    show(ctx: HttpContext): Promise<any>;
+    /** POST {prefix}/consent — `decision=allow|deny`, `scope[]` marcados. */
+    decide(ctx: HttpContext): Promise<any>;
+}

package/build/src/host/controllers/agent_consent_controller.js

@@ -0,0 +1,138 @@
+import '../augmentations.js';
+import { displayNameFor } from '../../agents/agent_identity.js';
+import { personalAgentsFor } from '../../agents/runtime.js';
+import { ACCOUNT_SESSION_KEY } from '../account_session_key.js';
+import { impersonationState } from '../impersonation_session.js';
+async function agentName(runtime, issuer) {
+    const registration = await runtime.config.resolveAgent(issuer);
+    return displayNameFor(registration ?? { issuer, jwksUri: '' });
+}
+/** Host do issuer para exibição — um resolver do host pode devolver issuer que não é URL. */
+function originOf(issuer) {
+    try {
+        return new URL(issuer).host;
+    }
+    catch {
+        return issuer;
+    }
+}
+/**
+ * Anti-clickjacking: o atacante pega um código na própria sessão de agente e
+ * emoldura o link já preenchido — um clique em "Permitir" entregaria a conta.
+ * A tela nunca pode ser renderizada num frame, com ou sem o shield do host.
+ */
+function denyFraming(ctx) {
+    ctx.response.header('X-Frame-Options', 'DENY');
+    ctx.response.header('Content-Security-Policy', "frame-ancestors 'none'");
+}
+/**
+ * Tela de consentimento da delegação (PACT §5.3) — o `verification_uri` do
+ * device flow. Montada atrás do `accountGuard`: sem sessão o usuário passa pelo
+ * login DESTE app e volta com o `user_code` no `return_to`. O agente nunca vê
+ * esse login.
+ *
+ * Durante uma impersonation a tela recusa: um admin personificando alguém não
+ * pode entregar a conta dessa pessoa a um agente.
+ */
+export default class AgentConsentController {
+    /** GET {prefix}/consent?user_code=XXXX-XXXX */
+    async show(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        denyFraming(ctx);
+        const service = await ctx.containerResolver.make('authkit.server');
+        const render = service.config.render;
+        const base = {
+            csrfToken: ctx.request.csrfToken,
+            action: runtime.urls.consent,
+            request: null,
+            account: null,
+            error: null,
+        };
+        if (impersonationState(ctx).active) {
+            return render(ctx, 'agents/consent', { ...base, error: 'agents.consent.impersonating' });
+        }
+        const input = ctx.request.input('user_code');
+        if (!input)
+            return render(ctx, 'agents/consent', base);
+        const pending = await runtime.delegation.pendingRequest(input);
+        if (!pending) {
+            return render(ctx, 'agents/consent', { ...base, error: 'agents.consent.invalid_code' });
+        }
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const account = await service.config.accountStore.findById(accountId);
+        return render(ctx, 'agents/consent', {
+            ...base,
+            request: {
+                userCode: pending.userCode,
+                agentName: await agentName(runtime, pending.clientId),
+                agentOrigin: originOf(pending.clientId),
+                scopes: pending.scopes,
+            },
+            account: { email: account?.email ?? null },
+        });
+    }
+    /** POST {prefix}/consent — `decision=allow|deny`, `scope[]` marcados. */
+    async decide(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        denyFraming(ctx);
+        const service = await ctx.containerResolver.make('authkit.server');
+        const cfg = service.config;
+        const render = cfg.render;
+        if (impersonationState(ctx).active) {
+            return render(ctx, 'agents/consent', {
+                csrfToken: ctx.request.csrfToken,
+                action: runtime.urls.consent,
+                request: null,
+                account: null,
+                error: 'agents.consent.impersonating',
+            });
+        }
+        const accountId = ctx.session.get(ACCOUNT_SESSION_KEY);
+        const rawCode = ctx.request.input('user_code');
+        const userCode = typeof rawCode === 'string' ? rawCode : '';
+        const pending = await runtime.delegation.pendingRequest(userCode);
+        if (!pending) {
+            return render(ctx, 'agents/done', { status: 'expired', agentName: null, scopes: [] });
+        }
+        const name = await agentName(runtime, pending.clientId);
+        const raw = ctx.request.input('scope');
+        const chosen = (Array.isArray(raw) ? raw : raw ? [raw] : []).map(String);
+        const approved = ctx.request.input('decision') === 'allow'
+            ? await runtime.delegation.approve({ userCode, accountId, scopes: chosen })
+            : null;
+        if (!approved) {
+            // Negou ou desmarcou tudo. Se nem negar deu, o pedido mudou de estado no
+            // meio do caminho (aprovado em outra aba, expirou).
+            if (!(await runtime.delegation.deny({ userCode, accountId }))) {
+                return render(ctx, 'agents/done', { status: 'expired', agentName: name, scopes: [] });
+            }
+            await cfg.audit?.record({
+                type: 'agent.delegation_denied',
+                accountId,
+                clientId: pending.clientId,
+                ip: ctx.request.ip?.() ?? null,
+                metadata: { requested: pending.scopes.map((s) => s.id) },
+            });
+            return render(ctx, 'agents/done', { status: 'denied', agentName: name, scopes: [] });
+        }
+        await cfg.audit?.record({
+            type: 'agent.delegation_approved',
+            accountId,
+            clientId: pending.clientId,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: { grantId: approved.grantId, scopes: approved.scopes },
+        });
+        return render(ctx, 'agents/done', {
+            status: 'approved',
+            agentName: name,
+            scopes: approved.scopes.map((id) => ({
+                id,
+                description: runtime.delegation.scopes[id] ?? id,
+            })),
+        });
+    }
+}

package/build/src/host/controllers/agent_oauth_controller.d.ts

@@ -0,0 +1,23 @@
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * Authorization server de delegação para personal agents (PACT §5.3): metadata
+ * RFC 8414, JWKS e os endpoints RFC 8628 que o AGENTE chama. O cliente OAuth é
+ * o agente, autenticado pelo JWT dele em `Authorization: Bearer` em toda
+ * chamada — `client_id` tem de ser o `iss` desse JWT.
+ */
+export default class AgentOAuthController {
+    #private;
+    metadata(ctx: HttpContext): Promise<void | {
+        issuer: string;
+        device_authorization_endpoint: string;
+        token_endpoint: string;
+        jwks_uri: string;
+        scopes_supported: string[];
+        grant_types_supported: string[];
+        response_types_supported: never[];
+    }>;
+    /** Chaves que assinam tokens de delegação e recibos — as mesmas do IdP. */
+    jwks(ctx: HttpContext): Promise<any>;
+    deviceAuthorization(ctx: HttpContext): Promise<void>;
+    token(ctx: HttpContext): Promise<void>;
+}

package/build/src/host/controllers/agent_oauth_controller.js

@@ -0,0 +1,110 @@
+import { AgentOAuthError, DEVICE_CODE_GRANT_TYPE, REFRESH_TOKEN_GRANT_TYPE, } from '../../agents/delegation_service.js';
+import { personalAgentUnauthorized } from '../../agents/middleware.js';
+import { personalAgentsFor } from '../../agents/runtime.js';
+function noStore(ctx) {
+    ctx.response.header('Cache-Control', 'no-store');
+    ctx.response.header('Pragma', 'no-cache');
+}
+function oauthError(ctx, error) {
+    noStore(ctx);
+    return ctx.response
+        .status(error.status)
+        .json({ error: error.code, error_description: error.description });
+}
+/**
+ * Authorization server de delegação para personal agents (PACT §5.3): metadata
+ * RFC 8414, JWKS e os endpoints RFC 8628 que o AGENTE chama. O cliente OAuth é
+ * o agente, autenticado pelo JWT dele em `Authorization: Bearer` em toda
+ * chamada — `client_id` tem de ser o `iss` desse JWT.
+ */
+export default class AgentOAuthController {
+    async metadata(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        return {
+            issuer: runtime.urls.issuer,
+            device_authorization_endpoint: runtime.urls.deviceAuthorization,
+            token_endpoint: runtime.urls.token,
+            jwks_uri: runtime.urls.jwks,
+            scopes_supported: Object.keys(runtime.delegation.scopes),
+            grant_types_supported: [DEVICE_CODE_GRANT_TYPE, REFRESH_TOKEN_GRANT_TYPE],
+            response_types_supported: [],
+            // Sem `token_endpoint_auth_methods_supported`: o agente se autentica com o
+            // JWT dele em `Authorization: Bearer` (PACT §5.3), método sem nome
+            // registrado — anunciar `private_key_jwt` levaria um cliente genérico a
+            // mandar `client_assertion` e tomar 401.
+        };
+    }
+    /** Chaves que assinam tokens de delegação e recibos — as mesmas do IdP. */
+    async jwks(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation)
+            return ctx.response.notFound();
+        const service = await ctx.containerResolver.make('authkit.server');
+        ctx.response.header('Access-Control-Allow-Origin', '*');
+        ctx.response.header('Cache-Control', 'public, max-age=300');
+        return service.publicJwks;
+    }
+    async deviceAuthorization(ctx) {
+        const auth = await this.#authenticate(ctx);
+        if (!auth)
+            return;
+        try {
+            const body = await auth.runtime.delegation.requestDevice(auth.agent, ctx.request.input('scope'));
+            noStore(ctx);
+            return ctx.response.json(body);
+        }
+        catch (error) {
+            if (error instanceof AgentOAuthError)
+                return oauthError(ctx, error);
+            throw error;
+        }
+    }
+    async token(ctx) {
+        const auth = await this.#authenticate(ctx);
+        if (!auth)
+            return;
+        const delegation = auth.runtime.delegation;
+        try {
+            const grantType = ctx.request.input('grant_type');
+            const body = grantType === DEVICE_CODE_GRANT_TYPE
+                ? await delegation.exchangeDeviceCode(auth.agent, ctx.request.input('device_code'))
+                : grantType === REFRESH_TOKEN_GRANT_TYPE
+                    ? await delegation.refresh(auth.agent, ctx.request.input('refresh_token'))
+                    : null;
+            if (!body) {
+                throw new AgentOAuthError('unsupported_grant_type', 'Unsupported grant_type');
+            }
+            noStore(ctx);
+            return ctx.response.json(body);
+        }
+        catch (error) {
+            if (error instanceof AgentOAuthError)
+                return oauthError(ctx, error);
+            throw error;
+        }
+    }
+    /**
+     * JWT do agente + `client_id` coerente. Já respondeu (401/404) quando
+     * devolve `null`.
+     */
+    async #authenticate(ctx) {
+        const runtime = await personalAgentsFor(ctx);
+        if (!runtime?.delegation) {
+            ctx.response.notFound();
+            return null;
+        }
+        const agent = await runtime.verifier.verify(ctx.request.header('authorization'));
+        if (!agent) {
+            personalAgentUnauthorized(ctx, runtime.config.protocol);
+            return null;
+        }
+        if (ctx.request.input('client_id') !== agent.issuer) {
+            oauthError(ctx, new AgentOAuthError('invalid_client', 'client_id must equal the personal-agent issuer', 401));
+            return null;
+        }
+        return { runtime, agent };
+    }
+}

package/build/src/host/controllers/interaction_controller.js

@@ -180,6 +180,7 @@ export default class AuthInteractionController {
                 params: details.params,
                 csrfToken: ctx.request.csrfToken,
                 brand,
+                ...(await consentSubject(service, details, cfg.messages)),
             });
         }
         const email = ctx.session.get(SESSION_KEY);
@@ -1564,3 +1565,30 @@ export default class AuthInteractionController {
         }
     }
 }
+/**
+ * Quem pede o acesso e o quê, para a tela de consent: o nome que o client registrou (um cliente
+ * MCP registra o seu, ex.: "Claude Code") e os escopos pedidos, com o rótulo de cada um. O nome
+ * vem de fora (registro dinâmico aberto) — `clientNameHtml` sai escapado para o `{{{ }}}`.
+ */
+async function consentSubject(service, details, messages) {
+    const clientId = String(details.params?.client_id ?? '');
+    const client = clientId ? await service.provider.Client.find(clientId).catch(() => null) : null;
+    const clientName = client?.clientName || clientId;
+    const requested = String(details.params?.scope ?? '')
+        .split(' ')
+        .filter((scope) => scope !== '' && scope !== 'openid');
+    const scopes = requested.map((scope) => {
+        const key = `consent.scope.${scope}`;
+        const label = translate(messages, key);
+        return { id: scope, label: label === key ? scope : label };
+    });
+    return { clientName, clientNameHtml: escapeHtml(clientName), scopes };
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}

package/build/src/host/csrf.d.ts

@@ -1,29 +1,19 @@
-/**
- * Helper de exceções de CSRF para as rotas machine-to-machine do AuthKit.
- *
- * Os endpoints do IdP (token/introspection/PAT) e o back-channel logout são
- * server-to-server (sem browser/token XSRF). Em vez de cada app reescrever a
- * checagem de URL no `config/shield.ts`, use este helper:
- *
- * ```ts
- * // config/shield.ts
- * import { authkitCsrfExceptions } from '@adonis-agora/authkit-server'
- * csrf: {
- *   enabled: true,
- *   exceptRoutes: (ctx) => authkitCsrfExceptions(ctx.request.url(), { mountPath: '/oidc' })
- *     || ctx.request.url().includes('/api'),
- * }
- * ```
- */
 export interface AuthkitCsrfOptions {
     /** mountPath do IdP (mesmo de defineConfig/registerAuthHost). Default: `/oidc`. */
     mountPath?: string;
     /** Inclui a rota de back-channel logout do CLIENT (default: `/auth/backchannel-logout`). */
     backchannelLogoutPath?: string | false;
+    /**
+     * Prefixo de `personalAgents`: isenta os endpoints OAuth que os agentes chamam
+     * (`{prefix}/oauth/*`). Default: o prefixo do config quando `personalAgents`
+     * está ligado; nada quando não está. `false` desliga. A tela de
+     * consentimento (`{prefix}/consent`) continua protegida.
+     */
+    personalAgentsPrefix?: string | false;
 }
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
  * (machine-to-machine). Cobre o mountPath do IdP, a introspecção de PAT e a
- * rota de back-channel logout do client.
+ * rota de back-channel logout do client e os endpoints OAuth de personal agents.
  */
 export declare function authkitCsrfExceptions(url: string, options?: AuthkitCsrfOptions): boolean;

package/build/src/host/csrf.js

@@ -1,14 +1,40 @@
+/**
+ * Helper de exceções de CSRF para as rotas machine-to-machine do AuthKit.
+ *
+ * Os endpoints do IdP (token/introspection/PAT) e o back-channel logout são
+ * server-to-server (sem browser/token XSRF). Em vez de cada app reescrever a
+ * checagem de URL no `config/shield.ts`, use este helper:
+ *
+ * ```ts
+ * // config/shield.ts
+ * import { authkitCsrfExceptions } from '@adonis-agora/authkit-server'
+ * csrf: {
+ *   enabled: true,
+ *   exceptRoutes: (ctx) => authkitCsrfExceptions(ctx.request.url(), { mountPath: '/oidc' })
+ *     || ctx.request.url().includes('/api'),
+ * }
+ * ```
+ */
+import { normalizePersonalAgentsPrefix } from '../agents/config.js';
+import { getAuthHostConfig } from './auth_host_config.js';
 /**
  * Retorna `true` quando `url` é uma rota AuthKit que deve ser ISENTA de CSRF
  * (machine-to-machine). Cobre o mountPath do IdP, a introspecção de PAT e a
- * rota de back-channel logout do client.
+ * rota de back-channel logout do client e os endpoints OAuth de personal agents.
  */
 export function authkitCsrfExceptions(url, options = {}) {
     const mountPath = options.mountPath ?? '/oidc';
     const backchannel = options.backchannelLogoutPath === false
         ? null
         : (options.backchannelLogoutPath ?? '/auth/backchannel-logout');
+    const agentsPrefix = options.personalAgentsPrefix === false
+        ? undefined
+        : options.personalAgentsPrefix !== undefined
+            ? normalizePersonalAgentsPrefix(options.personalAgentsPrefix)
+            : getAuthHostConfig()?.personalAgents?.prefix;
+    const agentsOAuth = agentsPrefix ? `${agentsPrefix}/oauth/` : null;
     return (url.includes(mountPath) ||
         url.includes('/authkit/pat') ||
-        (backchannel !== null && url === backchannel));
+        (backchannel !== null && url === backchannel) ||
+        (agentsOAuth !== null && url.startsWith(agentsOAuth)));
 }

package/build/src/host/i18n.d.ts

@@ -97,6 +97,11 @@ export declare const DEFAULT_MESSAGES: {
     'consent.title': string;
     'consent.body': string;
     'consent.submit': string;
+    'consent.scopes_title': string;
+    'consent.scope.profile': string;
+    'consent.scope.email': string;
+    'consent.scope.offline_access': string;
+    'consent.scope.roles': string;
     'account.login.page_title': string;
     'account.login.title': string;
     'account.login.intro': string;
@@ -175,6 +180,28 @@ export declare const DEFAULT_MESSAGES: {
     'account.apps.revoke': string;
     'account.apps.revoke_confirm': string;
     'account.apps.revoked': string;
+    'account.apps.agents_title': string;
+    'account.apps.agents_intro': string;
+    'account.apps.agents_empty': string;
+    'agents.consent.page_title': string;
+    'agents.consent.title': string;
+    'agents.consent.body': string;
+    'agents.consent.signed_in_as': string;
+    'agents.consent.scopes_label': string;
+    'agents.consent.code': string;
+    'agents.consent.allow': string;
+    'agents.consent.deny': string;
+    'agents.consent.enter_code_title': string;
+    'agents.consent.enter_code_body': string;
+    'agents.consent.continue': string;
+    'agents.consent.invalid_code': string;
+    'agents.consent.impersonating': string;
+    'agents.done.approved_title': string;
+    'agents.done.denied_title': string;
+    'agents.done.return': string;
+    'agents.done.revoke_hint': string;
+    'agents.done.expired_title': string;
+    'agents.done.expired_body': string;
     'account.apps.not_supported': string;
     'account.orgs.page_title': string;
     'account.orgs.title': string;
@@ -820,6 +847,11 @@ export declare const PT_BR_MESSAGES: {
     'consent.title': string;
     'consent.body': string;
     'consent.submit': string;
+    'consent.scopes_title': string;
+    'consent.scope.profile': string;
+    'consent.scope.email': string;
+    'consent.scope.offline_access': string;
+    'consent.scope.roles': string;
     'account.login.page_title': string;
     'account.login.title': string;
     'account.login.intro': string;
@@ -898,6 +930,28 @@ export declare const PT_BR_MESSAGES: {
     'account.apps.revoke': string;
     'account.apps.revoke_confirm': string;
     'account.apps.revoked': string;
+    'account.apps.agents_title': string;
+    'account.apps.agents_intro': string;
+    'account.apps.agents_empty': string;
+    'agents.consent.page_title': string;
+    'agents.consent.title': string;
+    'agents.consent.body': string;
+    'agents.consent.signed_in_as': string;
+    'agents.consent.scopes_label': string;
+    'agents.consent.code': string;
+    'agents.consent.allow': string;
+    'agents.consent.deny': string;
+    'agents.consent.enter_code_title': string;
+    'agents.consent.enter_code_body': string;
+    'agents.consent.continue': string;
+    'agents.consent.invalid_code': string;
+    'agents.consent.impersonating': string;
+    'agents.done.approved_title': string;
+    'agents.done.denied_title': string;
+    'agents.done.return': string;
+    'agents.done.revoke_hint': string;
+    'agents.done.expired_title': string;
+    'agents.done.expired_body': string;
     'account.apps.not_supported': string;
     'account.orgs.page_title': string;
     'account.orgs.title': string;

package/build/src/host/i18n.js

@@ -97,6 +97,11 @@ export const DEFAULT_MESSAGES = {
     // raw na view). O nome vem do branding (config-trusted).
     'consent.body': 'The app <strong>{app}</strong> wants to access your account.',
     'consent.submit': 'Authorize',
+    'consent.scopes_title': 'It will be able to:',
+    'consent.scope.profile': 'See your name and photo',
+    'consent.scope.email': 'See your e-mail address',
+    'consent.scope.offline_access': 'Stay connected without asking you to sign in again',
+    'consent.scope.roles': 'See your roles and organization',
     // Console de conta — login (account/login).
     'account.login.page_title': 'My account',
     'account.login.title': 'My account',
@@ -183,6 +188,28 @@ export const DEFAULT_MESSAGES = {
     'account.apps.revoke': 'Revoke access',
     'account.apps.revoke_confirm': 'Revoke this app’s access? It will need to be authorized again and its tokens will stop working.',
     'account.apps.revoked': 'Access revoked.',
+    'account.apps.agents_title': 'Personal agents',
+    'account.apps.agents_intro': 'AI assistants you allowed to act on your account, and what each one can do.',
+    'account.apps.agents_empty': 'No personal agent can act on your account.',
+    'agents.consent.page_title': 'Authorize assistant',
+    'agents.consent.title': '{agent} wants to act on your account',
+    'agents.consent.body': 'The request came from {origin}. Choose what it can do — you can revoke access at any time.',
+    'agents.consent.signed_in_as': 'Signed in as {email}',
+    'agents.consent.scopes_label': 'Allow it to:',
+    'agents.consent.code': 'Request code: {code}. Make sure it matches the code your assistant shows.',
+    'agents.consent.allow': 'Allow',
+    'agents.consent.deny': 'Deny',
+    'agents.consent.enter_code_title': 'Connect an assistant',
+    'agents.consent.enter_code_body': 'Enter the code your assistant showed you.',
+    'agents.consent.continue': 'Continue',
+    'agents.consent.invalid_code': 'This code is invalid or expired. Ask your assistant for a new one.',
+    'agents.consent.impersonating': 'You cannot authorize an assistant while impersonating another account.',
+    'agents.done.approved_title': '{agent} can now:',
+    'agents.done.denied_title': 'Access denied',
+    'agents.done.return': 'You can close this page and return to your assistant.',
+    'agents.done.revoke_hint': 'To revoke this access later, go to the apps page of your account.',
+    'agents.done.expired_title': 'Request expired',
+    'agents.done.expired_body': 'This request is no longer valid. Ask your assistant to start again.',
     'account.apps.not_supported': 'The configured OIDC adapter does not support enumeration — listing apps is unavailable.',
     // Console de conta — organizations (account/orgs).
     'account.orgs.page_title': 'My Organizations',
@@ -908,6 +935,11 @@ export const PT_BR_MESSAGES = {
     'consent.title': 'Autorizar acesso',
     'consent.body': 'O app <strong>{app}</strong> quer acessar sua conta.',
     'consent.submit': 'Autorizar',
+    'consent.scopes_title': 'Ele vai poder:',
+    'consent.scope.profile': 'Ver seu nome e foto',
+    'consent.scope.email': 'Ver seu e-mail',
+    'consent.scope.offline_access': 'Continuar conectado sem pedir que você entre de novo',
+    'consent.scope.roles': 'Ver seus papéis e sua organização',
     // Console de conta — login (account/login).
     'account.login.page_title': 'Minha conta',
     'account.login.title': 'Minha conta',
@@ -994,6 +1026,28 @@ export const PT_BR_MESSAGES = {
     'account.apps.revoke': 'Revogar acesso',
     'account.apps.revoke_confirm': 'Revogar o acesso deste app? Ele precisará ser autorizado novamente e seus tokens deixarão de funcionar.',
     'account.apps.revoked': 'Acesso revogado.',
+    'account.apps.agents_title': 'Assistentes pessoais',
+    'account.apps.agents_intro': 'Assistentes de IA que você autorizou a agir na sua conta, e o que cada um pode fazer.',
+    'account.apps.agents_empty': 'Nenhum assistente pessoal pode agir na sua conta.',
+    'agents.consent.page_title': 'Autorizar assistente',
+    'agents.consent.title': '{agent} quer agir na sua conta',
+    'agents.consent.body': 'O pedido veio de {origin}. Escolha o que ele pode fazer — você pode revogar o acesso quando quiser.',
+    'agents.consent.signed_in_as': 'Conectado como {email}',
+    'agents.consent.scopes_label': 'Permitir que ele:',
+    'agents.consent.code': 'Código do pedido: {code}. Confira se é o mesmo que o seu assistente mostra.',
+    'agents.consent.allow': 'Permitir',
+    'agents.consent.deny': 'Negar',
+    'agents.consent.enter_code_title': 'Conectar um assistente',
+    'agents.consent.enter_code_body': 'Digite o código que o seu assistente mostrou.',
+    'agents.consent.continue': 'Continuar',
+    'agents.consent.invalid_code': 'Este código é inválido ou expirou. Peça um novo ao seu assistente.',
+    'agents.consent.impersonating': 'Não é possível autorizar um assistente enquanto você personifica outra conta.',
+    'agents.done.approved_title': '{agent} agora pode:',
+    'agents.done.denied_title': 'Acesso negado',
+    'agents.done.return': 'Você pode fechar esta página e voltar ao seu assistente.',
+    'agents.done.revoke_hint': 'Para revogar este acesso depois, vá à página de apps da sua conta.',
+    'agents.done.expired_title': 'Pedido expirado',
+    'agents.done.expired_body': 'Este pedido não vale mais. Peça ao seu assistente para começar de novo.',
     'account.apps.not_supported': 'O adapter OIDC configurado não suporta enumeração — a listagem de apps fica indisponível.',
     // Console de conta — organizations (account/orgs).
     'account.orgs.page_title': 'Minhas Organizações',

package/build/src/host/redirect_exact.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Redireciona para `url` EXATAMENTE como a lib a montou.
+ *
+ * O starter do AdonisJS liga `redirect.forwardQueryString: true` no `config/app.ts`: todo
+ * `response.redirect(url)` passa a colar a query da request ATUAL no fim — e numa URL que já tem a
+ * dela, sai um destino quebrado (`/login?return_to=%2Fx%3Fa%3D1?a=1`). O argumento
+ * `forwardQueryString = false` do `redirect()` não desliga o que veio do config; só o
+ * `clearQs()` do builder desliga. Toda URL que a lib monta já carrega a query que precisa.
+ *
+ * Fora de uma Response do AdonisJS (dublês de teste), cai no `redirect(url)` de sempre.
+ */
+export declare function redirectExact(response: any, url: string): unknown;

package/build/src/host/redirect_exact.js

@@ -0,0 +1,17 @@
+/**
+ * Redireciona para `url` EXATAMENTE como a lib a montou.
+ *
+ * O starter do AdonisJS liga `redirect.forwardQueryString: true` no `config/app.ts`: todo
+ * `response.redirect(url)` passa a colar a query da request ATUAL no fim — e numa URL que já tem a
+ * dela, sai um destino quebrado (`/login?return_to=%2Fx%3Fa%3D1?a=1`). O argumento
+ * `forwardQueryString = false` do `redirect()` não desliga o que veio do config; só o
+ * `clearQs()` do builder desliga. Toda URL que a lib monta já carrega a query que precisa.
+ *
+ * Fora de uma Response do AdonisJS (dublês de teste), cai no `redirect(url)` de sempre.
+ */
+export function redirectExact(response, url) {
+    if (typeof response?.getStatus === 'function') {
+        return response.redirect().clearQs().toPath(url);
+    }
+    return response.redirect(url);
+}