@absolutejs/auth 0.54.9 → 0.55.1

package/dist/agents/postgresStores.d.ts

@@ -1,5 +1,5 @@
 import { type AnyPgDatabase } from '../stores/postgres';
-import type { AgentDelegationStatus, AgentDelegationStore, AgentRegistrationStatus, AgentRegistrationStore } from './types';
+import type { AgentDelegationStatus, AgentDelegationStore, AgentIdentityRegistrationKind, AgentIdentityRegistrationStatus, AgentIdentityRegistrationStore, AgentRegistrationStatus, AgentRegistrationStore } from './types';
 export declare const agentDelegationsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "auth_agent_delegations";
     schema: undefined;
@@ -157,6 +157,283 @@ export declare const agentDelegationsTable: import("drizzle-orm/pg-core").PgTabl
     };
     dialect: "pg";
 }>;
+export declare const agentIdentityRegistrationsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "auth_agent_identity_registrations";
+    schema: undefined;
+    columns: {
+        agent_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        claim_attempt: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgJsonbBuilder, import("./types").AgentClaimAttempt | undefined>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "object json";
+            data: import("./types").AgentClaimAttempt | undefined;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        claim_attempt_token_hash: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        claim_expires_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        claim_token_hash: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        created_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        expires_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        kind: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, AgentIdentityRegistrationKind>>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: AgentIdentityRegistrationKind;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        last_polled_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgBigInt53Builder, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        login_hint: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        registration_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, AgentIdentityRegistrationStatus>>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: AgentIdentityRegistrationStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        updated_at_ms: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        upstream_client_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        upstream_issuer: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        upstream_subject: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        user_id: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        version: import("drizzle-orm/pg-core").PgBuildColumn<"auth_agent_identity_registrations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+            name: string;
+            tableName: "auth_agent_identity_registrations";
+            dataType: "number int32";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
 export declare const agentRegistrationsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "auth_agent_registrations";
     schema: undefined;
@@ -285,6 +562,8 @@ export declare const agentRegistrationsTable: import("drizzle-orm/pg-core").PgTa
     dialect: "pg";
 }>;
 export declare const createNeonAgentDelegationStore: (databaseUrl: string) => AgentDelegationStore;
+export declare const createNeonAgentIdentityRegistrationStore: (databaseUrl: string) => AgentIdentityRegistrationStore;
 export declare const createNeonAgentRegistrationStore: (databaseUrl: string) => AgentRegistrationStore;
 export declare const createPostgresAgentDelegationStore: <DB extends AnyPgDatabase>(db: DB) => AgentDelegationStore;
+export declare const createPostgresAgentIdentityRegistrationStore: <DB extends AnyPgDatabase>(db: DB) => AgentIdentityRegistrationStore;
 export declare const createPostgresAgentRegistrationStore: <DB extends AnyPgDatabase>(db: DB) => AgentRegistrationStore;

package/dist/agents/registration.d.ts

