toolcraft 0.0.125 → 0.0.127

package/composition.json

@@ -76,6 +76,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
+    {
+      "name": "mcp-oauth-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -103,7 +108,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.125",
+      "version": "0.0.127",
       "license": "MIT"
     },
     {
@@ -113,7 +118,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.125",
+      "version": "0.0.127",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -76,6 +76,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
+    {
+      "name": "mcp-oauth-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -103,7 +108,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.125",
+      "version": "0.0.127",
       "license": "MIT"
     },
     {
@@ -113,7 +118,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.125",
+      "version": "0.0.127",
       "license": "MIT"
     },
     {

package/dist/http.d.ts

@@ -1,6 +1,7 @@
 import "./node-require-shim.js";
 import { type HttpListenOptions, type HttpServer, type HttpServerHandle, type HttpToolContext, type HttpTransportOptions } from "tiny-http-mcp-server/server";
 import type { Group } from "./index.js";
+import type { OAuthAuthorizationServer } from "mcp-oauth-server";
 import { type RunMCPOptions } from "./mcp.js";
 export type ToolcraftHTTPContext = HttpToolContext;
 export type ToolcraftHTTPServer = HttpServer;
@@ -13,7 +14,16 @@ export interface RunHTTPMCPOptions<TServices extends object = Record<string, unk
     path?: string;
     requestServices?(context: ToolcraftHTTPContext): Partial<TServices> | Promise<Partial<TServices>>;
 }
+export interface HTTPMCPAuthorizationOptions {
+    authorizationServer: Pick<OAuthAuthorizationServer, "issuer" | "verifyAccessToken">;
+    resource: string;
+    requiredScopes?: readonly string[];
+    scopesSupported?: readonly string[];
+}
+export declare function createHTTPMCPAuthorization(options: HTTPMCPAuthorizationOptions): import("tiny-http-mcp-server/server").TinyHttpMcpServerOAuthOptions;
 export declare function createHTTPMCPServer<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunHTTPMCPOptions<TServices>): Promise<ToolcraftHTTPServer>;
 export declare function runHTTPMCP<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunHTTPMCPOptions<TServices>): Promise<ToolcraftHTTPServerHandle>;
 export type { HttpListenOptions, HttpObservabilityEvent, HttpObservabilityOptions, RequestAuthInfo, Session, SessionStore, StreamableHttpTransportOptions, TinyHttpMcpServerOAuthOptions, TokenVerifier, VerifiedAccessToken } from "tiny-http-mcp-server/server";
 export { createJwksTokenVerifier, TokenVerificationError } from "tiny-http-mcp-server/server";
+export { createAuthorizationInteractionSecurity, createInMemoryAuthorizationServerStore, createOAuthAuthorizationServer, verifyAuthorizationInteractionCsrf } from "mcp-oauth-server";
+export type { AuthorizationInteraction, AuthorizationInteractionSecurity, AuthorizationServerStore, OAuthAuthorizationServer, OAuthAuthorizationServerOptions, VerifiedAuthorizationServerToken } from "mcp-oauth-server";

package/dist/http.js

@@ -2,6 +2,45 @@ import "./node-require-shim.js";
 import { createHttpServer } from "tiny-http-mcp-server/server";
 import { createMCPServerForTransport } from "./mcp.js";
 import { enableSourceMaps } from "./stack-trim.js";
