@kya-os/mcp-i/dist/runtime/delegation-hooks.d.ts

The TypeScript MCP framework with identity features built-in

import { ProofMeta } from "@kya-os/contracts/proof";
import { DelegationManager } from "../storage/delegation";
/**
 * Runtime hooks for delegation support
 */
export interface DelegationHooks {
    /**
     * Called before proof generation to attach delegation context
     */
    beforeProof?: (meta: Partial<ProofMeta>) => Promise<Partial<ProofMeta>>;
    /**
     * Called after proof generation to validate delegation
     */
    afterProof?: (meta: ProofMeta) => Promise<void>;
    /**
     * Called to resolve delegation reference for a request
     */
    resolveDelegation?: (context: RequestContext) => Promise<string | undefined>;
}
export interface RequestContext {
    audience: string;
    scopes?: string[];
    sessionId: string;
    did: string;
    kid: string;
}
/**
 * Default delegation hooks implementation
 */
export declare class DefaultDelegationHooks implements DelegationHooks {
    private delegationManager;
    private options;
    constructor(delegationManager: DelegationManager, options?: DelegationHookOptions);
    beforeProof(meta: Partial<ProofMeta>): Promise<Partial<ProofMeta>>;
    afterProof(meta: ProofMeta): Promise<void>;
    resolveDelegation(_context: RequestContext): Promise<string | undefined>;
}
export interface DelegationHookOptions {
    /**
     * Automatically resolve delegation references for requests
     */
    autoResolveDelegation?: boolean;
    /**
     * Require delegation for all requests
     */
    requireDelegation?: boolean;
    /**
     * Default delegation duration in seconds
     */
    defaultDuration?: number;
}
/**
 * Create delegation hooks instance
 */
export declare function createDelegationHooks(delegationManager: DelegationManager, options?: DelegationHookOptions): DelegationHooks;
/**
 * Delegation middleware for runtime integration
 */
export declare class DelegationMiddleware {
    private hooks;
    private options;
    constructor(hooks: DelegationHooks, options?: DelegationMiddlewareOptions);
    /**
     * Process request and attach delegation context
     */
    processRequest(meta: Partial<ProofMeta>, context: RequestContext): Promise<Partial<ProofMeta>>;
    /**
     * Validate proof after generation
     */
    validateProof(meta: ProofMeta): Promise<void>;
}
export interface DelegationMiddlewareOptions {
    /**
     * Require delegation for all requests
     */
    requireDelegation?: boolean;
    /**
     * Skip delegation validation in test mode
     */
    skipValidationInTest?: boolean;
}
/**
 * Create delegation middleware instance
 */
export declare function createDelegationMiddleware(hooks: DelegationHooks, options?: DelegationMiddlewareOptions): DelegationMiddleware;