@@ -0,0 +1,162 @@
+import type { AccessTokenStore } from '../apikeys/types';
+import { type SigningKey } from '../oidc/keys';
+import type { RouteString } from '../types';
+import type { AgentAuthConfig, AgentRegistrationDiscoveryMetadata } from './config';
+import type { AgentIdentityRegistration, AgentIdentityRegistrationKind, AgentIdentityRegistrationStore, VerifiedAgentIdentityAssertion } from './types';
+export declare const AGENT_CLAIM_GRANT_TYPE: "urn:workos:agent-auth:grant-type:claim";
+export declare const AGENT_IDENTITY_ASSERTION_GRANT_TYPE: "urn:ietf:params:oauth:grant-type:jwt-bearer";
+export declare const AGENT_IDENTITY_ASSERTION_TYPE: "urn:ietf:params:oauth:token-type:id-jag";
+export type AgentRegistrationAuthenticatedUser = {
+    email?: string;
+    userId: string;
+};
+export type AgentRegistrationProtocolConfig = {
+    accessTokenStore: AccessTokenStore;
+    allowAnonymous?: boolean;
+    allowServiceAuth?: boolean;
+    assertionTtlMs?: number;
+    attemptTtlMs?: number;
+    claimRoute?: RouteString;
+    claimTtlMs?: number;
+    completeRoute?: RouteString;
+    guideRoute?: RouteString;
+    identityRoute?: RouteString;
+    identityStore: AgentIdentityRegistrationStore;
+    maxAuthenticationAgeMs?: number;
+    maxCodeAttempts?: number;
+    pollIntervalSeconds?: number;
+    postClaimScopes: string[];
+    preClaimScopes?: string[];
+    resolveAuthenticatedUser: (request: Request) => Promise<AgentRegistrationAuthenticatedUser | undefined>;
+    /** Match a cryptographically verified upstream identity to local state. A
+     * userId permits immediate registration; omitting it requires a user claim. */
+    resolveVerifiedIdentity?: (identity: VerifiedAgentIdentityAssertion) => Promise<{
+        userId?: string;
+    } | undefined>;
+    /** Bulk-revokes access tokens for an agent. Required for anonymous
+     * registration and recommended for immediate cleanup on any revocation. It
+     * must be idempotent because atomic state updates may be retried. */
+    revokeAccessTokens?: (agentId: string) => Promise<void>;
+    signingKey: SigningKey;
+    tokenTtlMs?: number;
+    verifyIdentityAssertion?: (assertion: string) => Promise<VerifiedAgentIdentityAssertion | undefined>;
+};
+export type AgentRegistrationEndpoints = {
+    claimEndpoint: string;
+    completeEndpoint: string;
+    guide: string;
+    identityEndpoint: string;
+    tokenEndpoint: string;
+};
+export declare const agentRegistrationDiscoveryMetadata: (config: AgentAuthConfig) => AgentRegistrationDiscoveryMetadata;
+export declare const agentRegistrationEndpoints: (config: AgentAuthConfig) => AgentRegistrationEndpoints;
+/** Generates the agent-readable companion document. Endpoint URLs and support
+ * flags come from the same structured configuration used for discovery, so the
+ * prose cannot silently drift from the authorization server metadata. */
+export declare const generateAgentRegistrationGuide: (config: AgentAuthConfig) => string;
+declare const createFlow: ({ agentId, kind, loginHint, now, registration, status, upstream, userId, withAttempt }: {
+    agentId: string;
+    kind: AgentIdentityRegistrationKind;
+    loginHint?: string;
+    now: number;
+    registration: AgentRegistrationProtocolConfig;
+    status: AgentIdentityRegistration["status"];
+    upstream?: AgentIdentityRegistration["upstream"];
+    userId?: string;
+    withAttempt?: string;
+}) => Promise<{
+    attempt: {
+        attempt: {
+            attempts: number;
+            email: string;
+            expiresAt: number;
+            tokenHash: string;
+            userCodeHash: string;
+        };
+        attemptToken: string;
+        expiresAt: number;
+        userCode: string;
+    } | undefined;
+    claimToken: string;
+    flow: AgentIdentityRegistration;
+}>;
+export declare const issueAgentServiceAssertion: (config: AgentAuthConfig, flow: AgentIdentityRegistration, now?: number) => Promise<{
+    assertion: string;
+    expiresAt: number;
+}>;
+declare const ceremony: (config: AgentAuthConfig, flow: AgentIdentityRegistration, attempt: NonNullable<Awaited<ReturnType<typeof createFlow>>["attempt"]>) => {
+    expires_in: number;
+    interval: number;
+    user_code: string;
+    verification_uri: string;
+};
+export type StartAgentRegistrationInput = {
+    type: 'anonymous';
+} | {
+    loginHint: string;
+    type: 'service_auth';
+} | {
+    assertion: string;
+    assertionType: typeof AGENT_IDENTITY_ASSERTION_TYPE;
+    type: 'identity_assertion';
+};
+export type StartAgentRegistrationResult = {
+    error: string;
+    message?: string;
+    status: 400 | 401 | 403;
+} | {
+    assertionExpires: number;
+    claim?: ReturnType<typeof ceremony>;
+    claimToken?: string;
+    claimTokenExpires?: number;
+    identityAssertion?: string;
+    preClaimScopes?: string[];
+    postClaimScopes: string[];
+    registrationId: string;
+    registrationType: AgentIdentityRegistrationKind;
+    status: 200;
+};
+export declare const startAgentRegistration: (config: AgentAuthConfig, input: StartAgentRegistrationInput, now?: number) => Promise<StartAgentRegistrationResult>;
+export type BeginAgentClaimResult = {
+    error: 'claim_expired' | 'invalid_claim_token';
+    status: 400;
+} | {
+    error: 'concurrent_update';
+    status: 409;
+} | {
+    claimAttempt: ReturnType<typeof ceremony>;
+    status: 200;
+};
+export declare const beginAgentClaim: (config: AgentAuthConfig, input: {
+    claimToken: string;
+    email: string;
+}, now?: number) => Promise<BeginAgentClaimResult>;
+export type CompleteAgentClaimResult = {
+    error: 'claim_expired' | 'concurrent_update' | 'invalid_claim_attempt' | 'user_code_invalid' | 'wrong_user';
+    status: 400 | 403 | 409 | 429;
+} | {
+    status: 204;
+};
+export declare const completeAgentClaim: (config: AgentAuthConfig, input: {
+    attemptToken: string;
+    request: Request;
+    userCode: string;
+}, now?: number) => Promise<CompleteAgentClaimResult>;
+export type AgentTokenGrantResult = {
+    body: Record<string, unknown>;
+    status: 200;
+} | {
+    body: {
+        error: string;
+    };
+    status: 400;
+};
+export declare const createAgentRegistrationCredentialVerifier: (accessTokenStore: AccessTokenStore, identityStore?: AgentIdentityRegistrationStore) => (request: Request) => Promise<{
+    agentId: string;
+    expiresAt: number;
+    scopes: string[];
+    userId: string | undefined;
+} | undefined>;
+export declare const handleAgentTokenGrant: (config: AgentAuthConfig, body: Record<string, string | undefined>, now?: number) => Promise<AgentTokenGrantResult | undefined>;
+export declare const revokeAgentIdentityRegistration: (config: AgentAuthConfig, registrationId: string, now?: number) => Promise<boolean>;
+export {};