+function toVerifiedAccessToken(token, issuer, verified) {
+    return {
+        token,
+        issuer,
+        audience: [verified.resource],
+        scopes: [...verified.scopes],
+        expiresAt: verified.expiresAt,
+        claims: {
+            sub: verified.subject,
+            client_id: verified.clientId,
+            aud: verified.resource,
+            jti: verified.tokenId
+        },
+        subject: verified.subject,
+        clientId: verified.clientId
+    };
+}
+export function createHTTPMCPAuthorization(options) {
+    const issuer = options.authorizationServer.issuer;
+    const resource = new URL(options.resource).href;
+    return {
+        resource,
+        authorizationServers: [issuer],
+        requiredScopes: options.requiredScopes,
+        scopesSupported: options.scopesSupported ?? options.requiredScopes,
+        verifier: {
+            async verify(input) {
+                if (input.authorizationServers.length !== 1 || input.authorizationServers[0] !== issuer) {
+                    throw new Error("authorization server issuer does not match");
+                }
+                if (new URL(input.resource).href !== resource) {
+                    throw new Error("protected resource does not match");
+                }
+                const verified = await options.authorizationServer.verifyAccessToken(input.token, resource);
+                return toVerifiedAccessToken(input.token, issuer, verified);
+            }
+        }
+    };
+}
 function createTransportOptions(options, serverOptions) {
     return {
         ...serverOptions,
@@ -60,3 +99,4 @@ export async function runHTTPMCP(roots, options) {
     return server.listenHttp(createListenOptions(options));
 }
 export { createJwksTokenVerifier, TokenVerificationError } from "tiny-http-mcp-server/server";
+export { createAuthorizationInteractionSecurity, createInMemoryAuthorizationServerStore, createOAuthAuthorizationServer, verifyAuthorizationInteractionCsrf } from "mcp-oauth-server";

package/node_modules/@poe-code/agent-defs/README.md

@@ -23,7 +23,7 @@ const codex = allAgents.find((agent) => agent.id === "codex");
 - `parseAgentSpecifier(input)`: parses `agent` or `agent:model` input.
 - `formatAgentSpecifier(specifier)`: formats an agent specifier.
 - `normalizeAgentId(input)`: normalizes the agent part through the registry.
-- Agent definition exports such as `codexAgent`, `claudeCodeAgent`, and `geminiCliAgent`.
+- Agent definition exports such as `codexAgent`, `claudeCodeAgent`, `geminiCliAgent`, and `piAgent`.
 
 ## Config Options
 

package/node_modules/@poe-code/agent-defs/dist/agents/index.d.ts

@@ -6,4 +6,5 @@ export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
 export { kimiAgent } from "./kimi.js";
 export { gooseAgent } from "./goose.js";
+export { piAgent } from "./pi.js";
 export { poeAgentAgent } from "./poe-agent.js";

package/node_modules/@poe-code/agent-defs/dist/agents/index.js

@@ -6,4 +6,5 @@ export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
 export { kimiAgent } from "./kimi.js";
 export { gooseAgent } from "./goose.js";
+export { piAgent } from "./pi.js";
 export { poeAgentAgent } from "./poe-agent.js";

package/node_modules/@poe-code/agent-defs/dist/agents/pi.d.ts

@@ -0,0 +1,2 @@
+import type { AgentDefinition } from "../types.js";
+export declare const piAgent: AgentDefinition;

package/node_modules/@poe-code/agent-defs/dist/agents/pi.js

@@ -0,0 +1,14 @@
+export const piAgent = {
+    id: "pi",
+    name: "pi",
+    aliases: ["pi-agent"],
+    label: "Pi",
+    summary: "Pi coding agent (spawn-only; uses local Pi auth/settings).",
+    binaryName: "pi",
+    branding: {
+        colors: {
+            dark: "#F2F2F2",
+            light: "#242424"
+        }
+    }
+};

package/node_modules/@poe-code/agent-defs/dist/index.d.ts

@@ -1,5 +1,5 @@
 export type { AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
 export type { AgentSpecifier } from "./specifier.js";
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/index.js

@@ -1,3 +1,3 @@
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/@poe-code/agent-defs/dist/registry.js

@@ -1,4 +1,4 @@
-import { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+import { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 function freezeAgent(agent) {
     if (agent.aliases !== undefined) {
         Object.freeze(agent.aliases);
@@ -25,6 +25,7 @@ export const allAgents = Object.freeze([
     freezeAgent(openCodeAgent),
     freezeAgent(kimiAgent),
     freezeAgent(gooseAgent),
+    freezeAgent(piAgent),
     freezeAgent(poeAgentAgent)
 ]);
 const lookup = new Map();

package/node_modules/@poe-code/agent-defs/dist/types.d.ts

@@ -13,7 +13,7 @@ export interface AgentDefinition {
     binaryName?: string;
     readonly apiShapes?: readonly ApiShapeId[];
     readonly otelCapture?: OtelCaptureDefinition;
-    configPath: string;
+    configPath?: string;
     readonly configPaths?: {
         readonly darwin: string;
         readonly linux: string;

package/node_modules/mcp-oauth-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/mcp-oauth-server/README.md

@@ -0,0 +1,192 @@
+# mcp-oauth-server
+
+Production OAuth 2.1 authorization-server primitives for MCP applications.
+
+The package provides:
+
+- authorization code with mandatory PKCE `S256`
+- RFC 8414 authorization-server metadata
+- RFC 7591 dynamic registration for public MCP clients
+- exact registered redirect URI validation
+- RFC 8707 resource indicators and audience-bound JWT access tokens
+- JWKS publication and short-lived `at+jwt` access tokens
+- rotating refresh tokens with replay-triggered family revocation
+- token and grant revocation
+- asynchronous durable storage interfaces
+- an application-owned browser authorization interaction
+- CSRF, state, nonce, and secure cookie helpers
+- a Toolcraft adapter through `createHTTPMCPAuthorization()` from `toolcraft/http`
+
+## Availability
+
+This package is bundled privately inside the published `toolcraft` package and
+is supported through the `toolcraft/http` exports. It is not published as a
+standalone npm package because that npm package name is owned outside this
+repository.
+
+## Quick Start
+
+```ts
+import { generateKeyPairSync } from "node:crypto";
+import { exportJWK } from "jose";
+import {
+  createHTTPMCPAuthorization,
+  createOAuthAuthorizationServer,
+  runHTTPMCP,
+  type AuthorizationInteraction,
+  type AuthorizationServerStore
+} from "toolcraft/http";
+
+const { privateKey, publicKey } = generateKeyPairSync("ec", {
+  namedCurve: "P-256"
+});
+
+const store: AuthorizationServerStore = createDurableStore();
+const interaction: AuthorizationInteraction = {
+  async start({ transaction }) {
+    return renderApplicationAuthorizationPage(transaction);
+  }
+};
+
+const authorizationServer = createOAuthAuthorizationServer({
+  issuer: "https://auth.example.com",
+  resources: ["https://mcp.example.com/mcp"],
+  signingKey: {
+    algorithm: "ES256",
+    keyId: "2026-07",
+    privateKey,
+    publicJwk: await exportJWK(publicKey)
+  },
+  store,
+  interaction
+});
+
+await runHTTPMCP(groups, {
+  oauth: createHTTPMCPAuthorization({
+    authorizationServer,
+    resource: "https://mcp.example.com/mcp",
+    requiredScopes: ["mcp.read"]
+  }),
+  requestServices(context) {
+    if (context.auth === undefined) throw new Error("OAuth subject required");
+    return {
+      babyDaybook: loadBabyDaybookSession(context.auth.subject)
+    };
+  }
+});
+```
+
+Route requests for `/.well-known/oauth-authorization-server`,
+`/.well-known/jwks.json`, `/register`, `/authorize`, `/token`, and `/revoke`
+to `authorizationServer.handle(request)` in the application HTTP framework.
+
+## Application Authorization Interaction
+
+`interaction.start({ request, transaction })` owns the browser experience. It
+may render a login page, redirect to an upstream identity provider, or render a
+one-time credential completion form. The application finishes the OAuth flow
+only after authenticating its user:
+
+```ts
+const completion = await authorizationServer.completeAuthorization({
+  transactionId,
+  subject: applicationUserId,
+  scopes: approvedScopes
+});
+
+return Response.redirect(completion.redirectUrl);
+```
+
+For an Apple `intent://callback?...` completion flow:
+
+1. Generate the application CSRF token, upstream state, and nonce with
+   `createAuthorizationInteractionSecurity()`.
+2. Bind the upstream state to the pending authorization transaction in the
+   application's durable store.
+3. Render the callback paste form with the hidden CSRF token and returned
+   `Set-Cookie` value.
+4. On submission, bound the request body, verify CSRF with
+   `verifyAuthorizationInteractionCsrf()`, validate the exact intent callback
+   shape and state, and consume the application transaction once.
+5. Exchange the one-time callback immediately. Never log or persist the
+   callback, password, authorization code, access token, or refresh token in
+   plaintext.
+6. Persist only the encrypted upstream refresh session under the approved OAuth
+   subject, then call `completeAuthorization()`.
+
+The application credential is deliberately absent from all package APIs so it
+cannot accidentally enter OAuth transaction or token storage.
+
+## Durable Storage
+
+Production deployments must implement `AuthorizationServerStore`. The
+interface covers:
+
+- dynamic clients
+- browser authorization transactions
+- authorization grants
+- one-time authorization codes
+- access-token revocation records
+- refresh-token families
+
+`takeAuthorizationTransaction()`, `takeAuthorizationCode()`, and
+`rotateRefreshToken()` must be atomic. Refresh replay detection depends on the
+store retaining rotated token-family relationships and revoking the family
+when an old token is presented again.
+
+`createInMemoryAuthorizationServerStore()` is intended for tests and local
+development only. It is not durable and must not be used in production.
+
+## Subject Isolation
+
+The access token `sub` claim is the only identity passed to Toolcraft as
+`context.auth.subject`. Application service lookup must require that subject
+and load only credentials stored under the same subject. Do not fall back to a
+shared environment credential when a subject session is missing.
+
+Grant and token revocation use opaque identifiers and token hashes. Raw
+authorization codes, access tokens, and refresh tokens are never stored by the
+provided store contract.
+
+## Security Requirements
+
+- Terminate TLS before exposing any endpoint publicly.
+- Keep signing private keys outside source control and rotate keys with an
+  overlap period long enough for issued access tokens to expire.
+- Use a durable store implementation with transactional or compare-and-swap
+  semantics for one-time consumption and refresh rotation.
+- Keep access-token lifetimes short. The default is five minutes.
+- Set restrictive CSP, `Referrer-Policy: no-referrer`, and `Cache-Control:
+  no-store` on application authorization pages.
+- Require exact redirect URI matches. Do not add wildcard or prefix matching.
+- Treat every OAuth subject as a separate security boundary.
+- Encrypt application-owned upstream refresh tokens at rest with a
+  production key-management service.
+- Redact authorization headers, cookies, codes, callbacks, and tokens from
+  logs and traces.
+
+## Configuration
+
+`createOAuthAuthorizationServer(options)` accepts:
+
+| Option | Required | Default | Description |
+| --- | --- | --- | --- |
+| `issuer` | yes | none | HTTPS authorization-server issuer. Loopback HTTP is allowed for local development. |
+| `resources` | yes | none | Exact protected resource identifiers accepted through the OAuth `resource` parameter. |
+| `signingKey` | yes | none | Current `ES256` or `RS256` private key, public JWK, and key id. |
+| `additionalPublicJwks` | no | `[]` | Previous public signing keys retained in JWKS during a key-rotation overlap. |
+| `store` | yes | none | Durable `AuthorizationServerStore` implementation. |
+| `interaction` | yes | none | Application-owned browser authorization hook. |
+| `accessTokenTtlSeconds` | no | `300` | Signed access-token lifetime. |
+| `authorizationCodeTtlSeconds` | no | `60` | One-time authorization-code lifetime. |
+| `authorizationTransactionTtlSeconds` | no | `600` | Pending browser interaction lifetime. |
+| `refreshTokenTtlSeconds` | no | `2592000` | Rotating refresh-token lifetime. |
+| `maxRequestBodyBytes` | no | `65536` | Maximum DCR, token, and revocation request body size. |
+| `now` | no | `Date.now` | Clock override for tests. |
+| `randomToken` | no | cryptographic random | Opaque identifier generator override for tests. |
+
+## Environment Variables
+
+This package reads no environment variables. Signing keys, durable database
+connections, encryption keys, issuer URLs, and protected resource identifiers
+must be passed explicitly by the application.

package/node_modules/mcp-oauth-server/dist/index.d.ts

@@ -0,0 +1,157 @@
+import { type KeyObject } from "node:crypto";
+import { type JWK } from "jose";
+export interface OAuthClientRecord {
+    id: string;
+    redirectUris: readonly string[];
+    createdAt: number;
+}
+export interface AuthorizationTransactionRecord {
+    id: string;
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    resource: string;
+    scopes: readonly string[];
+    state?: string;
+    createdAt: number;
+    expiresAt: number;
+}
+export interface AuthorizationCodeRecord {
+    tokenHash: string;
+    grantId: string;
+    clientId: string;
+    subject: string;
+    redirectUri: string;
+    codeChallenge: string;
+    resource: string;
+    scopes: readonly string[];
+    expiresAt: number;
+}
+export interface AuthorizationGrantRecord {
+    id: string;
+    clientId: string;
+    subject: string;
+    resource: string;
+    scopes: readonly string[];
+    createdAt: number;
+    revokedAt?: number;
+}
+export interface RefreshTokenRecord {
+    tokenHash: string;
+    familyId: string;
+    grantId: string;
+    clientId: string;
+    subject: string;
+    resource: string;
+    scopes: readonly string[];
+    createdAt: number;
+    expiresAt: number;
+    status: "active" | "rotated" | "revoked";
+}
+export interface AccessTokenRecord {
+    tokenHash: string;
+    tokenId: string;
+    grantId: string;
+    subject: string;
+    clientId: string;
+    resource: string;
+    expiresAt: number;
+    revokedAt?: number;
+}
+export type RefreshTokenRotationResult = {
+    status: "rotated";
+    previous: RefreshTokenRecord;
+} | {
+    status: "replay";
+} | {
+    status: "invalid";
+};
+export interface AuthorizationServerStore {
+    putClient(client: OAuthClientRecord): Promise<void>;
+    getClient(clientId: string): Promise<OAuthClientRecord | undefined>;
+    putAuthorizationTransaction(transaction: AuthorizationTransactionRecord): Promise<void>;
+    takeAuthorizationTransaction(transactionId: string): Promise<AuthorizationTransactionRecord | undefined>;
+    putAuthorizationCode(code: AuthorizationCodeRecord): Promise<void>;
+    takeAuthorizationCode(tokenHash: string): Promise<AuthorizationCodeRecord | undefined>;
+    putGrant(grant: AuthorizationGrantRecord): Promise<void>;
+    getGrant(grantId: string): Promise<AuthorizationGrantRecord | undefined>;
+    putAccessToken(token: AccessTokenRecord): Promise<void>;
+    getAccessToken(tokenHash: string): Promise<AccessTokenRecord | undefined>;
+    putRefreshToken(token: RefreshTokenRecord): Promise<void>;
+    rotateRefreshToken(tokenHash: string, replacementTokenHash: string, now: number, expiresAt: number): Promise<RefreshTokenRotationResult>;
+    revokeToken(tokenHash: string, now: number): Promise<void>;
+    revokeGrant(grantId: string, now: number): Promise<void>;
+}
+export interface AuthorizationInteractionStartContext {
+    request: Request;
+    transaction: AuthorizationTransactionRecord;
+}
+export interface AuthorizationInteraction {
+    start(context: AuthorizationInteractionStartContext): Promise<Response> | Response;
+}
+export interface OAuthAuthorizationServerSigningKey {
+    algorithm: "ES256" | "RS256";
+    keyId: string;
+    privateKey: KeyObject;
+    publicJwk: JWK;
+}
+export interface OAuthAuthorizationServerOptions {
+    issuer: string;
+    resources: readonly string[];
+    signingKey: OAuthAuthorizationServerSigningKey;
+    additionalPublicJwks?: readonly JWK[];
+    store: AuthorizationServerStore;
+    interaction: AuthorizationInteraction;
+    accessTokenTtlSeconds?: number;
+    authorizationCodeTtlSeconds?: number;
+    authorizationTransactionTtlSeconds?: number;
+    refreshTokenTtlSeconds?: number;
+    maxRequestBodyBytes?: number;
+    now?: () => number;
+    randomToken?: () => string;
+}
+export interface CompleteAuthorizationInput {
+    transactionId: string;
+    subject: string;
+    scopes?: readonly string[];
+}
+export interface CompleteAuthorizationResult {
+    redirectUrl: URL;
+    grantId: string;
+}
+export interface AuthorizationInteractionSecurity {
+    csrfToken: string;
+    state: string;
+    nonce: string;
+    setCookie: string;
+}
+export interface AuthorizationInteractionSecurityOptions {
+    cookieName?: string;
+    maxAgeSeconds?: number;
+    randomToken?: () => string;
+}
+export interface VerifyAuthorizationInteractionCsrfInput {
+    cookieHeader: string | null;
+    submittedToken: string;
+    cookieName?: string;
+}
+export interface OAuthAuthorizationServer {
+    issuer: string;
+    handle(request: Request): Promise<Response>;
+    completeAuthorization(input: CompleteAuthorizationInput): Promise<CompleteAuthorizationResult>;
+    denyAuthorization(transactionId: string, error?: string): Promise<URL>;
+    revokeGrant(grantId: string): Promise<void>;
+    verifyAccessToken(token: string, resource: string): Promise<VerifiedAuthorizationServerToken>;
+}
+export interface VerifiedAuthorizationServerToken {
+    subject: string;
+    clientId: string;
+    resource: string;
+    scopes: readonly string[];
+    tokenId: string;
+    expiresAt: number;
+}
+export declare function createAuthorizationInteractionSecurity(options?: AuthorizationInteractionSecurityOptions): AuthorizationInteractionSecurity;
+export declare function verifyAuthorizationInteractionCsrf(input: VerifyAuthorizationInteractionCsrfInput): boolean;
+export declare function createInMemoryAuthorizationServerStore(): AuthorizationServerStore;
+export declare function createOAuthAuthorizationServer(options: OAuthAuthorizationServerOptions): OAuthAuthorizationServer;