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

package/build/src/agents/extension.js

@@ -0,0 +1,40 @@
+const EXTENSION_ID = /^[a-z0-9-]{2,16}$/;
+const GRANT_PREFIX = /^[a-z0-9]+_$/;
+function normalizePrefix(prefix, id) {
+    const trimmed = (prefix ?? '').trim().replace(/\/+$/, '');
+    if (!trimmed || trimmed === '/') {
+        throw new Error(`authkit: personalAgents.extensions "${id}" — prefix is required.`);
+    }
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+/** Resolves and validates `personalAgents.extensions`. */
+export function resolvePersonalAgentExtensions(input, context) {
+    const out = [];
+    for (const extension of input ?? []) {
+        const id = extension?.id;
+        if (typeof id !== 'string' || !EXTENSION_ID.test(id) || id === 'pact') {
+            throw new Error(`authkit: personalAgents.extensions — invalid id "${String(id)}" (2–16 of a-z, 0-9, -; not "pact").`);
+        }
+        if (out.some((e) => e.id === id)) {
+            throw new Error(`authkit: personalAgents.extensions — "${id}" is listed twice.`);
+        }
+        const definition = extension.resolve(context);
+        if (!GRANT_PREFIX.test(definition.grantIdPrefix) || definition.grantIdPrefix === 'agrant_') {
+            throw new Error(`authkit: personalAgents.extensions "${id}" — invalid grantIdPrefix "${definition.grantIdPrefix}".`);
+        }
+        if (out.some((e) => e.grantIdPrefix === definition.grantIdPrefix)) {
+            throw new Error(`authkit: personalAgents.extensions "${id}" — grantIdPrefix "${definition.grantIdPrefix}" is already taken.`);
+        }
+        const prefix = normalizePrefix(definition.prefix, id);
+        for (const other of out) {
+            if (other.prefix === prefix ||
+                other.prefix.startsWith(`${prefix}/`) ||
+                prefix.startsWith(`${other.prefix}/`)) {
+                throw new Error(`authkit: personalAgents.extensions "${id}" — prefix "${prefix}" overlaps "${other.id}" ("${other.prefix}").`);
+            }
+        }
+        // A plain object literal: its own members are the definition.
+        out.push({ ...definition, id, prefix });
+    }
+    return out;
+}

package/build/src/agents/middleware.js

@@ -40,7 +40,7 @@ export function personalAgentAuth(options = {}) {
     const mode = options.delegation ?? 'optional';
     return async (ctx, next) => {
         const runtime = await personalAgentsFor(ctx);
-        // Sem PACT (app só-Poppy) não há JWT de agente para verificar.
+        // Sem PACT (app só com extensions) não há JWT de agente para verificar.
         if (!runtime?.config.pact)
             return ctx.response.notFound();
         const { protocol } = runtime.config;

package/build/src/agents/protocol.d.ts

@@ -10,10 +10,10 @@ import type { DelegationReceipt } from './delegation_service.js';
  * MESMA família (JWT do agente + token de delegação) entra como mais um objeto
  * desta interface, passado direto em `personalAgents.protocol`.
  *
- * O Personal Agent Protocol ("Poppy", Sierra/Meta) tem outro modelo — um
- * authorization server OAuth com Sessions e tokens DPoP — e por isso não é um
- * adapter daqui: liga-se em `personalAgents.poppy` (ver `poppy/`), ao lado do
- * PACT, reaproveitando o núcleo de grants.
+ * Um protocolo de outro modelo (ex.: um authorization server OAuth próprio, como o
+ * Personal Agent Protocol de `@adonis-agora/authkit-poppy`) não é um adapter daqui:
+ * liga-se em `personalAgents.extensions` (ver `extension.ts`), ao lado do PACT,
+ * reaproveitando o núcleo de grants.
  */
 export interface PersonalAgentProtocol {
     /** Identificador estável (`'pact'`). */

package/build/src/agents/registry_store.d.ts

@@ -1,10 +1,11 @@
 export declare const REGISTRY_TABLE = "auth_agent_registry";
-export type AgentProtocolId = 'pact' | 'poppy';
+/** `'pact'` ou o id de uma extension (`personalAgents.extensions`). */
+export type AgentProtocolId = 'pact' | (string & {});
 export type AgentRegistryStatus = 'allowed' | 'blocked';
 export interface AgentRegistryRow {
     id: string;
     protocol: AgentProtocolId;
-    /** PACT: o `iss` do agente. Poppy: o `client_id` (URL do documento de metadata). */
+    /** PACT: o `iss` do agente. Extensions: o identificador do agente no protocolo delas. */
     identifier: string;
     status: AgentRegistryStatus;
     name: string | null;

package/build/src/agents/registry_store.js

@@ -3,7 +3,7 @@
  * `auth_agent_registry` (ver `schema/ensure.ts`). SOMA ao `defineConfig`:
  *
  * - `allowed`: o agente entra mesmo fora da lista do config (PACT: issuer + JWKS;
- *   Poppy: `client_id` registrado quando `clients.requireRegistration`).
+ *   extensions: o identificador do agente no protocolo delas).
  * - `blocked`: o agente é recusado mesmo que o config o liste — bloquear é a
  *   ação de emergência, e precisa valer sem deploy.
  *

package/build/src/agents/runtime.d.ts

@@ -4,8 +4,7 @@ import { PersonalAgentVerifier } from './agent_identity.js';
 import type { ResolvedPersonalAgentsConfig } from './config.js';
 import { PersonalAgentDelegation } from './delegation_service.js';
 import { DelegationStore, type GrantRow } from './delegation_store.js';
-import type { JsonFetcher } from './poppy/safe_fetch.js';
-import { PoppyService } from './poppy/service.js';
+import type { PersonalAgentProtocolRuntime, ResolvedPersonalAgentExtension } from './extension.js';
 import { type AgentProtocolId, AgentRegistryStore } from './registry_store.js';
 /** URLs públicas do authorization server de delegação. */
 export interface PersonalAgentUrls {
@@ -31,9 +30,15 @@ export interface PersonalAgentsRuntime {
     verifier: PersonalAgentVerifier;
     /** `null` quando o app não configurou `personalAgents.delegation`. */
     delegation: PersonalAgentDelegation | null;
-    /** `null` quando o app não configurou `personalAgents.poppy`. */
-    poppy: PoppyService | null;
-    /** Revoga um grant de personal agent DA CONTA (PACT ou Poppy). */
+    /**
+     * Runtimes de `personalAgents.extensions`, por id do protocolo. Vazio sem extensions ou sem
+     * banco.
+     */
+    extensions: Map<string, {
+        extension: ResolvedPersonalAgentExtension;
+        runtime: PersonalAgentProtocolRuntime;
+    }>;
+    /** Revoga um grant de personal agent DA CONTA (PACT ou de uma extension). */
     revokeAgentGrant(accountId: string, grantId: string): Promise<boolean>;
     /** Revoga todos os grants de personal agents da conta. Devolve quantos estavam vivos. */
     revokeAllAgentGrants(accountId: string): Promise<number>;
@@ -52,8 +57,6 @@ export interface PersonalAgentsRuntime {
 export interface BuildPersonalAgentsOptions {
     /** Resolve serviços do container (redis do replay store). */
     make?: (binding: string) => Promise<any>;
-    /** Busca de JSON (metadata/JWKS dos agentes Poppy) — injetável nos testes. */
-    fetchJson?: JsonFetcher;
     now?: () => Date;
 }
 /**
@@ -63,3 +66,19 @@ export interface BuildPersonalAgentsOptions {
 export declare function buildPersonalAgentsRuntime(service: OidcService, makeDb: () => Promise<any>, options?: BuildPersonalAgentsOptions): Promise<PersonalAgentsRuntime | null>;
 /** Runtime a partir de uma request. */
 export declare function personalAgentsFor(ctx: HttpContext): Promise<PersonalAgentsRuntime | null>;
+/** Where {@link personalAgentExtensionRuntime} builds the runtime from, outside a request. */
+export interface PersonalAgentRuntimeSource {
+    service: OidcService;
+    /** The Lucid `Database` (the `lucid.db` binding). */
+    db(): Promise<unknown>;
+    make?(binding: string): Promise<unknown>;
+    now?(): Date;
+}
+/**
+ * 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 declare function personalAgentExtensionRuntime<R extends PersonalAgentProtocolRuntime = PersonalAgentProtocolRuntime>(id: string, from?: HttpContext | PersonalAgentRuntimeSource): Promise<R | null>;

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.js

@@ -114,7 +114,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

@@ -112,18 +112,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`

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';
@@ -343,7 +343,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 +355,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

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_console/console_personal_agents_controller.d.ts

@@ -22,7 +22,7 @@ interface AgentEntry {
     connections: number;
 }
 /**
- * Endpoints JSON de personal agents (PACT e Poppy) do console admin React.
+ * Endpoints JSON de personal agents (PACT e `personalAgents.extensions`) do console admin React.
  *
  * GET    {prefix}/api/personal-agents                          → agentes (config + console + conectados)
  * GET    {prefix}/api/personal-agents/connections?clientId=&accountId=&protocol=&page=&size=
@@ -41,11 +41,6 @@ export default class ConsolePersonalAgentsController {
                 /** A lista do config é uma função do host (o console não enxerga). */
                 hostResolver: boolean;
             } | null;
-            poppy: {
-                requireRegistration: boolean;
-                hostResolver: boolean;
-                allowInsecureClientIds: boolean;
-            } | null;
         };
         agents: AgentEntry[];
     }>;