package/dist/agents/registrationClient.d.ts

@@ -0,0 +1,50 @@
+type JsonObject = Record<string, unknown>;
+export type DiscoveredAgentRegistration = {
+    agentAuth: {
+        claimEndpoint: string;
+        identityAssertionTypes: string[];
+        identityEndpoint: string;
+        identityTypes: string[];
+        skill: string;
+    };
+    authorizationServer: string;
+    resource: string;
+    resourceMetadataUrl: string;
+    scopes: string[];
+    tokenEndpoint: string;
+};
+export type AgentRegistrationClientOptions = {
+    allowInsecureLocalhost?: boolean;
+    maxResponseBytes?: number;
+    request?: typeof fetch;
+};
+/** Discovers agent registration using RFC 9728 followed by RFC 8414. Network
+ * policy is injected through `request`; redirects are rejected by default. */
+export declare const createAgentRegistrationClient: (discovery: DiscoveredAgentRegistration, options?: AgentRegistrationClientOptions) => {
+    beginAnonymous: () => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+    beginServiceAuth: (loginHint: string) => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+    beginVerified: (assertion: string) => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+    claim: (claimToken: string, email: string) => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+    exchangeAssertion: (assertion: string) => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+    pollClaim: (claimToken: string) => Promise<{
+        body: JsonObject;
+        response: Response;
+    }>;
+};
+export declare const discoverAgentRegistration: (resource: string, options?: AgentRegistrationClientOptions) => Promise<DiscoveredAgentRegistration>;
+export {};

package/dist/agents/routes.d.ts

@@ -1,6 +1,7 @@
 import { Elysia } from 'elysia';
 import { type AgentAuthConfig } from './config';
 import type { AgentPrincipal } from './types';
+import { agentRegistrationDiscoveryMetadata } from './registration';
 type AgentAuthFailure = {
     code: 'Forbidden' | 'Unauthorized';
     message: 'Agent is not authenticated' | 'Insufficient agent scopes';
@@ -11,6 +12,39 @@ export declare const agentAuthChallenge: ({ config, error, requiredScopes }: {
     requiredScopes?: string[];
 }) => string;
 export declare const agentResourceMetadataUrl: (config: AgentAuthConfig) => string;
+export { agentRegistrationDiscoveryMetadata };
+export declare const agentAuthContextPlugin: (config?: AgentAuthConfig) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+    };
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+    }>;
+}>;
 export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     decorator: {};
     store: {};
@@ -92,5 +126,114 @@ export declare const agentAuthPlugin: (config?: AgentAuthConfig) => Elysia<"", {
     schema: {};
     standaloneSchema: {};
     response: {};
+}> | Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly protectAgent: <AuthReturn, AuthFailReturn>(requiredScopes: string[], handleAuth: (principal: AgentPrincipal) => AuthReturn | Promise<AuthReturn>, handleAuthFail?: (error: AgentAuthFailure) => AuthFailReturn | Promise<AuthFailReturn>) => Promise<Response | AuthReturn | NonNullable<Awaited<AuthFailReturn>>>;
+    }>;
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: {
+                    resource: string;
+                    scopes_supported: string[];
+                    resource_name?: string | undefined;
+                    resource_logo_uri?: string | undefined;
+                    authorization_servers: string[];
+                    bearer_methods_supported: string[];
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
 }>;
-export {};