@adonis-agora/authkit-server 1.0.0-rc.1 → 1.0.0-rc.3

package/build/src/agents/runtime.js

@@ -1,13 +1,9 @@
+import { getBootedApp } from '../../services/booted_app.js';
 import { supportsAccountStatus } from '../accounts/account_store.js';
 import { findMcpResource } from '../mcp/mcp_oauth.js';
 import { PersonalAgentVerifier } from './agent_identity.js';
 import { PersonalAgentDelegation } from './delegation_service.js';
 import { DelegationStore } from './delegation_store.js';
-import { PoppyClientRegistry } from './poppy/client_registry.js';
-import { hmacNonceSource } from './poppy/dpop.js';
-import { databaseReplayStore, memoryLimiter, memoryReplayStore, redisReplayStore, } from './poppy/replay.js';
-import { PoppyService, poppyUrls } from './poppy/service.js';
-import { PoppyStore } from './poppy/store.js';
 import { AgentRegistryStore } from './registry_store.js';
 import { keystoreSigner } from './signer.js';
 /**
@@ -27,9 +23,10 @@ export function personalAgentUrls(oidcIssuer, prefix) {
     };
 }
 const runtimes = new WeakMap();
-/** Ponte Poppy → oidc-provider: Bearer de MCP de Sessions logadas viram access tokens dele. */
-function mcpBridge(service, poppyApis) {
+/** Access tokens do oidc-provider para resources MCP (ver {@link PersonalAgentAccessTokens}). */
+function accessTokens(service) {
     return {
+        mcpEnabled: !!service.config.mcp?.enabled,
         isMcpResource(url) {
             try {
                 return findMcpResource(url, service.config.issuer, service.config.mcp) !== null;
@@ -42,11 +39,6 @@ function mcpBridge(service, poppyApis) {
             const provider = service.provider;
             if (!provider?.AccessToken || !provider?.Grant)
                 return null;
-            // Só faz sentido quando a integração MCP do authkit está ligada, ou o MCP é de `apis`.
-            if (!service.config.mcp?.enabled &&
-                !poppyApis.some((a) => a.type === 'mcp' && a.url.replace(/\/+$/, '') === input.resource.replace(/\/+$/, ''))) {
-                return null;
-            }
             const remaining = Math.max(60, Math.floor((input.grantExpiresAt.getTime() - Date.now()) / 1000));
             let grant = await provider.Grant.find(input.grantId);
             if (!grant) {
@@ -63,13 +55,13 @@ function mcpBridge(service, poppyApis) {
                 clientId: input.clientId,
                 grantId: input.grantId,
                 scope: input.scope,
-                gty: 'poppy',
+                gty: input.grantType,
                 expiresIn: input.expiresIn,
             });
             at.aud = input.resource;
             return at.save();
         },
-        async revoke(grantId) {
+        async revokeGrant(grantId) {
             const provider = service.provider;
             if (!provider?.Grant)
                 return;
@@ -80,18 +72,32 @@ function mcpBridge(service, poppyApis) {
         },
     };
 }
-async function resolveReplay(replay, conn, make) {
-    if (replay === 'memory')
-        return memoryReplayStore();
-    if (replay === 'database')
-        return databaseReplayStore(conn);
-    if (typeof replay.claim === 'function')
-        return replay;
-    const name = replay.redis;
-    if (!make)
-        throw new Error('authkit: personalAgents.poppy.replay { redis } exige o container.');
-    const redis = await make('redis');
-    return redisReplayStore(redis.connection(name));
+/** O ledger de grants visto por uma extension: só os ids com o prefixo dela. */
+function scopedLedger(store, prefix) {
+    const mine = (id) => typeof id === 'string' && id.startsWith(prefix);
+    return {
+        async insertGrant(grant) {
+            if (!mine(grant.id)) {
+                throw new Error(`authkit: grant "${grant.id}" fora do prefixo "${prefix}" da extension.`);
+            }
+            await store.insertGrant(grant);
+        },
+        async findGrant(id) {
+            return mine(id) ? store.findGrant(id) : null;
+        },
+        async listGrants(accountId) {
+            return (await store.listGrants(accountId)).filter((g) => mine(g.id));
+        },
+        async unrevokedGrantIdsOfClient(clientId) {
+            return (await store.unrevokedGrantIdsOfClient(clientId)).filter(mine);
+        },
+        async revokeGrantById(id, at) {
+            if (mine(id))
+                await store.revokeGrantById(id, at);
+        },
+        insertRefreshToken: (token) => store.insertRefreshToken(token),
+        findRefreshToken: (tokenHash) => store.findRefreshToken(tokenHash),
+    };
 }
 /**
  * Config com o registro do console por cima: um agente BLOQUEADO no console é
@@ -112,21 +118,7 @@ function withRegistry(config, registry) {
         }
         return null;
     };
-    const poppy = config.poppy;
-    return {
-        ...config,
-        resolveAgent,
-        poppy: poppy && {
-            ...poppy,
-            clients: {
-                ...poppy.clients,
-                isBlocked: async (id) => (await poppy.clients.isBlocked(id)) ||
-                    (await registry.find('poppy', id))?.status === 'blocked',
-                isRegistered: async (id) => (await poppy.clients.isRegistered(id)) ||
-                    (await registry.find('poppy', id))?.status === 'allowed',
-            },
-        },
-    };
+    return { ...config, resolveAgent };
 }
 /**
  * Monta (uma vez por `OidcService`) o runtime de personal agents. `null` quando
@@ -149,7 +141,7 @@ export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
             };
             let conn = null;
             const connection = service.config.schema.connection;
-            if (config.delegation || config.poppy) {
+            if (config.delegation || (config.extensions ?? []).length > 0) {
                 const db = await makeDb();
                 conn = () => (connection ? db.connection(connection) : db.connection());
             }
@@ -177,39 +169,53 @@ export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
                     isAccountActive,
                 });
             }
-            let poppy = null;
-            if (effective.poppy && store && conn) {
-                const cfg = effective.poppy;
-                const limiter = cfg.rateLimit === false
-                    ? null
-                    : typeof cfg.rateLimit === 'function'
-                        ? cfg.rateLimit
-                        : memoryLimiter(cfg.rateLimit);
-                const secret = service.deriveSecret('poppy-dpop-nonce');
-                poppy = new PoppyService({
-                    cfg,
-                    urls: poppyUrls(service.config.issuer, cfg.prefix),
-                    store: new PoppyStore(conn),
-                    grants: store,
-                    registry: new PoppyClientRegistry(cfg, { fetchJson: options.fetchJson }),
-                    replay: await resolveReplay(cfg.replay, conn, options.make),
-                    limiter,
-                    nonces: hmacNonceSource(secret),
-                    isAccountActive,
-                    mcp: mcpBridge(service, cfg.apis),
-                    now: options.now,
-                });
+            const extensions = new Map();
+            const now = () => options.now?.() ?? new Date();
+            if (store && conn && registry) {
+                const db = conn;
+                const tokens = accessTokens(service);
+                for (const extension of config.extensions ?? []) {
+                    const runtime = await extension.setup({
+                        protocol: extension.id,
+                        issuer: service.config.issuer,
+                        db: () => db(),
+                        grants: scopedLedger(store, extension.grantIdPrefix),
+                        registryStatus: async (identifier) => (await registry.find(extension.id, identifier))?.status ?? null,
+                        deriveSecret: (label) => service.deriveSecret(label),
+                        isAccountActive,
+                        make: async (binding) => {
+                            if (!options.make) {
+                                throw new Error(`authkit: o binding "${binding}" exige o container do app.`);
+                            }
+                            return options.make(binding);
+                        },
+                        accessTokens: tokens,
+                        now,
+                    });
+                    extensions.set(extension.id, { extension, runtime });
+                }
             }
+            /** A extension dona de um grant, pelo prefixo do id. */
+            const ownerOf = (grantId) => {
+                for (const entry of extensions.values()) {
+                    if (grantId.startsWith(entry.extension.grantIdPrefix))
+                        return entry;
+                }
+                return null;
+            };
+            const isExtensionGrant = (grantId) => (config.extensions ?? []).some((e) => grantId.startsWith(e.grantIdPrefix));
             const revokeAgentGrant = async (accountId, grantId) => {
-                if (grantId.startsWith('pgrant_')) {
-                    return poppy ? poppy.revokeAccountGrant(accountId, grantId) : false;
+                if (isExtensionGrant(grantId)) {
+                    const owner = ownerOf(grantId);
+                    return owner ? owner.runtime.revokeAccountGrant(accountId, grantId) : false;
                 }
                 return delegation ? delegation.revokeGrant(accountId, grantId) : false;
             };
             const revokeAllAgentGrants = async (accountId) => {
                 let count = 0;
-                if (poppy)
-                    count += await poppy.revokeAllAccountGrants(accountId);
+                for (const { runtime } of extensions.values()) {
+                    count += await runtime.revokeAllAccountGrants(accountId);
+                }
                 if (delegation)
                     count += await delegation.revokeAllGrants(accountId);
                 return count;
@@ -222,10 +228,11 @@ export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
                 // Expirado já não vale: revogar não muda nada (e não vira evento de auditoria).
                 if (!grant || grant.revokedAt || grant.expiresAt <= now)
                     return null;
-                if (grantId.startsWith('pgrant_')) {
-                    if (!poppy)
+                if (isExtensionGrant(grantId)) {
+                    const owner = ownerOf(grantId);
+                    if (!owner)
                         return null;
-                    await poppy.revokeGrant(grantId);
+                    await owner.runtime.revokeGrant(grantId);
                 }
                 else {
                     await store.revokeGrantById(grantId, now);
@@ -235,9 +242,11 @@ export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
             const disconnectAgent = async (protocol, identifier) => {
                 if (!store)
                     return 0;
-                if (protocol === 'poppy')
-                    return poppy ? poppy.disconnectClient(identifier) : 0;
-                const ids = (await store.unrevokedGrantIdsOfClient(identifier)).filter((id) => !id.startsWith('pgrant_'));
+                if (protocol !== 'pact') {
+                    const entry = extensions.get(protocol);
+                    return entry ? entry.runtime.disconnectAgent(identifier) : 0;
+                }
+                const ids = (await store.unrevokedGrantIdsOfClient(identifier)).filter((id) => !isExtensionGrant(id));
                 const at = options.now?.() ?? new Date();
                 for (const id of ids)
                     await store.revokeGrantById(id, at);
@@ -248,7 +257,7 @@ export function buildPersonalAgentsRuntime(service, makeDb, options = {}) {
                 urls,
                 verifier: new PersonalAgentVerifier(effective),
                 delegation,
-                poppy,
+                extensions,
                 revokeAgentGrant,
                 revokeAllAgentGrants,
                 registry,
@@ -270,3 +279,29 @@ export async function personalAgentsFor(ctx) {
         make: (binding) => ctx.containerResolver.make(binding),
     });
 }
+/**
+ * The runtime an extension's `setup` built (`personalAgents.extensions`), by protocol id. `null`
+ * when the extension is not configured (or there is no database). Takes the request, an explicit
+ * source (tests, scripts) or nothing (the booted app).
+ *
+ * Stable for 1.x — see `extension.ts`.
+ */
+export async function personalAgentExtensionRuntime(id, from) {
+    let runtime;
+    if (from && 'containerResolver' in from) {
+        runtime = await personalAgentsFor(from);
+    }
+    else if (from) {
+        const source = from;
+        runtime = await buildPersonalAgentsRuntime(source.service, () => source.db(), {
+            make: source.make ? (binding) => source.make(binding) : undefined,
+            now: source.now ? () => source.now() : undefined,
+        });
+    }
+    else {
+        const app = getBootedApp();
+        const service = (await app.container.make('authkit.server'));
+        runtime = await buildPersonalAgentsRuntime(service, () => app.container.make('lucid.db'), { make: (binding) => app.container.make(binding) });
+    }
+    return runtime?.extensions.get(id)?.runtime ?? null;
+}

package/build/src/audit/audit_sink.d.ts

@@ -8,7 +8,7 @@
  * varre os `audit.record({ type: ... })` do `src/` e falha quando um evento
  * emitido não está aqui.
  */
-export declare const AUDIT_EVENT_TYPES: readonly ['login.success', 'login.failure', 'signup', 'password_reset.issued', 'password_reset.consumed', 'pat.issued', 'pat.revoked', 'pat.used', 'impersonation', 'impersonation.panel_viewed', 'impersonation.stopped', 'mfa.enabled', 'mfa.disabled', 'mfa.recovery_codes_regenerated', 'account.locked', 'passkey.registered', 'passkey.removed', 'email_verification.issued', 'email_verification.consumed', 'client.created', 'client.updated', 'client.deleted', 'session.revoked_all', 'password.changed', 'password.rehashed', 'email.change_requested', 'email.changed', 'login.new_ip_notified', 'login.new_device', 'login.otp_sent', 'login.otp_verified', 'login.otp_failed', 'login.otp_invalidated', 'bot_protection.rejected', 'grant.revoked_by_user', 'user.created', 'user.password_reset_sent', 'user.disabled', 'user.enabled', 'user.deleted', 'profile.updated', 'account.deleted', 'account.exported', 'keys.rotated', 'organization.created', 'organization.updated', 'organization.deleted', 'organization.member_added', 'organization.member_removed', 'organization.member_role_changed', 'organization.member_role_updated', 'organization.switched', 'organization.deactivated', 'organization.invitation_sent', 'organization.invitation_accepted', 'organization.invitation_revoked', 'email_change.requested', 'email_change.confirmed', 'email_change.cancelled', 'security_notice.sent', 'settings.updated', 'maintenance.enabled', 'maintenance.disabled', 'trusted_device.revoked', 'password.expired_change_forced', 'otp.locked', 'otp.unlocked', 'otp.unlock_failed', 'sudo.confirmed', 'session.single_enforced', 'account.expired_login_blocked', 'account.expiration_warned', 'login.magic_link_sent', 'session.revoked', 'account.signed_out_all', 'client.secret_regenerated', 'roles_catalog.updated', 'agent.delegation_approved', 'agent.delegation_denied', 'agent.grant_revoked', 'agent.grant_revoked_by_admin', 'agent.allowed', 'agent.blocked', 'agent.registry_removed'];
+export declare const AUDIT_EVENT_TYPES: readonly ['login.success', 'login.failure', 'signup', 'password_reset.issued', 'password_reset.consumed', 'pat.issued', 'pat.revoked', 'pat.used', 'impersonation', 'impersonation.panel_viewed', 'impersonation.stopped', 'mfa.enabled', 'mfa.disabled', 'mfa.recovery_codes_regenerated', 'account.locked', 'passkey.registered', 'passkey.removed', 'email_verification.issued', 'email_verification.consumed', 'client.created', 'client.updated', 'client.deleted', 'session.revoked_all', 'password.changed', 'password.rehashed', 'email.change_requested', 'email.changed', 'login.new_ip_notified', 'login.new_device', 'login.otp_sent', 'login.otp_verified', 'login.otp_failed', 'login.otp_invalidated', 'bot_protection.rejected', 'grant.revoked_by_user', 'user.created', 'user.password_reset_sent', 'user.disabled', 'user.enabled', 'user.deleted', 'profile.updated', 'account.deleted', 'account.exported', 'keys.rotated', 'organization.created', 'organization.updated', 'organization.deleted', 'organization.member_added', 'organization.member_removed', 'organization.member_role_changed', 'organization.member_role_updated', 'organization.switched', 'organization.deactivated', 'organization.invitation_sent', 'organization.invitation_accepted', 'organization.invitation_revoked', 'email_change.requested', 'email_change.confirmed', 'email_change.cancelled', 'security_notice.sent', 'settings.updated', 'maintenance.enabled', 'maintenance.disabled', 'trusted_device.revoked', 'password.expired_change_forced', 'otp.locked', 'otp.unlocked', 'otp.unlock_failed', 'sudo.confirmed', 'session.single_enforced', 'account.expired_login_blocked', 'account.expiration_warned', 'login.magic_link_sent', 'session.revoked', 'account.signed_out_all', 'client.secret_regenerated', 'client.disabled', 'client.enabled', 'service_tenant.token_issued', 'roles_catalog.updated', 'agent.delegation_approved', 'agent.delegation_denied', 'agent.grant_revoked', 'agent.grant_revoked_by_admin', 'agent.allowed', 'agent.blocked', 'agent.registry_removed'];
 /** Tipos de eventos de auditoria relevantes para segurança emitidos pelo IdP. */
 export type AuditEventType = (typeof AUDIT_EVENT_TYPES)[number];
 /**

package/build/src/audit/audit_sink.js

@@ -107,6 +107,11 @@ export const AUDIT_EVENT_TYPES = [
     'session.revoked',
     'account.signed_out_all',
     'client.secret_regenerated',
+    // A client was disabled (no new tokens) or enabled again.
+    'client.disabled',
+    'client.enabled',
+    // A service tenant got a token (`partition`, `resource`, `jti` in the metadata).
+    'service_tenant.token_issued',
     'roles_catalog.updated',
     // Personal agents (PACT §5): o usuário aprovou/negou a delegação pedida por um
     // agente, ou revogou um grant no console. `clientId` = issuer do agente.
@@ -114,7 +119,7 @@ export const AUDIT_EVENT_TYPES = [
     'agent.delegation_denied',
     'agent.grant_revoked',
     // Console admin: um admin revogou a conexão de um usuário, ou liberou/bloqueou um
-    // agente (PACT pelo `iss`, Poppy pelo `client_id`).
+    // agente (PACT pelo `iss`; uma extension pelo identificador dela).
     'agent.grant_revoked_by_admin',
     'agent.allowed',
     'agent.blocked',

package/build/src/define_config.d.ts

@@ -22,6 +22,7 @@ import type { WhatsappCodeSenderBinding } from './host/whatsapp_code_sender.js';
 import { type McpOAuthConfigInput, type ResolvedMcpOAuthConfig } from './mcp/mcp_oauth.js';
 import type { PatStore } from './pat/pat_store.js';
 import { type RedirectUriPolicy, type ResolvedRedirectUriPolicy, type ValidateRegistrationHook } from './provider/registration_policy.js';
+import { type ResolvedServiceTenantsConfig, type ServiceTenantsConfigInput } from './service_tenants/config.js';
 export type { AuthAccount };
 export { adapters };
 export type AuthHostRenderer = (ctx: HttpContext, view: string, props: Record<string, unknown>) => unknown;
@@ -112,18 +113,6 @@ export interface MailHooks {
         email: string;
         sudoUrl: string;
     }) => Promise<void>;
-    /**
-     * Código do Mediated Sign-In pronto do Poppy (`poppyEmailCodeSignIn`): um personal
-     * agent quer entrar na conta e a pessoa precisa dar o código a ele. Sem o hook, o
-     * host-kit envia pelo mailer default, com branding e i18n.
-     */
-    onPoppySignInCode?: (data: {
-        email: string;
-        code: string;
-        /** Nome do agente (metadata dele, ou o host do `client_id`). */
-        agentName: string;
-        expiresInMinutes: number;
-    }) => Promise<void>;
     /**
      * Disparado num login bem-sucedido a partir de um IP NOVO para a conta (nenhum
      * `login.success` anterior desse IP no audit sink), quando `notifications.newLoginEmail`
@@ -1125,6 +1114,19 @@ export interface AuthServerConfigInput {
      * `resources` mapeia resource indicators (RFC 8707) para audiences/scopes/formato/TTL por API.
      */
     accessTokens?: AccessTokensConfig;
+    /**
+     * Service tenants: confidential `client_credentials` clients that act as a partition of
+     * a resource server (e.g. a durable control plane). `resources` lists the resource
+     * indicators (RFC 8707) that issue their JWT access tokens (RFC 9068), each with an
+     * optional `expiresIn` (seconds, default 600), `audience` and `scopes`:
+     *
+     * ```ts
+     * serviceTenants: { resources: { 'urn:agora:durable': { expiresIn: 600 } } }
+     * ```
+     *
+     * Turns on the `client_credentials` grant. Default: off.
+     */
+    serviceTenants?: ServiceTenantsConfigInput;
     /**
      * Login OAuth de clientes MCP (Claude Code, Claude, ChatGPT, VS Code, Cursor): `true` liga o
      * registro dinâmico restrito aos redirects deles, o refresh token desses clientes e os
@@ -1367,6 +1369,8 @@ export interface ResolvedServerConfig {
     registration: ResolvedRegistrationConfig;
     /** Access Tokens resolvido (RFC 9068; default opaque). */
     accessTokens: ResolvedAccessTokensConfig;
+    /** Service tenants (always present; `enabled: false` when no resource is declared). */
+    serviceTenants: ResolvedServiceTenantsConfig;
     mcp: ResolvedMcpOAuthConfig;
     /** Console admin resolvido (sempre presente; default desligado). */
     admin: ResolvedAdminConfig;

package/build/src/define_config.js

@@ -6,7 +6,7 @@ import { composeAuditSink, resolveEvents } from './events/dispatcher.js';
 import { resolveBotProtection, } from './host/bot_protection.js';
 import { resolveBranding } from './host/branding.js';
 import { deriveLockedRouteOptions, deriveLockedSettingKeys, } from './host/config_locks.js';
-import { resolveMessages } from './host/i18n.js';
+import { registerExtensionMessages, resolveMessages, } from './host/i18n.js';
 import { resolveOtpLoginConfig, } from './host/otp_login.js';
 import { edgeRenderer } from './host/renderers/edge_renderer.js';
 import { warnUnsatisfiableSudoConfig } from './host/sudo/satisfiability.js';
@@ -17,6 +17,7 @@ import { loadEncryptionService } from './keys/keystore_crypto.js';
 import { KeystoreManager, resolveKeystoreVault } from './keys/keystore_manager.js';
 import { mcpClientRegistration, resolveMcpOAuth, } from './mcp/mcp_oauth.js';
 import { OPEN_REGISTRATION_REDIRECT_POLICY, resolveRedirectUriPolicy, } from './provider/registration_policy.js';
+import { resolveServiceTenants, } from './service_tenants/config.js';
 export { adapters };
 const RATE_LIMIT_DEFAULTS = {
     login: { points: 10, duration: '1 min' },
@@ -343,7 +344,7 @@ export function defineConfig(config) {
         }
         // Personal agents com delegação assinam tokens e recibos com este keystore,
         // e o PACT só admite ES256/RS256 — falha no boot, não na primeira troca de token.
-        const personalAgents = resolvePersonalAgentsConfig(config.personalAgents);
+        const personalAgents = resolvePersonalAgentsConfig(config.personalAgents, config.issuer);
         if (personalAgents?.delegation)
             assertDelegationSigningKey(jwks);
         // Debaixo do mountPath, a rota curinga do oidc-provider (`${mount}/*`)
@@ -355,11 +356,13 @@ export function defineConfig(config) {
             (personalAgents.prefix === oidcMount || personalAgents.prefix.startsWith(`${oidcMount}/`))) {
             throw new Error(`authkit: personalAgents.prefix "${personalAgents.prefix}" não pode ficar debaixo do mountPath do OIDC ("${oidcMount}").`);
         }
-        const poppyPrefix = personalAgents?.poppy?.prefix;
-        if (poppyPrefix &&
-            oidcMount &&
-            (poppyPrefix === oidcMount || poppyPrefix.startsWith(`${oidcMount}/`))) {
-            throw new Error(`authkit: personalAgents.poppy.prefix "${poppyPrefix}" não pode ficar debaixo do mountPath do OIDC ("${oidcMount}").`);
+        for (const extension of personalAgents?.extensions ?? []) {
+            if (extension.messages)
+                registerExtensionMessages(extension.messages);
+            if (oidcMount &&
+                (extension.prefix === oidcMount || extension.prefix.startsWith(`${oidcMount}/`))) {
+                throw new Error(`authkit: o prefixo "${extension.prefix}" de personalAgents.extensions "${extension.id}" não pode ficar debaixo do mountPath do OIDC ("${oidcMount}").`);
+            }
         }
         // BACKSTOP DE SUDO. Um host cujo `sudo.methods` não tem um único método
         // satisfazível por conta sem senha fica bricado para TODA operação sob
@@ -473,6 +476,7 @@ export function defineConfig(config) {
                 : undefined,
             registration: resolveRegistration(config.registration),
             accessTokens: resolveAccessTokens(config.issuer, config.accessTokens),
+            serviceTenants: resolveServiceTenants(config.serviceTenants, config.accessTokens?.resources),
             mcp: resolveMcpOAuth(config.mcp),
             admin: resolveAdmin(config.admin),
             adminApi: resolveAdminApi(config.adminApi),

package/build/src/host/access_token_verifier.js

@@ -41,6 +41,10 @@ function fromJwtPayload(payload) {
     if (typeof payload.sub !== 'string' || !payload.sub)
         return null;
     const clientId = payload.client_id;
+    // No user behind it: a `client_credentials` token (a service tenant's, for one) has
+    // `sub` = the client id (RFC 9068 §2.2) and never authenticates an account.
+    if (payload.sub === clientId)
+        return null;
     return {
         format: 'jwt',
         sub: payload.sub,
@@ -209,6 +213,9 @@ export function remoteAccessTokenVerifier(options) {
             return null;
         if (typeof body.sub !== 'string' || !body.sub)
             return null;
+        // `client_credentials` token: no account behind it.
+        if (body.sub === body.client_id)
+            return null;
         if (typeof body.exp === 'number' && body.exp <= Math.floor(Date.now() / 1000))
             return null;
         return {

package/build/src/host/account_api/account_api_controller.js

@@ -611,7 +611,7 @@ export default class AccountApiController {
     /** Personal agents com delegação ativa na conta (scopes aprovados). */
     async listAgents(ctx) {
         const runtime = await personalAgentsFor(ctx);
-        if (!runtime?.delegation && !runtime?.poppy) {
+        if (!runtime || (!runtime.delegation && runtime.extensions.size === 0)) {
             return ctx.response
                 .status(404)
                 .send(apiErr('capability_unsupported', 'Personal agent delegation is not enabled.'));
@@ -620,16 +620,18 @@ export default class AccountApiController {
         const pact = runtime.delegation
             ? (await runtime.delegation.listGrants(userId)).map((g) => ({ ...g, protocol: 'pact' }))
             : [];
-        const poppy = runtime.poppy
-            ? (await runtime.poppy.listGrants(userId)).map((g) => ({ ...g, protocol: 'poppy' }))
-            : [];
-        return { agents: [...pact, ...poppy] };
+        const others = [];
+        for (const [protocol, { runtime: extension }] of runtime.extensions) {
+            for (const g of await extension.listAccountGrants(userId))
+                others.push({ ...g, protocol });
+        }
+        return { agents: [...pact, ...others] };
     }
     // ─── DELETE /account/api/agents/:id ──────────────────────────────────────
     /** Revoga a delegação de um personal agent (efeito imediato nos tokens). */
     async revokeAgent(ctx) {
         const runtime = await personalAgentsFor(ctx);
-        if (!runtime?.delegation && !runtime?.poppy) {
+        if (!runtime || (!runtime.delegation && runtime.extensions.size === 0)) {
             return ctx.response
                 .status(404)
                 .send(apiErr('capability_unsupported', 'Personal agent delegation is not enabled.'));

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

@@ -0,0 +1,12 @@
+/**
+ * Abrir e fechar a sessão de CONTA do authkit (o cookie do console, `ACCOUNT_SESSION_KEY`) a partir
+ * de código de fora do host-kit — o navegador de um personal agent que entrou na conta, por
+ * exemplo. Sincroniza `ctx.auth` (`adonisAuth.guard`) como o login do próprio console.
+ *
+ * Estável no 1.x (usado pelas `personalAgents.extensions`).
+ */
+import type { HttpContext } from '@adonisjs/core/http';
+/** Liga a sessão de conta a `accountId` e sincroniza `ctx.auth`. Não regenera a sessão. */
+export declare function signInAccountSession(ctx: HttpContext, accountId: string): Promise<void>;
+/** Desliga a sessão de conta e sincroniza `ctx.auth`. Não regenera a sessão. */
+export declare function signOutAccountSession(ctx: HttpContext): Promise<void>;

package/build/src/host/account_session_sign_in.js

@@ -0,0 +1,19 @@
+import { ACCOUNT_SESSION_KEY } from './account_session_key.js';
+import { syncAdonisAuthLogin, syncAdonisAuthLogout } from './adonis_auth_sync.js';
+/** Liga a sessão de conta a `accountId` e sincroniza `ctx.auth`. Não regenera a sessão. */
+export async function signInAccountSession(ctx, accountId) {
+    // Sem augmentation no barrel (ver `augmentation_isolation.spec.ts`): a sessão é lida sem tipo.
+    const session = ctx.session;
+    const service = await ctx.containerResolver.make('authkit.server');
+    session.put(ACCOUNT_SESSION_KEY, accountId);
+    const account = await service.config.accountStore.findById(accountId);
+    if (account)
+        await syncAdonisAuthLogin(ctx, service.config, account);
+}
+/** Desliga a sessão de conta e sincroniza `ctx.auth`. Não regenera a sessão. */
+export async function signOutAccountSession(ctx) {
+    const session = ctx.session;
+    const service = await ctx.containerResolver.make('authkit.server');
+    session.forget(ACCOUNT_SESSION_KEY);
+    await syncAdonisAuthLogout(ctx, service.config);
+}

package/build/src/host/admin_api/api_clients_controller.d.ts

@@ -6,6 +6,7 @@ import type { HttpContext } from '@adonisjs/core/http';
  * em create/regenerate. Audita create/update/delete.
  */
 export default class ApiClientsController {
+    #private;
     index(ctx: HttpContext): Promise<{
         data: {
             clientId: string;
@@ -19,6 +20,8 @@ export default class ApiClientsController {
             backchannelLogoutSessionRequired: boolean;
             clientName: string | null;
             logoUri: string | null;
+            disabled: boolean;
+            serviceTenant: import("../../service_tenants/client_metadata.ts").ServiceTenantInfo | null;
         }[];
         canList: boolean;
     }>;
@@ -34,6 +37,8 @@ export default class ApiClientsController {
         backchannelLogoutSessionRequired: boolean;
         clientName: string | null;
         logoUri: string | null;
+        disabled: boolean;
+        serviceTenant: import("../../service_tenants/client_metadata.ts").ServiceTenantInfo | null;
     }>;
     store(ctx: HttpContext): Promise<void | {
         clientId: string;
@@ -51,11 +56,43 @@ export default class ApiClientsController {
         backchannelLogoutSessionRequired: boolean;
         clientName: string | null;
         logoUri: string | null;
+        disabled: boolean;
+        serviceTenant: import("../../service_tenants/client_metadata.ts").ServiceTenantInfo | null;
     }>;
     regenerateSecret(ctx: HttpContext): Promise<void | {
         clientId: any;
         clientSecret: string;
     }>;
+    disable(ctx: HttpContext): Promise<void | {
+        clientId: string;
+        confidential: boolean;
+        grantTypes: string[];
+        redirectUris: string[];
+        postLogoutRedirectUris: string[];
+        tokenEndpointAuthMethod: string;
+        applicationType: import("../client_metadata.js").ApplicationType;
+        backchannelLogoutUri: string | null;
+        backchannelLogoutSessionRequired: boolean;
+        clientName: string | null;
+        logoUri: string | null;
+        disabled: boolean;
+        serviceTenant: import("../../service_tenants/client_metadata.ts").ServiceTenantInfo | null;
+    }>;
+    enable(ctx: HttpContext): Promise<void | {
+        clientId: string;
+        confidential: boolean;
+        grantTypes: string[];
+        redirectUris: string[];
+        postLogoutRedirectUris: string[];
+        tokenEndpointAuthMethod: string;
+        applicationType: import("../client_metadata.js").ApplicationType;
+        backchannelLogoutUri: string | null;
+        backchannelLogoutSessionRequired: boolean;
+        clientName: string | null;
+        logoUri: string | null;
+        disabled: boolean;
+        serviceTenant: import("../../service_tenants/client_metadata.ts").ServiceTenantInfo | null;
+    }>;
     destroy(ctx: HttpContext): Promise<{
         clientId: any;
         deleted: boolean;

package/build/src/host/admin_api/api_clients_controller.js

@@ -85,11 +85,16 @@ export default class ApiClientsController {
         const id = ctx.request.param('id');
         try {
             const secret = await svc.regenerateSecret(id);
+            const tenant = (await svc.find(id))?.serviceTenant;
             await service.config.audit?.record({
                 type: 'client.updated',
                 clientId: id,
                 ip: ctx.request.ip?.() ?? null,
-                metadata: { actor: 'admin-api', action: 'regenerate_secret' },
+                metadata: {
+                    actor: 'admin-api',
+                    action: 'regenerate_secret',
+                    ...(tenant ? { partition: tenant.partition } : {}),
+                },
             });
             return { clientId: id, clientSecret: secret };
         }
@@ -97,6 +102,31 @@ export default class ApiClientsController {
             return ctx.response.conflict(apiError('cannot_regenerate', e.message));
         }
     }
+    async disable(ctx) {
+        return this.#setDisabled(ctx, true);
+    }
+    async enable(ctx) {
+        return this.#setDisabled(ctx, false);
+    }
+    /** Disabled clients get `invalid_client` from the next request on. */
+    async #setDisabled(ctx, disabled) {
+        const { service, svc } = await clientsService(ctx);
+        const id = ctx.request.param('id');
+        if (!(await svc.setDisabled(id, disabled))) {
+            return ctx.response.notFound(apiError('not_found', 'Client não encontrado.'));
+        }
+        const client = await svc.find(id);
+        await service.config.audit?.record({
+            type: disabled ? 'client.disabled' : 'client.enabled',
+            clientId: id,
+            ip: ctx.request.ip?.() ?? null,
+            metadata: {
+                actor: 'admin-api',
+                ...(client?.serviceTenant ? { partition: client.serviceTenant.partition } : {}),
+            },
+        });
+        return clientDto(client);
+    }
     async destroy(ctx) {
         const { service, svc } = await clientsService(ctx);
         const id = ctx.request.param('id');