kontext-sdk 0.3.1 → 0.5.0

package/dist/index.d.mts

@@ -102,109 +102,6 @@ declare class JsonFileExporter implements EventExporter {
     /** Get the output directory path. */
     getOutputDir(): string;
 }
-/**
- * Generic HTTP exporter that sends batched events to any HTTP endpoint.
- * Events are buffered and sent in configurable batch sizes.
- *
- * @example
- * ```typescript
- * const kontext = Kontext.init({
- *   projectId: 'my-project',
- *   environment: 'production',
- *   exporter: new HttpExporter({
- *     endpoint: 'https://my-analytics.example.com/v1/events',
- *     headers: { 'Authorization': 'Bearer my-token' },
- *   }),
- * });
- * ```
- */
-declare class HttpExporter implements EventExporter {
-    private readonly endpoint;
-    private readonly headers;
-    private readonly batchSize;
-    private readonly timeoutMs;
-    private buffer;
-    constructor(options: {
-        endpoint: string;
-        headers?: Record<string, string>;
-        batchSize?: number;
-        timeoutMs?: number;
-    });
-    export(events: ActionLog[]): Promise<ExporterResult>;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-/**
- * Cloud exporter for Pro and Enterprise plans.
- * Ships events to the Kontext Cloud API (api.getkontext.com) with automatic
- * batching, retry, and GENIUS Act-compliant retention.
- *
- * Events sent via this exporter are stored in Kontext's GCP infrastructure
- * with configurable retention policies aligned with regulatory requirements:
- * - 5-year default retention (BSA/AML)
- * - WORM-compatible immutable storage (SEC 17a-4 / CFTC 1.31)
- * - US-based data residency (GCP us-central1)
- * - AES-256 encryption at rest, TLS 1.3 in transit
- *
- * @example
- * ```typescript
- * const kontext = Kontext.init({
- *   apiKey: 'sk_live_...',
- *   projectId: 'my-project',
- *   environment: 'production',
- *   plan: 'pro',
- *   exporter: new KontextCloudExporter({
- *     apiKey: 'sk_live_...',
- *     projectId: 'my-project',
- *   }),
- * });
- * ```
- */
-declare class KontextCloudExporter implements EventExporter {
-    private readonly apiKey;
-    private readonly projectId;
-    private readonly apiUrl;
-    private readonly batchSize;
-    private readonly timeoutMs;
-    private readonly retryAttempts;
-    private readonly retryDelayMs;
-    private buffer;
-    constructor(options: {
-        apiKey: string;
-        projectId: string;
-        apiUrl?: string;
-        batchSize?: number;
-        timeoutMs?: number;
-        retryAttempts?: number;
-        retryDelayMs?: number;
-    });
-    export(events: ActionLog[]): Promise<ExporterResult>;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
-/**
- * Composite exporter that fans out events to multiple exporters.
- * Useful for sending events to both local files and cloud simultaneously.
- *
- * @example
- * ```typescript
- * const kontext = Kontext.init({
- *   projectId: 'my-project',
- *   environment: 'production',
- *   exporter: new MultiExporter([
- *     new JsonFileExporter({ outputDir: './backup' }),
- *     new KontextCloudExporter({ apiKey: 'sk_live_...', projectId: 'my-project' }),
- *   ]),
- * });
- * ```
- */
-declare class MultiExporter implements EventExporter {
-    private readonly exporters;
-    constructor(exporters: EventExporter[]);
-    export(events: ActionLog[]): Promise<ExporterResult>;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-}
 
 /**
  * Interface for pluggable storage backends.
@@ -295,7 +192,7 @@ type TaskStatus = 'pending' | 'in_progress' | 'confirmed' | 'failed' | 'expired'
 /** Supported export formats */
 type ExportFormat = 'json' | 'csv';
 /** Report types */
-type ReportType = 'compliance' | 'transaction' | 'anomaly' | 'sar' | 'ctr';
+type ReportType = 'compliance' | 'transaction' | 'anomaly';
 /** Anomaly detection rule types */
 type AnomalyRuleType = 'unusualAmount' | 'frequencySpike' | 'newDestination' | 'offHoursActivity' | 'rapidSuccession' | 'roundAmount';
 /** SDK initialization configuration */
@@ -320,6 +217,19 @@ interface KontextConfig {
     logLevel?: 'debug' | 'info' | 'warn' | 'error';
     /** Pluggable storage adapter for persistence (default: in-memory) */
     storage?: StorageAdapter;
+    /**
+     * Anomaly detection rules to enable at init time.
+     * When provided, anomaly detection is automatically enabled and every
+     * verify() call includes anomaly results in its response.
+     *
+     * Free-tier rules: `unusualAmount`, `frequencySpike`
+     * Pay as you go rules: `newDestination`, `offHoursActivity`, `rapidSuccession`, `roundAmount`
+     */
+    anomalyRules?: AnomalyRuleType[];
+    /**
+     * Thresholds for anomaly detection. Only used when `anomalyRules` is set.
+     */
+    anomalyThresholds?: AnomalyThresholds;
     /**
      * Pluggable event exporter for shipping events to external systems.
      * Follows the OpenTelemetry exporter pattern.
@@ -328,9 +238,6 @@ interface KontextConfig {
      * - `NoopExporter` (default) — discards events, current SDK behavior
      * - `ConsoleExporter` — prints events to stdout
      * - `JsonFileExporter` — writes JSONL files to disk
-     * - `HttpExporter` — sends batched events to any HTTP endpoint
-     * - `KontextCloudExporter` — ships to Kontext Cloud (Pro/Enterprise)
-     * - `MultiExporter` — fans out to multiple exporters
      *
      * @example
      * ```typescript
@@ -389,11 +296,34 @@ interface KontextConfig {
      */
     featureFlags?: FeatureFlagConfig;
     /**
-     * Approval policies for human-in-the-loop review. When provided, the SDK
-     * initializes an `ApprovalManager` that evaluates actions against these
-     * policies and blocks execution until a human decides.
+     * User / tenant identifier for storage isolation.
+     * Required when using FirestoreStorageAdapter. Logs for each userId
+     * are stored under separate Firestore paths:
+     * users/{userId}/projects/{projectId}/...
+     *
+     * Use a stable, opaque identifier: your auth system's user ID,
+     * a Stripe customer ID, or a hash of the API key.
+     */
+    userId?: string;
+    /**
+     * When set, verify() auto-creates a pending task if the transaction
+     * amount exceeds this threshold (string, to preserve decimal precision).
+     * The task is returned in `result.task` and `result.requiresApproval`
+     * is set to `true`. Your agent should wait for confirmTask() before
+     * executing the transfer.
+     *
+     * Free tier feature — works with createTask() / confirmTask().
+     *
+     * @example
+     * ```typescript
+     * const ctx = Kontext.init({
+     *   projectId: 'my-agent',
+     *   environment: 'production',
+     *   approvalThreshold: '3000', // auto-task above $3K
+     * });
+     * ```
      */
-    approvalPolicies?: ApprovalPolicy[];
+    approvalThreshold?: string;
 }
 /**
  * Interface for metadata validation. Compatible with Zod schemas and any
@@ -413,6 +343,8 @@ interface ActionLog {
     projectId: string;
     /** ID of the agent performing the action */
     agentId: string;
+    /** Session ID grouping all steps in one agent run */
+    sessionId?: string;
     /** Correlation ID for tracing related actions */
     correlationId: string;
     /** Type of action */
@@ -434,6 +366,8 @@ interface LogActionInput {
     description: string;
     /** ID of the agent performing the action */
     agentId: string;
+    /** Optional session ID grouping all steps in a single agent run */
+    sessionId?: string;
     /** Optional correlation ID (auto-generated if not provided) */
     correlationId?: string;
     /** Arbitrary metadata */
@@ -455,6 +389,8 @@ interface LogTransactionInput {
     to: string;
     /** ID of the agent initiating the transaction */
     agentId: string;
+    /** Optional session ID grouping all steps in a single agent run */
+    sessionId?: string;
     /** Optional correlation ID */
     correlationId?: string;
     /** Additional transaction metadata */
@@ -609,87 +545,47 @@ interface ExportResult {
     /** Terminal digest of the chain at time of export */
     terminalDigest?: string;
 }
-/** Subject information for SAR/CTR reports */
-interface ReportSubject {
-    /** Subject name or identifier */
-    name: string;
-    /** Agent ID (if applicable) */
-    agentId?: string;
-    /** Wallet addresses associated with the subject */
-    addresses: string[];
-    /** Additional identifying information */
-    identifiers?: Record<string, string>;
-}
-/** Suspicious Activity Report template */
-interface SARReport {
-    /** Report ID */
+/** Detected anomaly event */
+interface AnomalyEvent {
+    /** Unique anomaly ID */
     id: string;
-    /** Report type discriminator */
-    type: 'sar';
-    /** Generation timestamp */
-    generatedAt: string;
-    /** Reporting period */
-    period: DateRange;
-    /** Project ID */
-    projectId: string;
-    /** Filing institution information */
-    filingInstitution: string;
-    /** Subject(s) of the report */
-    subjects: ReportSubject[];
-    /** Narrative summary of suspicious activity */
-    narrative: string;
-    /** Suspicious activity categories */
-    activityCategories: string[];
-    /** Total amount involved */
-    totalAmount: string;
-    /** Currency/token */
-    currency: string;
-    /** Transactions flagged as suspicious */
-    suspiciousTransactions: TransactionRecord[];
-    /** Related anomalies */
-    anomalies: AnomalyEvent[];
-    /** Supporting action logs */
-    supportingActions: ActionLog[];
-    /** Whether this is a continuing activity report */
-    isContinuingActivity: boolean;
-    /** Prior report ID if continuing */
-    priorReportId: string | null;
-    /** Status of the report */
-    status: 'draft' | 'review' | 'filed';
+    /** Anomaly type/rule that triggered */
+    type: AnomalyRuleType;
+    /** Severity level */
+    severity: AnomalySeverity;
+    /** Human-readable description */
+    description: string;
+    /** ID of the agent involved */
+    agentId: string;
+    /** Related action log ID */
+    actionId: string;
+    /** Detection timestamp */
+    detectedAt: string;
+    /** Related data */
+    data: Record<string, unknown>;
+    /** Whether the anomaly has been reviewed */
+    reviewed: boolean;
 }
-/** Currency Transaction Report template */
-interface CTRReport {
-    /** Report ID */
-    id: string;
-    /** Report type discriminator */
-    type: 'ctr';
-    /** Generation timestamp */
-    generatedAt: string;
-    /** Reporting period */
-    period: DateRange;
-    /** Project ID */
-    projectId: string;
-    /** Filing institution information */
-    filingInstitution: string;
-    /** Person/entity conducting the transactions */
-    conductors: ReportSubject[];
-    /** Transactions included in the report */
-    transactions: TransactionRecord[];
-    /** Total cash-in amount */
-    totalCashIn: string;
-    /** Total cash-out amount */
-    totalCashOut: string;
-    /** Currency/token */
-    currency: string;
-    /** Whether multiple transactions are aggregated */
-    isAggregated: boolean;
-    /** Chains involved */
-    chainsInvolved: Chain[];
-    /** Supporting action logs */
-    supportingActions: ActionLog[];
-    /** Status of the report */
-    status: 'draft' | 'review' | 'filed';
+/** Anomaly detection configuration */
+interface AnomalyDetectionConfig {
+    /** Detection rules to enable */
+    rules: AnomalyRuleType[];
+    /** Thresholds for detection */
+    thresholds?: AnomalyThresholds;
+}
+/** Configurable anomaly thresholds */
+interface AnomalyThresholds {
+    /** Maximum transaction amount before flagging */
+    maxAmount?: string;
+    /** Maximum transactions per hour */
+    maxFrequency?: number;
+    /** Hours considered "off-hours" (24h format, e.g., [22, 23, 0, 1, 2, 3, 4, 5]) */
+    offHours?: number[];
+    /** Minimum seconds between transactions before "rapid succession" flag */
+    minIntervalSeconds?: number;
 }
+/** Anomaly event callback */
+type AnomalyCallback = (anomaly: AnomalyEvent) => void;
 /** Trust score result for an agent */
 interface TrustScore {
     /** Agent ID */
@@ -740,99 +636,6 @@ interface RiskFactor {
     /** Human-readable description */
     description: string;
 }
-/** Anomaly detection configuration */
-interface AnomalyDetectionConfig {
-    /** Detection rules to enable */
-    rules: AnomalyRuleType[];
-    /** Thresholds for detection */
-    thresholds?: AnomalyThresholds;
-}
-/** Configurable anomaly thresholds */
-interface AnomalyThresholds {
-    /** Maximum transaction amount before flagging */
-    maxAmount?: string;
-    /** Maximum transactions per hour */
-    maxFrequency?: number;
-    /** Hours considered "off-hours" (24h format, e.g., [22, 23, 0, 1, 2, 3, 4, 5]) */
-    offHours?: number[];
-    /** Minimum seconds between transactions before "rapid succession" flag */
-    minIntervalSeconds?: number;
-}
-/** Detected anomaly event */
-interface AnomalyEvent {
-    /** Unique anomaly ID */
-    id: string;
-    /** Anomaly type/rule that triggered */
-    type: AnomalyRuleType;
-    /** Severity level */
-    severity: AnomalySeverity;
-    /** Human-readable description */
-    description: string;
-    /** ID of the agent involved */
-    agentId: string;
-    /** Related action log ID */
-    actionId: string;
-    /** Detection timestamp */
-    detectedAt: string;
-    /** Related data */
-    data: Record<string, unknown>;
-    /** Whether the anomaly has been reviewed */
-    reviewed: boolean;
-}
-/** Anomaly event callback */
-type AnomalyCallback = (anomaly: AnomalyEvent) => void;
-/** USDC compliance check result */
-interface UsdcComplianceCheck {
-    /** Whether the transaction is compliant */
-    compliant: boolean;
-    /** List of compliance checks performed */
-    checks: ComplianceCheckResult[];
-    /** Overall risk level */
-    riskLevel: 'low' | 'medium' | 'high' | 'critical';
-    /** Recommendations */
-    recommendations: string[];
-}
-/** Individual compliance check result */
-interface ComplianceCheckResult {
-    /** Check name */
-    name: string;
-    /** Whether the check passed */
-    passed: boolean;
-    /** Human-readable description */
-    description: string;
-    /** Severity if failed */
-    severity: AnomalySeverity;
-}
-/** Input for logging agent reasoning */
-interface LogReasoningInput {
-    /** ID of the agent making the decision */
-    agentId: string;
-    /** What action was taken or is being considered */
-    action: string;
-    /** The agent's reasoning/justification */
-    reasoning: string;
-    /** Optional confidence score (0-1) */
-    confidence?: number;
-    /** Optional additional context */
-    context?: Record<string, unknown>;
-}
-/** A reasoning entry stored in the action log */
-interface ReasoningEntry {
-    /** Unique reasoning entry identifier */
-    id: string;
-    /** Timestamp of the reasoning entry */
-    timestamp: string;
-    /** ID of the agent making the decision */
-    agentId: string;
-    /** What action was taken or is being considered */
-    action: string;
-    /** The agent's reasoning/justification */
-    reasoning: string;
-    /** Confidence score (0-1), defaults to 1.0 */
-    confidence: number;
-    /** Additional context */
-    context: Record<string, unknown>;
-}
 /** Input for generating a compliance certificate */
 interface GenerateComplianceCertificateInput {
     /** ID of the agent to generate the certificate for */
@@ -880,6 +683,28 @@ interface ComplianceCertificate {
     /** SHA-256 hash of the certificate content for integrity verification */
     contentHash: string;
 }
+/** USDC compliance check result */
+interface UsdcComplianceCheck {
+    /** Whether the transaction is compliant */
+    compliant: boolean;
+    /** List of compliance checks performed */
+    checks: ComplianceCheckResult[];
+    /** Overall risk level */
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    /** Recommendations */
+    recommendations: string[];
+}
+/** Individual compliance check result */
+interface ComplianceCheckResult {
+    /** Check name */
+    name: string;
+    /** Whether the check passed */
+    passed: boolean;
+    /** Human-readable description */
+    description: string;
+    /** Severity if failed */
+    severity: AnomalySeverity;
+}
 /** Scope of a feature flag */
 type FlagScope = 'sdk' | 'server' | 'website' | 'all';
 /** Plan-based targeting for a single environment */
@@ -921,79 +746,105 @@ interface FeatureFlagConfig {
     /** Scope filter — only load flags matching this scope (or 'all') */
     scope?: FlagScope;
 }
-/** Types of approval policies that can trigger human review */
-type ApprovalPolicyType = 'amount-threshold' | 'low-trust-score' | 'anomaly-detected' | 'new-destination' | 'manual';
-/** Status of an approval request */
-type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
-/** Configurable policy that determines when human approval is required */
-interface ApprovalPolicy {
-    type: ApprovalPolicyType;
-    enabled: boolean;
-    params: Record<string, unknown>;
-    requiredEvidence?: string[];
-}
-/** A pending or resolved approval request */
-interface ApprovalRequest {
-    id: string;
-    actionId: string;
-    agentId: string;
-    status: ApprovalStatus;
-    triggeredPolicies: ApprovalPolicyType[];
-    riskAssessment: {
-        score: number;
-        factors: string[];
-    };
-    requiredEvidence: string[];
-    decision: ApprovalDecision | null;
-    createdAt: string;
-    expiresAt: string;
-    metadata: Record<string, unknown>;
-}
-/** Decision made by a human reviewer */
-interface ApprovalDecision {
-    decision: 'approve' | 'reject';
-    decidedBy: string;
-    reason: string;
-    evidence?: Record<string, unknown>;
-    conditions?: string[];
-    decidedAt: string;
+/** Input for the verify() convenience method */
+interface VerifyInput extends LogTransactionInput {
+    /** Agent reasoning for this transaction (logged into digest chain if provided) */
+    reasoning?: string;
+    /** Confidence level 0–1 for the reasoning */
+    confidence?: number;
+    /** Additional reasoning context */
+    context?: Record<string, unknown>;
 }
-/** Result of evaluating an action against approval policies */
-interface ApprovalEvaluation {
-    required: boolean;
-    requestId?: string;
-    triggeredPolicies: ApprovalPolicyType[];
-    riskAssessment: {
-        score: number;
-        factors: string[];
+/** Result of the verify() convenience method */
+interface VerifyResult {
+    /** Whether the transaction passed all compliance checks */
+    compliant: boolean;
+    /** Individual compliance check results */
+    checks: ComplianceCheckResult[];
+    /** Overall risk level */
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+    /** Recommended actions */
+    recommendations: string[];
+    /** The logged transaction record */
+    transaction: TransactionRecord;
+    /** Agent trust score (auto-computed when agentId is present) */
+    trustScore: TrustScore;
+    /** Anomalies detected for this transaction (empty if anomaly detection not configured) */
+    anomalies: AnomalyEvent[];
+    /** Digest chain proof at time of verification */
+    digestProof: {
+        terminalDigest: string;
+        chainLength: number;
+        valid: boolean;
     };
+    /** Reasoning entry ID (present when reasoning was provided in input) */
+    reasoningId?: string;
+    /** True when the transaction amount exceeds the approvalThreshold */
+    requiresApproval?: boolean;
+    /** The pending approval task (present when requiresApproval is true) */
+    task?: Task;
 }
-/** Input for evaluating whether an action requires approval */
-interface EvaluateApprovalInput {
-    actionId: string;
+/**
+ * Input for logging an agent's reasoning/decision step.
+ * Supports full trace reconstruction via sessionId + step sequencing.
+ */
+interface LogReasoningInput {
+    /** ID of the agent performing the reasoning */
     agentId: string;
-    amount?: string;
-    destination?: string;
-    trustScore?: number;
-    anomalies?: Array<{
-        type: string;
-        severity: string;
-    }>;
-    metadata?: Record<string, unknown>;
-}
-/** Input for submitting a human decision on an approval request */
-interface SubmitDecisionInput {
-    requestId: string;
-    decision: 'approve' | 'reject';
-    decidedBy: string;
-    reason: string;
-    evidence?: Record<string, unknown>;
-    conditions?: string[];
-}
-/** Error codes for Kontext SDK */
-declare enum KontextErrorCode {
-    INITIALIZATION_ERROR = "INITIALIZATION_ERROR",
-    VALIDATION_ERROR = "VALIDATION_ERROR",
+    /**
+     * Session ID grouping all steps in one agent run.
+     * Use Kontext.generateSessionId() or your framework's run ID
+     * (LangGraph thread_id, Vercel AI id, OpenAI run_id).
+     */
+    sessionId?: string;
+    /** Step number within the session (for ordering) */
+    step?: number;
+    /** Parent step number (links this step to a prior decision) */
+    parentStep?: number;
+    /** The action or decision being made (e.g., 'evaluate-transfer') */
+    action: string;
+    /** Natural language explanation of the reasoning */
+    reasoning: string;
+    /** Confidence level 0–1 */
+    confidence?: number;
+    /** Tool or method called as a result of this reasoning */
+    toolCall?: string;
+    /** Result returned by the tool call */
+    toolResult?: unknown;
+    /** Additional context */
+    context?: Record<string, unknown>;
+}
+/** A stored reasoning/decision entry in the audit trail */
+interface ReasoningEntry {
+    /** Unique entry ID */
+    id: string;
+    /** Timestamp */
+    timestamp: string;
+    /** Agent ID */
+    agentId: string;
+    /** Session ID */
+    sessionId?: string;
+    /** Step number */
+    step?: number;
+    /** Parent step */
+    parentStep?: number;
+    /** Action name */
+    action: string;
+    /** Reasoning text */
+    reasoning: string;
+    /** Confidence 0–1 */
+    confidence: number;
+    /** Tool called */
+    toolCall?: string;
+    /** Tool result */
+    toolResult?: unknown;
+    /** Context */
+    context: Record<string, unknown>;
+}
+/** Error codes for Kontext SDK */
+declare enum KontextErrorCode {
+    INITIALIZATION_ERROR = "INITIALIZATION_ERROR",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
     TASK_NOT_FOUND = "TASK_NOT_FOUND",
     TASK_ALREADY_CONFIRMED = "TASK_ALREADY_CONFIRMED",
     TASK_EXPIRED = "TASK_EXPIRED",
@@ -1417,13 +1268,12 @@ declare class Kontext {
     private readonly logger;
     private readonly taskManager;
     private readonly auditExporter;
-    private readonly trustScorer;
-    private readonly anomalyDetector;
     private readonly mode;
     private readonly planManager;
     private readonly exporter;
     private readonly featureFlagManager;
-    private approvalManager;
+    private readonly trustScorer;
+    private readonly anomalyDetector;
     private constructor();
     /**
      * Initialize the Kontext SDK.
@@ -1556,58 +1406,6 @@ declare class Kontext {
      * @returns Compliance report with summary and detailed records
      */
     generateReport(options: ReportOptions): Promise<ComplianceReport>;
-    /**
-     * Generate a Suspicious Activity Report (SAR) template.
-     *
-     * This produces a structured SAR template populated with data from the SDK.
-     * It is a template/structure, not an actual regulatory filing.
-     *
-     * @param options - Report configuration
-     * @returns SAR report template
-     */
-    generateSARReport(options: ReportOptions): Promise<SARReport>;
-    /**
-     * Generate a Currency Transaction Report (CTR) template.
-     *
-     * This produces a structured CTR template for transactions that meet or
-     * exceed reporting thresholds. It is a template/structure, not an actual
-     * regulatory filing.
-     *
-     * @param options - Report configuration
-     * @returns CTR report template
-     */
-    generateCTRReport(options: ReportOptions): Promise<CTRReport>;
-    /**
-     * Get the trust score for an agent.
-     *
-     * @param agentId - Agent identifier
-     * @returns Trust score with factor breakdown
-     */
-    getTrustScore(agentId: string): Promise<TrustScore>;
-    /**
-     * Evaluate the risk of a specific transaction.
-     *
-     * @param tx - Transaction to evaluate
-     * @returns Transaction evaluation with risk score and recommendation
-     */
-    evaluateTransaction(tx: LogTransactionInput): Promise<TransactionEvaluation>;
-    /**
-     * Enable anomaly detection with the specified rules and thresholds.
-     *
-     * @param config - Detection configuration
-     */
-    enableAnomalyDetection(config: AnomalyDetectionConfig): void;
-    /**
-     * Disable anomaly detection.
-     */
-    disableAnomalyDetection(): void;
-    /**
-     * Register a callback for anomaly events.
-     *
-     * @param callback - Function to call when an anomaly is detected
-     * @returns Unsubscribe function
-     */
-    onAnomaly(callback: AnomalyCallback): () => void;
     /**
      * Get the terminal digest — the latest SHA-256 hash in the rolling digest chain.
      * Embed this in outgoing messages as tamper-evident proof of the entire action history.
@@ -1640,6 +1438,65 @@ declare class Kontext {
      * @returns A copy of the action log array
      */
     getActions(): ActionLog[];
+    /**
+     * Generate a unique session ID for a single agent run.
+     * Pass this as `sessionId` to logReasoning(), log(), logTransaction(),
+     * and verify() calls within the same run to group them in the audit trail.
+     *
+     * Compatible with framework run IDs: pass LangGraph thread_id,
+     * Vercel AI id, or OpenAI run_id directly instead if you prefer.
+     *
+     * @returns A short unique session identifier
+     */
+    static generateSessionId(): string;
+    /**
+     * Log an agent's reasoning step into the tamper-evident digest chain.
+     *
+     * Each entry records why the agent took an action, optionally linked
+     * to a tool call. All entries for a sessionId can be replayed in
+     * order via step numbering to reconstruct the full decision trace.
+     *
+     * @param input - Reasoning details including agentId, action, reasoning text
+     * @returns The created reasoning entry
+     *
+     * @example
+     * ```typescript
+     * const sessionId = Kontext.generateSessionId();
+     *
+     * await ctx.logReasoning({
+     *   agentId: 'payment-agent-v1',
+     *   sessionId,
+     *   step: 1,
+     *   action: 'evaluate-transfer',
+     *   reasoning: 'User requested $5K USDC to 0xabc. Running compliance check first.',
+     *   confidence: 0.95,
+     *   toolCall: 'verify',
+     * });
+     *
+     * const result = await ctx.verify({ ..., sessionId });
+     *
+     * await ctx.logReasoning({
+     *   agentId: 'payment-agent-v1',
+     *   sessionId,
+     *   step: 2,
+     *   parentStep: 1,
+     *   action: 'compliance-passed',
+     *   reasoning: 'verify() returned compliant=true, riskLevel=low. Proceeding.',
+     *   confidence: 0.99,
+     *   context: { riskLevel: result.riskLevel },
+     * });
+     * ```
+     */
+    logReasoning(input: LogReasoningInput): Promise<ReasoningEntry>;
+    /**
+     * Get all reasoning entries for a specific agent, optionally filtered
+     * by session ID to retrieve a single run's decision trace.
+     *
+     * @param agentId - Agent identifier
+     * @param sessionId - Optional: filter to a single run
+     * @returns Array of reasoning entries in chronological order
+     */
+    getReasoningEntries(agentId: string, sessionId?: string): ReasoningEntry[];
     /**
      * Run USDC-specific compliance checks on a transaction.
      *
@@ -1648,47 +1505,99 @@ declare class Kontext {
      */
     checkUsdcCompliance(tx: LogTransactionInput): UsdcComplianceCheck;
     /**
-     * Log an agent's reasoning/justification for an action.
-     * The reasoning entry is recorded into the digest chain as a tamper-evident
-     * part of the audit trail (type: 'reasoning').
+     * Verify a transaction: compliance check, transaction log, trust score,
+     * anomaly detection, reasoning, and digest proof — all in one call.
      *
-     * @param input - Reasoning details
-     * @returns The created reasoning entry
+     * @param input - Transaction details with optional reasoning
+     * @returns Full verification result including compliance, trust, anomalies, and digest proof
      *
      * @example
      * ```typescript
-     * const entry = await kontext.logReasoning({
-     *   agentId: 'payment-agent-1',
-     *   action: 'approve_transfer',
-     *   reasoning: 'Recipient is a verified vendor with 50+ prior transactions',
+     * const result = await ctx.verify({
+     *   txHash: '0xabc...', chain: 'base', amount: '5000', token: 'USDC',
+     *   from: '0xsender', to: '0xrecipient', agentId: 'agent-v1',
+     *   reasoning: 'Transfer within daily limit. Recipient in allowlist.',
      *   confidence: 0.95,
-     *   context: { recipientId: 'vendor-42' },
      * });
+     *
+     * // result.compliant        — boolean
+     * // result.trustScore       — { score: 87, level: 'high', factors: [...] }
+     * // result.anomalies        — any flags triggered
+     * // result.digestProof      — { terminalDigest, chainLength, valid }
+     * // result.reasoningId      — ID of the reasoning entry (if reasoning provided)
      * ```
      */
-    logReasoning(input: LogReasoningInput): Promise<ReasoningEntry>;
+    verify(input: VerifyInput): Promise<VerifyResult>;
     /**
-     * Get all reasoning entries for a specific agent.
+     * Get the trust score for an agent based on historical behavioral signals.
+     *
+     * Computes a 0–100 score across 5 factors: history depth, task completion
+     * rate, anomaly frequency, transaction consistency, and compliance adherence.
      *
      * @param agentId - Agent identifier
-     * @returns Array of reasoning entries
+     * @returns Trust score with factor breakdown and level ('untrusted'|'low'|'medium'|'high'|'verified')
+     */
+    getTrustScore(agentId: string): Promise<TrustScore>;
+    /**
+     * Evaluate the risk of a specific transaction before or after executing it.
+     *
+     * @param tx - Transaction to evaluate
+     * @returns Risk evaluation with score, factors, and recommendation (approve/review/block)
+     */
+    evaluateTransaction(tx: LogTransactionInput): Promise<TransactionEvaluation>;
+    /**
+     * Enable anomaly detection with the specified rules and thresholds.
+     *
+     * Free-tier rules: `unusualAmount`, `frequencySpike`
+     * Pay as you go rules: `newDestination`, `offHoursActivity`, `rapidSuccession`, `roundAmount`
+     *
+     * @param config - Detection configuration with rules and optional thresholds
+     *
+     * @example
+     * ```typescript
+     * ctx.enableAnomalyDetection({
+     *   rules: ['unusualAmount', 'frequencySpike'],
+     *   thresholds: { maxAmount: '10000', maxFrequency: 30 },
+     * });
+     * ctx.onAnomaly((event) => {
+     *   console.log(`Anomaly: ${event.type} [${event.severity}]`);
+     * });
+     * ```
+     */
+    enableAnomalyDetection(config: AnomalyDetectionConfig): void;
+    /**
+     * Disable anomaly detection.
+     */
+    disableAnomalyDetection(): void;
+    /**
+     * Register a callback for anomaly events.
+     *
+     * @param callback - Function to call when an anomaly is detected
+     * @returns Unsubscribe function
      */
-    getReasoningEntries(agentId: string): ReasoningEntry[];
+    onAnomaly(callback: AnomalyCallback): () => void;
     /**
-     * Generate a compliance certificate that summarizes agent actions and
-     * verifies the terminal digest.
+     * Generate a compliance certificate that summarizes an agent's actions
+     * and cryptographically verifies the digest chain integrity.
      *
-     * @param input - Certificate generation options
-     * @returns A compliance certificate with digest chain verification
+     * The certificate includes: action/transaction/reasoning counts, digest chain
+     * verification status (Patent US 12,463,819 B1), the agent's current trust
+     * score, and an overall compliance status. A SHA-256 content hash of the
+     * certificate itself is included for tamper-evidence.
+     *
+     * @param input - Certificate generation options (agentId, optional timeRange, includeReasoning)
+     * @returns Compliance certificate with digest chain proof and trust score
      *
      * @example
      * ```typescript
-     * const cert = await kontext.generateComplianceCertificate({
-     *   agentId: 'payment-agent-1',
+     * const cert = await ctx.generateComplianceCertificate({
+     *   agentId: 'payment-agent-v1',
      *   includeReasoning: true,
      * });
-     * console.log(cert.complianceStatus); // 'compliant'
-     * console.log(cert.digestChain.verified); // true
+     * console.log(cert.complianceStatus);       // 'compliant'
+     * console.log(cert.digestChain.verified);   // true
+     * console.log(cert.trustScore);             // 87
+     * console.log(cert.contentHash);            // sha256 of certificate
      * ```
      */
     generateComplianceCertificate(input: GenerateComplianceCertificateInput): Promise<ComplianceCertificate>;
@@ -1751,142 +1660,155 @@ declare class Kontext {
      */
     getFeatureFlagManager(): FeatureFlagManager | null;
     /**
-     * Set or replace approval policies. Creates a new ApprovalManager.
-     *
-     * @param policies - Approval policy configurations
+     * Gracefully shut down the SDK, flushing any pending data.
      */
-    setApprovalPolicies(policies: ApprovalPolicy[]): void;
+    destroy(): Promise<void>;
+}
+
+interface FirestoreStorageConfig {
+    /** GCP project ID — use "Kontext" for the Kontext production project */
+    gcpProjectId: string;
     /**
-     * Evaluate an action against the configured approval policies.
-     *
-     * @param input - Action details to evaluate
-     * @returns Evaluation result indicating whether approval is required
-     * @throws KontextError if no approval policies are configured
+     * The user/tenant ID that owns these logs. Required for data isolation.
+     * Use a stable identifier: Stripe customer ID, your auth system's user ID,
+     * or a deterministic hash of the API key.
      */
-    evaluateApproval(input: EvaluateApprovalInput): ApprovalEvaluation;
+    userId: string;
     /**
-     * Submit a human decision on a pending approval request.
-     *
-     * @param input - Decision details
-     * @returns The updated ApprovalRequest
-     * @throws KontextError if no approval policies are configured
+     * OAuth2 access token for the Firestore REST API.
+     * On GCP (Cloud Run, GCE, GKE): omit — the adapter will fetch a token
+     * from the GCP metadata server automatically.
+     * For local dev or other environments: pass a token from Application Default
+     * Credentials (`gcloud auth print-access-token`).
      */
-    submitApprovalDecision(input: SubmitDecisionInput): ApprovalRequest;
+    accessToken?: string;
     /**
-     * Get an approval request by ID.
-     *
-     * @param requestId - The approval request identifier
-     * @returns The approval request, or undefined if not found
+     * Firestore database ID. Defaults to '(default)'.
+     * Change only if you created a named database in the GCP console.
      */
-    getApprovalRequest(requestId: string): ApprovalRequest | undefined;
+    databaseId?: string;
     /**
-     * Get all pending approval requests.
-     *
-     * @returns Array of pending approval requests
+     * Whether to write each record as an individual Firestore document
+     * in addition to the bulk flush writes. Enables real-time querying
+     * per-action, per-session, per-agent.
+     * @default true
      */
-    getPendingApprovals(): ApprovalRequest[];
+    writeDocumentsIndividually?: boolean;
     /**
-     * Gracefully shut down the SDK, flushing any pending data.
+     * Custom Firestore REST base URL. Override for testing or emulator use.
+     * @default 'https://firestore.googleapis.com'
      */
-    destroy(): Promise<void>;
+    firestoreBaseUrl?: string;
 }
-
 /**
- * ApprovalManager evaluates proposed actions against configurable policies
- * and blocks execution until a human reviewer approves or rejects.
+ * Persistent, hierarchical Firestore storage adapter for Kontext audit logs.
+ *
+ * Stores compliance logs by user → project → agent → session, enabling
+ * regulatory-grade queries: "show me all transactions agent X made in
+ * session Y" or "export all logs for user Z".
  *
- * Policies:
- * - **amount-threshold** — triggers when amount exceeds a configured threshold
- * - **low-trust-score** — triggers when the agent's trust score is below minimum
- * - **anomaly-detected** — triggers when anomalies of sufficient severity are present
- * - **new-destination** — triggers when the destination address has not been seen before
- * - **manual** — always triggers, requiring explicit human approval
+ * Works as a drop-in replacement for FileStorage:
  *
  * @example
  * ```typescript
- * const manager = new ApprovalManager([
- *   { type: 'amount-threshold', enabled: true, params: { threshold: '10000' } },
- *   { type: 'manual', enabled: false, params: {} },
- * ]);
+ * import { Kontext, FirestoreStorageAdapter } from 'kontext-sdk';
  *
- * const evaluation = manager.evaluate({
- *   actionId: 'action-1',
- *   agentId: 'agent-1',
- *   amount: '25000',
+ * const ctx = Kontext.init({
+ *   projectId: 'treasury-agent',
+ *   environment: 'production',
+ *   storage: new FirestoreStorageAdapter({
+ *     gcpProjectId: 'Kontext',
+ *     userId: 'user-abc123',
+ *   }),
  * });
  *
- * if (evaluation.required) {
- *   // Wait for human decision
- *   const request = manager.submitDecision({
- *     requestId: evaluation.requestId!,
- *     decision: 'approve',
- *     decidedBy: 'admin@example.com',
- *     reason: 'Verified recipient',
- *   });
- * }
+ * // After this, all verify(), log(), logReasoning() calls are
+ * // persisted to Firestore at:
+ * // users/user-abc123/projects/treasury-agent/agents/{agentId}/sessions/{sessionId}/...
  * ```
  */
-declare class ApprovalManager {
-    private readonly policies;
-    private readonly expiresInMs;
-    private readonly requests;
-    private readonly seenDestinations;
-    constructor(policies: ApprovalPolicy[], expiresInMs?: number);
-    /**
-     * Evaluate an action against all enabled policies.
-     * If any policy triggers, an ApprovalRequest is created and the evaluation
-     * returns `required: true` with the request ID.
-     *
-     * @param input - Action details to evaluate
-     * @returns Evaluation result indicating whether approval is required
-     */
-    evaluate(input: EvaluateApprovalInput): ApprovalEvaluation;
+declare class FirestoreStorageAdapter implements StorageAdapter {
+    private readonly config;
+    /** In-memory cache for load() — avoids re-fetching on every store.restore() */
+    private cache;
+    /** Token cache: avoid metadata server round-trips on every write */
+    private cachedToken;
+    private tokenExpiresAt;
+    constructor(config: FirestoreStorageConfig);
     /**
-     * Submit a human decision on a pending approval request.
+     * Save data under a Kontext storage key.
      *
-     * @param input - Decision details
-     * @returns The updated ApprovalRequest
-     * @throws KontextError if request not found, expired, or missing required evidence
+     * The flat key space (kontext:actions, kontext:transactions, etc.) is mapped
+     * to structured Firestore paths. List data (actions, transactions) is written
+     * as individual documents under sub-collections for queryability.
      */
-    submitDecision(input: SubmitDecisionInput): ApprovalRequest;
+    save(key: string, data: unknown): Promise<void>;
     /**
-     * Get an approval request by ID.
-     *
-     * @param requestId - The approval request identifier
-     * @returns The approval request, or undefined if not found
+     * Load data for a Kontext storage key.
+     * Returns cached data if available (populated by save()).
+     * Falls back to Firestore fetch for cold starts.
      */
-    getRequest(requestId: string): ApprovalRequest | undefined;
+    load(key: string): Promise<unknown | null>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<string[]>;
     /**
-     * Get all pending approval requests.
+     * Write a single action log to its canonical Firestore path.
+     * Called by the SDK when `writeDocumentsIndividually` is true.
      *
-     * @returns Array of pending approval requests
+     * Path: users/{userId}/projects/{projectId}/agents/{agentId}/sessions/{sessionId}/actions/{actionId}
      */
-    getPendingRequests(): ApprovalRequest[];
+    writeAction(action: ActionLog): Promise<void>;
     /**
-     * Get all approval requests for a specific agent.
+     * Write a single transaction record to its canonical Firestore path.
      *
-     * @param agentId - The agent identifier
-     * @returns Array of approval requests for the agent
+     * Path: users/{userId}/projects/{projectId}/agents/{agentId}/sessions/{sessionId}/transactions/{txId}
      */
-    getRequestsByAgent(agentId: string): ApprovalRequest[];
+    writeTransaction(tx: TransactionRecord): Promise<void>;
     /**
-     * Check if an approval request has been approved.
+     * Write a single task to its canonical Firestore path.
      *
-     * @param requestId - The approval request identifier
-     * @returns Whether the request is approved
+     * Path: users/{userId}/projects/{projectId}/tasks/{taskId}
      */
-    isApproved(requestId: string): boolean;
-    private evaluatePolicy;
-    private evaluateAmountThreshold;
-    private evaluateLowTrustScore;
-    private evaluateAnomalyDetected;
-    private evaluateNewDestination;
-    private calculateRiskScore;
-    private collectRequiredEvidence;
+    writeTask(task: Task): Promise<void>;
+    private get basePath();
+    private actionPath;
+    private transactionPath;
+    private taskPath;
+    private anomalyPath;
+    private keyToPath;
+    private saveActionList;
+    private saveTransactionList;
+    private saveTaskList;
+    private saveAnomalyList;
+    private loadActionList;
+    private loadTransactionList;
+    private loadTaskList;
+    private loadAnomalyList;
+    private firestoreBase;
+    /** Save an arbitrary JS object as a Firestore document at the given path. */
+    private saveDocument;
+    /** Load a document at the given Firestore path. Returns null if not found. */
+    private loadDocument;
+    /** Delete a document at the given Firestore path. */
+    private deleteDocument;
+    /**
+     * List all documents in a collection and deserialize them.
+     * Used for tasks (simple flat collection).
+     */
+    private queryCollection;
+    /**
+     * Run a Firestore collection group query to fetch documents across all
+     * nested sub-collections with the given name (e.g., 'actions' across all
+     * agents and sessions).
+     *
+     * Scoped to the user's project root to prevent cross-tenant reads.
+     */
+    private queryCollectionGroup;
+    private getToken;
 }
 
 /** Features gated by plan tier */
-type GatedFeature = 'advanced-anomaly-rules' | 'sar-ctr-reports' | 'webhooks' | 'ofac-screening' | 'csv-export' | 'multi-chain' | 'cftc-compliance' | 'circle-wallets' | 'circle-compliance' | 'gas-station' | 'cctp-transfers' | 'approval-policies' | 'unified-screening' | 'blocklist-manager';
+type GatedFeature = 'advanced-anomaly-rules' | 'sar-ctr-reports' | 'webhooks' | 'ofac-screening' | 'csv-export' | 'multi-chain' | 'cftc-compliance' | 'circle-wallets' | 'circle-compliance' | 'gas-station' | 'cctp-transfers' | 'approval-policies' | 'unified-screening' | 'blocklist-manager' | 'kya-identity' | 'kya-behavioral';
 /**
  * Check if a feature is available on the given plan.
  * Returns true if allowed, false if not.
@@ -1897,298 +1819,6 @@ declare function isFeatureAvailable(feature: GatedFeature, currentPlan: PlanTier
  */
 declare function requirePlan(feature: GatedFeature, currentPlan: PlanTier): void;
 
-/** OFAC sanctions list identifiers */
-type SanctionsList = 'SDN' | 'SSI' | 'CAPTA' | 'NS-MBS' | 'CONSOLIDATED' | 'DELISTED' | 'COMMUNITY';
-/** Sanctioned jurisdiction identifiers (ISO 3166-1 alpha-2 where applicable) */
-type SanctionedJurisdiction = 'KP' | 'IR' | 'CU' | 'SY' | 'RU_CRIMEA' | 'RU_DNR' | 'RU_LNR' | 'RU_ZAPORIZHZHIA' | 'RU_KHERSON' | 'BY' | 'VE' | 'MM' | 'SD' | 'SO';
-/** Risk level for sanctions screening */
-type SanctionsRiskLevel = 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'SEVERE' | 'BLOCKED';
-/** Entity type for sanctions context */
-type SanctionedEntityType = 'MIXER' | 'EXCHANGE' | 'INDIVIDUAL' | 'GROUP' | 'PROTOCOL' | 'UNKNOWN';
-/** A sanctioned address entry with metadata */
-interface SanctionedAddressEntry {
-    /** The blockchain address */
-    address: string;
-    /** Which sanctions list(s) this address appears on */
-    lists: SanctionsList[];
-    /** The entity name associated with this address */
-    entityName: string;
-    /** Entity type */
-    entityType: SanctionedEntityType;
-    /** ISO date when the address was first sanctioned */
-    dateAdded: string;
-    /** ISO date when the address was removed (if applicable) */
-    dateRemoved: string | null;
-    /** Blockchain network(s) this address is relevant to */
-    chains: string[];
-    /** Additional notes */
-    notes: string;
-}
-/** Result of a comprehensive sanctions screening */
-interface ComprehensiveSanctionsResult {
-    /** Whether any sanctions match was found */
-    sanctioned: boolean;
-    /** Overall risk level */
-    riskLevel: SanctionsRiskLevel;
-    /** Numeric risk score (0-100) */
-    riskScore: number;
-    /** The address that was screened */
-    address: string;
-    /** Direct address matches */
-    directMatches: SanctionsMatch[];
-    /** Jurisdictional flags */
-    jurisdictionFlags: JurisdictionFlag[];
-    /** Pattern-based flags */
-    patternFlags: PatternFlag[];
-    /** 50% rule flags */
-    ownershipFlags: OwnershipFlag[];
-    /** Screening timestamp */
-    screenedAt: string;
-    /** Lists that were checked */
-    listsChecked: SanctionsList[];
-    /** Recommendations */
-    recommendations: string[];
-}
-/** A match against a sanctions list */
-interface SanctionsMatch {
-    /** The matched address */
-    matchedAddress: string;
-    /** Which list the match is on */
-    list: SanctionsList;
-    /** Entity name */
-    entityName: string;
-    /** Entity type */
-    entityType: SanctionedEntityType;
-    /** Match confidence (0-1, 1.0 = exact match) */
-    confidence: number;
-    /** Whether this is currently active or delisted */
-    active: boolean;
-}
-/** A jurisdictional screening flag */
-interface JurisdictionFlag {
-    /** The flagged jurisdiction */
-    jurisdiction: SanctionedJurisdiction;
-    /** Human-readable jurisdiction name */
-    name: string;
-    /** Reason for the flag */
-    reason: string;
-    /** Risk level for this jurisdiction */
-    riskLevel: SanctionsRiskLevel;
-}
-/** A pattern-based flag */
-interface PatternFlag {
-    /** Pattern type */
-    pattern: 'MIXING' | 'CHAIN_HOPPING' | 'STRUCTURING' | 'RAPID_MOVEMENT' | 'PEELING_CHAIN';
-    /** Human-readable description */
-    description: string;
-    /** Severity */
-    severity: SanctionsRiskLevel;
-    /** Evidence for the flag */
-    evidence: string[];
-}
-/** A 50% rule ownership flag */
-interface OwnershipFlag {
-    /** The entity that may be controlled by a sanctioned party */
-    entityName: string;
-    /** The sanctioned parent entity */
-    sanctionedParent: string;
-    /** Estimated ownership percentage */
-    ownershipPercentage: number;
-    /** Source of the ownership data */
-    source: string;
-}
-/** Transaction data for pattern analysis */
-interface TransactionForAnalysis {
-    txHash: string;
-    from: string;
-    to: string;
-    amount: number;
-    chain: string;
-    timestamp: string;
-}
-/** Entity name for fuzzy matching */
-interface EntityNameEntry {
-    /** Canonical name */
-    name: string;
-    /** Known aliases */
-    aliases: string[];
-    /** Associated addresses */
-    addresses: string[];
-    /** Sanctions list */
-    list: SanctionsList;
-}
-/** Sanctions list metadata */
-interface SanctionsListMetadata {
-    /** When the list was last updated */
-    lastUpdated: string;
-    /** Number of addresses in the list */
-    addressCount: number;
-    /** Number of entities in the list */
-    entityCount: number;
-    /** Source URL */
-    sourceUrl: string;
-    /** Version/hash of the list */
-    version: string;
-}
-interface JurisdictionInfo {
-    code: SanctionedJurisdiction;
-    name: string;
-    sanctionsProgram: string;
-    riskLevel: SanctionsRiskLevel;
-    comprehensive: boolean;
-}
-/**
- * Comprehensive OFAC sanctions screening engine.
- *
- * Goes beyond simple address matching to provide multi-layered screening
- * aligned with GENIUS Act requirements and OFAC compliance best practices.
- *
- * Features:
- * - SDN and Consolidated Sanctions List address matching
- * - Delisted address risk flagging (e.g., former Tornado Cash contracts)
- * - Jurisdictional screening for sanctioned countries
- * - 50% Rule ownership flagging
- * - Fuzzy entity name matching with alias support
- * - Transaction pattern analysis (mixing, chain-hopping, structuring)
- * - Sanctions list update mechanism
- * - Comprehensive risk scoring
- *
- * @example
- * ```typescript
- * const screener = new OFACSanctionsScreener();
- *
- * // Screen a single address
- * const result = screener.screenAddress('0x098B716B...');
- * if (result.sanctioned) {
- *   console.log('BLOCKED:', result.recommendations);
- * }
- *
- * // Screen with jurisdiction context
- * const result2 = screener.screenAddress('0x...', { jurisdiction: 'IR' });
- *
- * // Fuzzy entity name search
- * const matches = screener.searchEntityName('Lazarus');
- * ```
- */
-declare class OFACSanctionsScreener {
-    /**
-     * Check if an address is on an active sanctions list.
-     * Returns true only for currently sanctioned (non-delisted) addresses.
-     */
-    isActivelySanctioned(address: string): boolean;
-    /**
-     * Check if an address has ever appeared on any sanctions list,
-     * including those that have been delisted.
-     */
-    hasAnySanctionsHistory(address: string): boolean;
-    /**
-     * Get the full entry for a sanctioned address.
-     */
-    getAddressEntry(address: string): SanctionedAddressEntry | undefined;
-    /**
-     * Perform a comprehensive sanctions screening on an address.
-     * Checks against all lists, evaluates jurisdiction, and computes risk score.
-     */
-    screenAddress(address: string, context?: {
-        jurisdiction?: SanctionedJurisdiction;
-        counterpartyAddress?: string;
-        amount?: number;
-        chain?: string;
-    }): ComprehensiveSanctionsResult;
-    /**
-     * Screen a jurisdiction for sanctions.
-     */
-    screenJurisdiction(code: string): JurisdictionFlag | null;
-    /**
-     * Get all sanctioned jurisdictions.
-     */
-    getSanctionedJurisdictions(): JurisdictionInfo[];
-    /**
-     * Check if a jurisdiction has comprehensive sanctions (all transactions blocked).
-     */
-    isComprehensiveSanctions(code: SanctionedJurisdiction): boolean;
-    /**
-     * Search for sanctioned entities by name with fuzzy matching.
-     * Uses normalized Levenshtein distance and alias matching.
-     *
-     * @param query - Name to search for
-     * @param threshold - Minimum similarity score (0-1, default 0.6)
-     * @returns Matching entities sorted by relevance
-     */
-    searchEntityName(query: string, threshold?: number): Array<{
-        entity: EntityNameEntry;
-        similarity: number;
-        matchedOn: string;
-    }>;
-    /**
-     * Check if an entity may be subject to the OFAC 50% Rule.
-     *
-     * Under the 50% Rule, entities owned 50% or more (individually or in
-     * aggregate) by one or more sanctioned persons are themselves blocked,
-     * even if not explicitly named on the SDN list.
-     *
-     * This method checks a provided ownership structure against known
-     * sanctioned entities.
-     *
-     * @param ownershipEntries - Array of { ownerName, ownershipPercentage } objects
-     * @returns Array of OwnershipFlag for any sanctioned owners
-     */
-    checkFiftyPercentRule(entityName: string, ownershipEntries: Array<{
-        ownerName: string;
-        ownershipPercentage: number;
-    }>): OwnershipFlag[];
-    /**
-     * Analyze a set of transactions for patterns associated with sanctions evasion.
-     *
-     * Detects:
-     * - Mixing/tumbling indicators (interaction with known mixers)
-     * - Chain-hopping patterns (rapid cross-chain movements)
-     * - Structuring (amounts just below reporting thresholds)
-     * - Rapid fund movement through intermediaries
-     * - Peeling chain patterns
-     */
-    analyzeTransactionPatterns(transactions: TransactionForAnalysis[]): PatternFlag[];
-    private detectMixingPattern;
-    private detectChainHopping;
-    private detectStructuring;
-    private detectRapidMovement;
-    private detectPeelingChain;
-    /**
-     * Add new sanctioned addresses to the database at runtime.
-     * Returns the count of newly added addresses.
-     */
-    addAddresses(entries: SanctionedAddressEntry[]): number;
-    /**
-     * Add new entity names for fuzzy matching.
-     */
-    addEntities(entities: EntityNameEntry[]): number;
-    /**
-     * Get current sanctions list metadata.
-     */
-    getListMetadata(): SanctionsListMetadata;
-    /**
-     * Get all active sanctioned addresses (non-delisted).
-     */
-    getActiveSanctionedAddresses(): string[];
-    /**
-     * Get all sanctioned addresses including delisted.
-     */
-    getAllAddresses(): string[];
-    /**
-     * Get the count of active sanctioned addresses.
-     */
-    getActiveAddressCount(): number;
-    /**
-     * Get the count of all addresses (including delisted).
-     */
-    getTotalAddressCount(): number;
-    /**
-     * Get all entity names in the database.
-     */
-    getEntities(): EntityNameEntry[];
-}
-declare const ofacScreener: OFACSanctionsScreener;
-
 /**
  * Result of a sanctions check with list matching details.
  */
@@ -2301,31 +1931,6 @@ declare class UsdcCompliance {
      * @returns The size of the current sanctions list
      */
     static getSanctionsListSize(): number;
-    /**
-     * Perform comprehensive OFAC sanctions screening using the advanced
-     * OFACSanctionsScreener. This goes beyond simple address matching to
-     * include jurisdictional screening, delisted address detection, and
-     * entity metadata.
-     *
-     * @param address - The address to screen
-     * @param context - Optional context for enhanced screening
-     * @returns ComprehensiveSanctionsResult with full screening details
-     */
-    static screenComprehensive(address: string, context?: {
-        jurisdiction?: string;
-        counterpartyAddress?: string;
-        amount?: number;
-        chain?: string;
-    }): ComprehensiveSanctionsResult;
-    /**
-     * Check if an address is actively sanctioned (non-delisted).
-     * Unlike isSanctioned(), this excludes addresses that have been removed
-     * from the SDN list (e.g., Tornado Cash contracts post-March 2025).
-     *
-     * @param address - The address to check
-     * @returns true if the address is on an active sanctions list
-     */
-    static isActivelySanctioned(address: string): boolean;
     private static checkTokenType;
     private static checkChainSupport;
     private static checkAddressFormat;
@@ -2336,2661 +1941,349 @@ declare class UsdcCompliance {
     private static generateRecommendations;
 }
 
-/** CCTP protocol version */
-type CCTPVersion = 'v1' | 'v2';
-/** CCTP message status */
-type CCTPMessageStatus = 'pending' | 'attested' | 'confirmed' | 'failed';
-/** CCTP V2 hook definition for post-transfer automation */
-interface CCTPHook {
-    /** Target contract address on the destination chain */
-    targetContract: string;
-    /** Encoded function call data */
-    callData: string;
-    /** Maximum gas for hook execution */
-    gasLimit: number;
-    /** Human-readable description of the hook */
-    description?: string;
-}
-/** Input for initiating a CCTP V2 fast transfer */
-interface InitiateFastTransferInput {
-    /** Source chain */
-    sourceChain: Chain;
-    /** Destination chain */
-    destinationChain: Chain;
-    /** Transfer amount */
-    amount: string;
-    /** Token being transferred */
-    token: Token;
-    /** Sender address */
-    sender: string;
-    /** Recipient address */
-    recipient: string;
-    /** Source chain transaction hash */
-    sourceTxHash: string;
-    /** Agent initiating the transfer */
-    agentId: string;
-    /** Maximum finality time the sender will accept (seconds) */
-    maxFinalitySeconds?: number;
-    /** Optional hooks to execute after transfer completes */
-    hooks?: CCTPHook[];
-    /** Optional nonce */
-    nonce?: number;
-    /** Optional correlation ID */
-    correlationId?: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** A cross-chain transfer record */
-interface CrossChainTransfer {
-    /** Unique transfer identifier */
-    id: string;
-    /** Source chain */
-    sourceChain: Chain;
-    /** Destination chain */
-    destinationChain: Chain;
-    /** CCTP domain ID for source */
-    sourceDomain: number;
-    /** CCTP domain ID for destination */
-    destinationDomain: number;
-    /** Transfer amount (string to preserve precision) */
-    amount: string;
-    /** Token being transferred */
-    token: Token;
-    /** Sender address on source chain */
-    sender: string;
-    /** Recipient address on destination chain */
-    recipient: string;
-    /** Source chain transaction hash */
-    sourceTxHash: string;
-    /** Destination chain transaction hash (set after confirmation) */
-    destinationTxHash: string | null;
-    /** CCTP message hash for attestation tracking */
-    messageHash: string | null;
-    /** Current status of the transfer */
-    status: CCTPMessageStatus;
-    /** Nonce from the CCTP MessageSent event */
-    nonce: number | null;
-    /** Timestamp when the transfer was initiated */
-    initiatedAt: string;
-    /** Timestamp when attestation was received */
-    attestedAt: string | null;
-    /** Timestamp when the transfer was confirmed on destination */
-    confirmedAt: string | null;
-    /** Correlation ID linking source and destination actions */
-    correlationId: string;
-    /** Agent that initiated the transfer */
-    agentId: string;
-    /** Additional metadata */
-    metadata: Record<string, unknown>;
-    /** CCTP protocol version used */
-    version?: CCTPVersion;
-    /** Whether this is a fast transfer (V2) */
-    isFastTransfer?: boolean;
-    /** Post-transfer hooks (V2) */
-    hooks?: CCTPHook[];
-    /** Hook execution results (V2) */
-    hookResults?: CCTPHookResult[];
-}
-/** Input for initiating a cross-chain transfer record */
-interface InitiateCCTPTransferInput {
-    /** Source chain */
-    sourceChain: Chain;
-    /** Destination chain */
-    destinationChain: Chain;
-    /** Transfer amount */
-    amount: string;
-    /** Token being transferred */
-    token: Token;
-    /** Sender address */
-    sender: string;
-    /** Recipient address */
-    recipient: string;
-    /** Source chain transaction hash (from depositForBurn) */
-    sourceTxHash: string;
-    /** Agent initiating the transfer */
-    agentId: string;
-    /** Optional nonce from the MessageSent event */
-    nonce?: number;
-    /** Optional correlation ID */
-    correlationId?: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Input for recording a CCTP attestation */
-interface CCTPAttestationInput {
-    /** The cross-chain transfer ID */
-    transferId: string;
-    /** The message hash from the attestation service */
-    messageHash: string;
-    /** Optional attestation metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Input for confirming a cross-chain transfer on destination */
-interface ConfirmCCTPTransferInput {
-    /** The cross-chain transfer ID */
-    transferId: string;
-    /** Destination chain transaction hash (from receiveMessage) */
-    destinationTxHash: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Validation result for a cross-chain transfer */
-interface CCTPValidationResult {
-    /** Whether the transfer configuration is valid */
-    valid: boolean;
-    /** Validation checks performed */
-    checks: CCTPValidationCheck[];
-    /** Overall risk level */
-    riskLevel: 'low' | 'medium' | 'high' | 'critical';
-    /** Recommendations */
-    recommendations: string[];
-}
-/** Individual validation check */
-interface CCTPValidationCheck {
-    /** Check name */
-    name: string;
-    /** Whether the check passed */
-    passed: boolean;
-    /** Description */
-    description: string;
-    /** Severity if failed */
-    severity: AnomalySeverity;
-}
-/** Cross-chain audit trail entry */
-interface CrossChainAuditEntry {
-    /** The transfer record */
-    transfer: CrossChainTransfer;
-    /** Source chain action log ID (from logTransaction) */
-    sourceActionId: string | null;
-    /** Destination chain action log ID (from logTransaction) */
-    destinationActionId: string | null;
-    /** Whether source and destination are linked */
-    linked: boolean;
-    /** Duration from initiation to confirmation in milliseconds */
-    durationMs: number | null;
-}
-/** Result of a CCTP V2 hook execution */
-interface CCTPHookResult {
-    /** Target contract address */
-    targetContract: string;
-    /** Whether the hook executed successfully */
-    success: boolean;
-    /** Transaction hash of the hook execution */
-    transactionHash?: string;
-    /** Error message if the hook failed */
-    error?: string;
-    /** Gas used by the hook */
-    gasUsed?: number;
-}
-/** Validation result for a CCTP V2 fast transfer */
-interface FastTransferValidation {
-    /** Whether the fast transfer route is supported */
-    fastTransferAvailable: boolean;
-    /** Estimated finality time in seconds */
-    estimatedFinalitySeconds: number;
-    /** Whether hooks are valid */
-    hooksValid: boolean;
-    /** Hook validation details */
-    hookValidation: {
-        index: number;
-        valid: boolean;
-        reason?: string;
-    }[];
-    /** Standard validation result */
-    standardValidation: CCTPValidationResult;
-}
-/**
- * CCTPTransferManager handles cross-chain transfer tracking and validation
- * for Circle's Cross-Chain Transfer Protocol.
- *
- * Provides:
- * - Transfer validation (source chain to destination chain)
- * - CCTP message attestation logging
- * - Cross-chain audit trail linking
- * - Transfer lifecycle tracking (pending -> attested -> confirmed)
- */
-declare class CCTPTransferManager {
-    private transfers;
-    private actionLinks;
-    /**
-     * Validate a cross-chain transfer before execution.
-     *
-     * Checks include:
-     * - Source and destination chain support
-     * - Route validity (different chains)
-     * - Token support on both chains
-     * - Amount validation
-     * - Address format validation
-     *
-     * @param input - Transfer details to validate
-     * @returns Validation result with checks and recommendations
-     */
-    validateTransfer(input: InitiateCCTPTransferInput): CCTPValidationResult;
-    /**
-     * Record a new cross-chain transfer initiated via CCTP depositForBurn.
-     *
-     * @param input - Transfer initiation details
-     * @returns The created CrossChainTransfer record
-     */
-    initiateTransfer(input: InitiateCCTPTransferInput): CrossChainTransfer;
-    /**
-     * Record a CCTP attestation for a pending transfer.
-     * Called after the attestation service has signed the burn message.
-     *
-     * @param input - Attestation details
-     * @returns The updated CrossChainTransfer record
-     * @throws Error if transfer not found or not in pending status
-     */
-    recordAttestation(input: CCTPAttestationInput): CrossChainTransfer;
-    /**
-     * Confirm a cross-chain transfer has been received on the destination chain.
-     * Called after receiveMessage has been executed on the destination.
-     *
-     * @param input - Confirmation details
-     * @returns The updated CrossChainTransfer record
-     * @throws Error if transfer not found or not in attested status
-     */
-    confirmTransfer(input: ConfirmCCTPTransferInput): CrossChainTransfer;
-    /**
-     * Mark a transfer as failed.
-     *
-     * @param transferId - The transfer to mark as failed
-     * @param reason - Reason for failure
-     * @returns The updated CrossChainTransfer record
-     */
-    failTransfer(transferId: string, reason: string): CrossChainTransfer;
-    /**
-     * Link a Kontext action log ID to a cross-chain transfer.
-     * Used to correlate source and destination chain actions in the audit trail.
-     *
-     * @param transferId - The cross-chain transfer ID
-     * @param actionId - The action log ID to link
-     * @param side - Whether this is the source or destination action
-     */
-    linkAction(transferId: string, actionId: string, side: 'source' | 'destination'): void;
-    /**
-     * Get a cross-chain transfer by ID.
-     */
-    getTransfer(transferId: string): CrossChainTransfer | undefined;
-    /**
-     * Get all cross-chain transfers, optionally filtered by status.
-     */
-    getTransfers(status?: CCTPMessageStatus): CrossChainTransfer[];
-    /**
-     * Get transfers by correlation ID.
-     * Useful for finding all transfers related to a single workflow.
-     */
-    getTransfersByCorrelation(correlationId: string): CrossChainTransfer[];
-    /**
-     * Build a cross-chain audit trail for a given transfer.
-     * Links source and destination chain actions together.
-     *
-     * @param transferId - The transfer to build an audit trail for
-     * @returns CrossChainAuditEntry with linked action references
-     */
-    getAuditEntry(transferId: string): CrossChainAuditEntry | undefined;
-    /**
-     * Build audit trail entries for all transfers, optionally filtered.
-     *
-     * @param agentId - Optional filter by agent
-     * @returns Array of CrossChainAuditEntry records
-     */
-    getAuditTrail(agentId?: string): CrossChainAuditEntry[];
-    /**
-     * Validate a fast transfer request (CCTP V2).
-     * Checks route eligibility, hook validity, and standard validation.
-     *
-     * @param input - Fast transfer details
-     * @returns FastTransferValidation with availability and hook checks
-     */
-    validateFastTransfer(input: InitiateFastTransferInput): FastTransferValidation;
-    /**
-     * Initiate a CCTP V2 fast transfer with optional hooks.
-     *
-     * Fast transfers use CCTP V2's sub-minute finality on supported routes.
-     * Hooks allow automated post-transfer actions on the destination chain.
-     *
-     * @param input - Fast transfer details including optional hooks
-     * @returns The created CrossChainTransfer record with V2 metadata
-     */
-    initiateFastTransfer(input: InitiateFastTransferInput): CrossChainTransfer;
-    /**
-     * Record hook execution results for a V2 transfer.
-     *
-     * @param transferId - The transfer ID
-     * @param results - Array of hook execution results
-     * @returns The updated transfer
-     */
-    recordHookResults(transferId: string, results: CCTPHookResult[]): CrossChainTransfer;
-    /**
-     * Check if a route supports CCTP V2 fast transfers.
-     *
-     * @param sourceChain - Source blockchain network
-     * @param destinationChain - Destination blockchain network
-     * @returns Whether fast transfer is available
-     */
-    static isFastTransferAvailable(sourceChain: Chain, destinationChain: Chain): boolean;
-    /**
-     * Get the CCTP domain ID for a given chain.
-     *
-     * @param chain - The blockchain network
-     * @returns The CCTP domain ID, or undefined for unsupported chains
-     */
-    static getDomainId(chain: Chain): number | undefined;
-    /**
-     * Get the chains supported for CCTP transfers.
-     */
-    static getSupportedChains(): Chain[];
-    /**
-     * Get the list of V2 fast-transfer eligible routes.
-     *
-     * @returns Array of route strings in "source->destination" format
-     */
-    static getFastTransferRoutes(): string[];
-    private checkChainSupport;
-    private checkRouteValidity;
-    private checkTokenSupport;
-    private checkAmountValidity;
-    private checkAddressFormat;
-    private generateRecommendations;
-}
-
-/** Configuration options for the CircleWalletManager */
-interface CircleWalletOptions {
-    /** Entity secret ciphertext for developer-controlled wallets */
-    entitySecretCiphertext?: string;
-    /** Default blockchain network for new wallets */
-    defaultChain?: Chain;
-    /** Automatically log all wallet operations through Kontext (default: true) */
-    autoLog?: boolean;
-    /** Require compliance check before transfers (default: true) */
-    requireCompliance?: boolean;
-}
-/** A wallet set (group of wallets) */
-interface WalletSet {
-    /** Unique wallet set identifier */
-    id: string;
-    /** Human-readable name */
-    name: string;
-    /** Custody type */
-    custodyType: 'DEVELOPER' | 'USER';
-    /** Creation timestamp */
-    createdAt: string;
-}
-/** A Circle programmable wallet */
-interface CircleWallet {
-    /** Unique wallet identifier */
-    id: string;
-    /** Parent wallet set ID */
-    walletSetId: string;
-    /** On-chain address */
-    address: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Custody type */
-    custodyType: 'DEVELOPER' | 'USER';
-    /** Wallet state */
-    state: 'LIVE' | 'FROZEN';
-    /** Creation timestamp */
-    createDate: string;
-}
-/** Options for creating a new wallet */
-interface CreateWalletOptions {
-    /** Blockchain network for the wallet */
-    chain: Chain;
-    /** Custody type (default: 'DEVELOPER') */
-    custodyType?: 'DEVELOPER' | 'USER';
-    /** Additional metadata */
-    metadata?: Record<string, string>;
-}
-/** Input for a compliant transfer */
-interface CompliantTransferInput {
-    /** Source wallet ID */
-    walletId: string;
-    /** Destination on-chain address */
-    destinationAddress: string;
-    /** Transfer amount (string to preserve precision) */
-    amount: string;
-    /** Blockchain network (defaults to wallet's chain) */
-    chain?: Chain;
-    /** Token to transfer */
-    token?: 'USDC' | 'EURC';
-    /** Agent initiating the transfer */
-    agent?: string;
-    /** Additional metadata */
-    metadata?: Record<string, any>;
-}
-/** Result of a compliant transfer */
-interface CompliantTransferResult {
-    /** Circle transfer identifier */
-    transferId: string;
-    /** Source wallet ID */
-    walletId: string;
-    /** Transfer status */
-    status: 'COMPLETED' | 'BLOCKED' | 'PENDING_REVIEW';
-    /** Compliance check details */
-    complianceCheck: ComplianceCheckSummary;
-    /** Kontext action log ID */
-    kontextLogId: string;
-    /** Trust score at time of transfer */
-    trustScore: number;
-    /** Transfer amount */
-    amount: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** On-chain transaction hash (if completed) */
-    transactionHash?: string;
-    /** Reason the transfer was blocked (if blocked) */
-    blockedReason?: string;
-}
-/** Summary of compliance check for a transfer */
-interface ComplianceCheckSummary {
-    /** Whether the check passed */
-    passed: boolean;
-    /** Risk level */
-    riskLevel: AnomalySeverity;
-    /** Individual check results */
-    checks: ComplianceCheckResult[];
-    /** Recommendations */
-    recommendations: string[];
-}
-/** Wallet balance information */
-interface WalletBalance {
-    /** Wallet identifier */
-    walletId: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Token balances */
-    balances: {
-        token: string;
-        amount: string;
-    }[];
-}
-/**
- * Adapter interface for Circle API calls.
- * Allows swapping between simulation and live implementations.
- */
-interface CircleApiAdapter {
-    createWalletSet(name: string, custodyType: string): Promise<{
-        id: string;
-    }>;
-    createWallet(walletSetId: string, chain: Chain, custodyType: string): Promise<{
-        id: string;
-        address: string;
-    }>;
-    getWallet(walletId: string): Promise<{
-        id: string;
-        address: string;
-        chain: Chain;
-        state: string;
-    } | null>;
-    listWallets(walletSetId: string): Promise<{
-        id: string;
-        address: string;
-        chain: Chain;
-        state: string;
-    }[]>;
-    transfer(params: {
-        walletId: string;
-        destinationAddress: string;
-        amount: string;
-        chain: Chain;
-        token: string;
-    }): Promise<{
-        transferId: string;
-        transactionHash: string;
-    }>;
-    getBalance(walletId: string): Promise<{
-        balances: {
-            token: string;
-            amount: string;
-        }[];
-    }>;
-}
-/** Minimal interface for the Kontext client used by CircleWalletManager */
-interface KontextLike$2 {
-    log(input: {
-        type: string;
-        description: string;
-        agentId: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<ActionLog>;
-    logTransaction(input: LogTransactionInput): Promise<ActionLog>;
-    getTrustScore(agentId: string): Promise<{
-        score: number;
-    }>;
-    checkUsdcCompliance(tx: LogTransactionInput): {
-        compliant: boolean;
-        checks: ComplianceCheckResult[];
-        riskLevel: AnomalySeverity;
-        recommendations: string[];
-    };
-}
-/**
- * Manages Circle Programmable Wallets with integrated Kontext compliance
- * and audit logging.
- *
- * All wallet operations are automatically logged through Kontext's rolling
- * SHA-256 digest chain. Transfers are wrapped with compliance checks that
- * must pass before execution.
- *
- * @example
- * ```typescript
- * import { Kontext } from 'kontext-sdk';
- * import { CircleWalletManager } from 'kontext-sdk';
- *
- * const kontext = Kontext.init({ projectId: 'my-project', environment: 'production' });
- * const wallets = new CircleWalletManager(kontext, 'circle-api-key');
- *
- * const walletSet = await wallets.createWalletSet('Operations');
- * const wallet = await wallets.createWallet(walletSet.id, { chain: 'base' });
- *
- * const result = await wallets.transferWithCompliance({
- *   walletId: wallet.id,
- *   destinationAddress: '0x...',
- *   amount: '100',
- *   agent: 'payment-agent',
- * });
- * ```
- */
-declare class CircleWalletManager {
-    private readonly kontext;
-    private readonly adapter;
-    private readonly options;
-    private readonly isLiveMode;
-    private walletSets;
-    private wallets;
-    private walletSetWallets;
-    private auditTrail;
-    /**
-     * Create a new CircleWalletManager.
-     *
-     * @param kontextClient - Initialized Kontext SDK client
-     * @param circleApiKey - Circle API key (optional; omit for simulation mode)
-     * @param options - Configuration options
-     */
-    constructor(kontextClient: KontextLike$2, circleApiKey?: string, options?: CircleWalletOptions);
-    /**
-     * Create a new wallet set (a logical group of wallets).
-     *
-     * @param name - Human-readable name for the wallet set
-     * @param metadata - Optional metadata key-value pairs
-     * @returns The created WalletSet
-     */
-    createWalletSet(name: string, metadata?: Record<string, string>): Promise<WalletSet>;
-    /**
-     * Create a new wallet within a wallet set.
-     *
-     * @param walletSetId - Parent wallet set ID
-     * @param options - Wallet creation options
-     * @returns The created CircleWallet
-     */
-    createWallet(walletSetId: string, options: CreateWalletOptions): Promise<CircleWallet>;
-    /**
-     * Get a wallet by its ID.
-     *
-     * @param walletId - Wallet identifier
-     * @returns The CircleWallet, or throws if not found
-     */
-    getWallet(walletId: string): Promise<CircleWallet>;
-    /**
-     * List all wallets in a wallet set.
-     *
-     * @param walletSetId - Wallet set identifier
-     * @returns Array of CircleWallet records
-     */
-    listWallets(walletSetId: string): Promise<CircleWallet[]>;
-    /**
-     * Execute a USDC/EURC transfer with integrated compliance checks.
-     *
-     * The transfer flow:
-     * 1. Validate the source wallet exists and is live
-     * 2. Run Kontext compliance checks on the transaction
-     * 3. Get the agent's trust score
-     * 4. If compliance passes, execute the transfer via Circle
-     * 5. Log the entire operation through Kontext's audit system
-     *
-     * @param input - Transfer details
-     * @returns CompliantTransferResult with status and audit trail
-     */
-    transferWithCompliance(input: CompliantTransferInput): Promise<CompliantTransferResult>;
-    /**
-     * Get the token balances for a wallet.
-     *
-     * @param walletId - Wallet identifier
-     * @param chain - Optional chain override
-     * @returns WalletBalance with token amounts
-     */
-    getBalance(walletId: string, chain?: Chain): Promise<WalletBalance>;
-    /**
-     * Get the Kontext audit trail for a specific wallet.
-     *
-     * @param walletId - Wallet identifier
-     * @returns Array of ActionLog entries related to this wallet
-     */
-    getWalletAuditTrail(walletId: string): Promise<ActionLog[]>;
-    /**
-     * Run Kontext compliance checks on a transfer.
-     */
-    private runComplianceCheck;
-    /**
-     * Log an operation through the Kontext client.
-     */
-    private logOperation;
-}
-
-/** Input for screening a transaction */
-interface ScreenTransactionInput {
-    /** Sender address */
-    from: string;
-    /** Recipient address */
-    to: string;
-    /** Transfer amount */
-    amount: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Token being transferred */
-    token?: string;
-}
-/** Result of dual screening (Circle + Kontext) */
-interface DualScreenResult {
-    /** Circle's screening result */
-    circleScreening: {
-        /** Whether the transaction is approved by Circle */
-        approved: boolean;
-        /** Risk level from Circle's screening */
-        riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'SEVERE';
-        /** Flags raised by Circle's screening */
-        flags: string[];
-    };
-    /** Kontext's screening result */
-    kontextScreening: {
-        /** Trust score (0-100) */
-        trustScore: number;
-        /** Whether anomaly was detected */
-        anomalyDetected: boolean;
-        /** Whether compliance checks passed */
-        complianceApproved: boolean;
-        /** Flags raised by Kontext screening */
-        flags: string[];
-    };
-    /** Combined decision from both systems */
-    combinedDecision: 'APPROVE' | 'REVIEW' | 'BLOCK';
-    /** Kontext audit log ID */
-    auditLogId: string;
-}
-/** Result of screening a single address */
-interface AddressScreenResult {
-    /** The screened address */
-    address: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Whether the address is sanctioned */
-    sanctioned: boolean;
-    /** Risk level */
-    riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'SEVERE';
-    /** Flags raised */
-    flags: string[];
-    /** Screening timestamp */
-    screenedAt: string;
-}
-/** Input for comprehensive risk assessment */
-interface RiskAssessmentInput {
-    /** Address to assess */
-    address: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Agent ID for trust scoring */
-    agentId?: string;
-    /** Transaction amount for contextual assessment */
-    amount?: string;
-    /** Token for contextual assessment */
-    token?: string;
-}
-/** Comprehensive risk assessment result */
-interface ComprehensiveRiskResult {
-    /** Overall risk level */
-    overallRisk: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-    /** Circle-derived risk score (0-100) */
-    circleRiskScore: number;
-    /** Kontext trust score (0-100) */
-    kontextTrustScore: number;
-    /** Combined weighted score (0-100, higher = riskier) */
-    combinedScore: number;
-    /** Action recommendation */
-    recommendation: 'PROCEED' | 'MANUAL_REVIEW' | 'BLOCK';
-    /** Individual risk factors */
-    factors: ComprehensiveRiskFactor[];
-    /** Kontext audit log ID */
-    auditLogId: string;
-}
-/** Risk factor in comprehensive assessment */
-interface ComprehensiveRiskFactor {
-    /** Factor name */
-    name: string;
-    /** Risk score contribution (0-100) */
-    score: number;
-    /** Human-readable description */
-    description: string;
-}
-/**
- * Adapter interface for Circle's compliance screening API.
- */
-interface CircleComplianceAdapter {
-    screenTransaction(input: ScreenTransactionInput): Promise<{
-        approved: boolean;
-        riskLevel: string;
-        flags: string[];
-    }>;
-    screenAddress(address: string, chain: Chain): Promise<{
-        sanctioned: boolean;
-        riskLevel: string;
-        flags: string[];
-    }>;
-}
-/** Minimal interface for the Kontext client used by CircleComplianceEngine */
-interface KontextLike$1 {
-    log(input: {
-        type: string;
-        description: string;
-        agentId: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<ActionLog>;
-    getTrustScore(agentId: string): Promise<{
-        score: number;
-    }>;
-    checkUsdcCompliance(tx: LogTransactionInput): {
-        compliant: boolean;
-        checks: ComplianceCheckResult[];
-        riskLevel: AnomalySeverity;
-        recommendations: string[];
-    };
-}
-/**
- * Dual-layer compliance engine combining Circle's transaction screening
- * with Kontext's trust scoring and anomaly detection.
- *
- * Every screening operation is logged through Kontext's tamper-evident
- * audit system for regulatory compliance.
- *
- * @example
- * ```typescript
- * const kontext = Kontext.init({ projectId: 'my-project', environment: 'production' });
- * const compliance = new CircleComplianceEngine(kontext);
- *
- * const result = await compliance.screenTransaction({
- *   from: '0xSender...',
- *   to: '0xRecipient...',
- *   amount: '5000',
- *   chain: 'base',
- * });
- *
- * if (result.combinedDecision === 'BLOCK') {
- *   console.log('Transaction blocked');
- * }
- * ```
- */
-declare class CircleComplianceEngine {
-    private readonly kontext;
-    private readonly adapter;
-    private readonly isLiveMode;
-    /**
-     * Create a new CircleComplianceEngine.
-     *
-     * @param kontextClient - Initialized Kontext SDK client
-     * @param circleApiKey - Circle API key (optional; omit for simulation mode)
-     */
-    constructor(kontextClient: KontextLike$1, circleApiKey?: string);
-    /**
-     * Screen a transaction through both Circle and Kontext compliance systems.
-     *
-     * @param input - Transaction details to screen
-     * @returns DualScreenResult with combined decision
-     */
-    screenTransaction(input: ScreenTransactionInput): Promise<DualScreenResult>;
-    /**
-     * Screen an address for sanctions and risk.
-     *
-     * @param address - On-chain address to screen
-     * @param chain - Blockchain network
-     * @returns AddressScreenResult with risk assessment
-     */
-    screenAddress(address: string, chain: Chain): Promise<AddressScreenResult>;
-    /**
-     * Get a comprehensive risk assessment combining Circle screening with
-     * Kontext trust scoring.
-     *
-     * @param input - Assessment input
-     * @returns ComprehensiveRiskResult with combined scoring
-     */
-    getComprehensiveRisk(input: RiskAssessmentInput): Promise<ComprehensiveRiskResult>;
-    /**
-     * Run Kontext-side screening using USDC compliance checks and trust scoring.
-     */
-    private runKontextScreening;
-    /**
-     * Determine the combined decision based on both screening results.
-     */
-    private determineCombinedDecision;
-    /**
-     * Convert a risk level string to a numeric score.
-     */
-    private riskLevelToScore;
-}
-
-/** Gas sponsorship eligibility result */
-interface GasEligibility {
-    /** Whether the wallet is eligible for sponsored gas */
-    eligible: boolean;
-    /** Maximum sponsored amount in native token */
-    maxSponsoredAmount: string;
-    /** Supported operations */
-    supportedOperations: string[];
-    /** Remaining daily quota */
-    remainingDailyQuota: string;
-    /** Reason if not eligible */
-    reason?: string;
-}
-/** Input for gas estimation */
-interface GasEstimateInput {
-    /** Source wallet ID */
-    walletId: string;
-    /** Destination address */
-    destinationAddress: string;
-    /** Transfer amount */
-    amount: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Token being transferred */
-    token?: string;
-}
-/** Gas estimate result */
-interface GasEstimate {
-    /** Estimated gas cost in native token */
-    estimatedGas: string;
-    /** Whether this gas would be sponsored */
-    sponsored: boolean;
-    /** Amount the user would pay (zero if fully sponsored) */
-    userCost: string;
-    /** Amount Circle would sponsor */
-    sponsoredAmount: string;
-    /** Chain the estimate is for */
-    chain: Chain;
-    /** Native token used for gas */
-    nativeToken: string;
-}
-/** Input for logging a gas sponsorship event */
-interface GasSponsorshipLog {
-    /** Wallet ID that received sponsorship */
-    walletId: string;
-    /** Transaction hash of the sponsored transaction */
-    transactionHash: string;
-    /** Amount of gas sponsored */
-    sponsoredGasAmount: string;
-    /** Chain the sponsorship occurred on */
-    chain: Chain;
-    /** Agent that initiated the transaction */
-    agent?: string;
-    /** Additional metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Adapter interface for Circle Gas Station API.
- */
-interface GasStationAdapter {
-    checkEligibility(walletId: string, chain: Chain): Promise<GasEligibility>;
-    estimateGas(input: GasEstimateInput): Promise<GasEstimate>;
-}
-/** Minimal interface for the Kontext client used by GasStationManager */
-interface KontextLike {
-    log(input: {
-        type: string;
-        description: string;
-        agentId: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<ActionLog>;
-}
-/**
- * Manages Circle Gas Station (sponsored gas) with integrated Kontext audit
- * logging for compliance tracking.
- *
- * Gas sponsorship events are logged through Kontext's tamper-evident audit
- * system to maintain a clear record of subsidized transactions.
- *
- * @example
- * ```typescript
- * const kontext = Kontext.init({ projectId: 'my-project', environment: 'production' });
- * const gasStation = new GasStationManager(kontext);
- *
- * const eligibility = await gasStation.checkEligibility('wallet-123', 'base');
- * if (eligibility.eligible) {
- *   const estimate = await gasStation.estimateGas({
- *     walletId: 'wallet-123',
- *     destinationAddress: '0x...',
- *     amount: '100',
- *     chain: 'base',
- *   });
- *   console.log(`Gas sponsored: ${estimate.sponsored}`);
- * }
- * ```
- */
-declare class GasStationManager {
-    private readonly kontext;
-    private readonly adapter;
-    private readonly isLiveMode;
-    /**
-     * Create a new GasStationManager.
-     *
-     * @param kontextClient - Initialized Kontext SDK client
-     * @param circleApiKey - Circle API key (optional; omit for simulation mode)
-     */
-    constructor(kontextClient: KontextLike, circleApiKey?: string);
-    /**
-     * Check if a wallet is eligible for gas sponsorship on a given chain.
-     *
-     * @param walletId - Wallet identifier
-     * @param chain - Blockchain network
-     * @returns GasEligibility with details
-     */
-    checkEligibility(walletId: string, chain: Chain): Promise<GasEligibility>;
-    /**
-     * Estimate gas cost for a transfer and determine sponsorship.
-     *
-     * @param input - Transfer details for estimation
-     * @returns GasEstimate with sponsorship information
-     */
-    estimateGas(input: GasEstimateInput): Promise<GasEstimate>;
-    /**
-     * Log a gas sponsorship event for audit purposes.
-     *
-     * Call this after a sponsored transaction has been confirmed on-chain
-     * to record the sponsorship in Kontext's audit trail.
-     *
-     * @param input - Sponsorship event details
-     * @returns The created ActionLog entry
-     */
-    logGasSponsorship(input: GasSponsorshipLog): Promise<ActionLog>;
-    /**
-     * Get the list of chains eligible for gas sponsorship.
-     *
-     * @returns Array of supported chains
-     */
-    static getEligibleChains(): Chain[];
-    /**
-     * Get the native gas token for a chain.
-     *
-     * @param chain - Blockchain network
-     * @returns Native token symbol
-     */
-    static getNativeToken(chain: Chain): string;
-}
-
-/** Supported webhook event types */
-type WebhookEventType = 'anomaly.detected' | 'task.confirmed' | 'task.failed' | 'trust.score_changed' | 'approval.required' | 'approval.decided';
-/** Webhook registration configuration */
-interface WebhookConfig {
-    /** Unique identifier for this webhook */
-    id: string;
-    /** Target URL to receive webhook POST requests */
-    url: string;
-    /** Event types to listen for */
-    events: WebhookEventType[];
-    /** Optional secret for HMAC signature verification */
-    secret?: string;
-    /** Whether this webhook is active */
-    active: boolean;
-    /** When this webhook was registered */
-    createdAt: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Input for registering a new webhook */
-interface RegisterWebhookInput {
-    /** Target URL */
-    url: string;
-    /** Event types to listen for */
-    events: WebhookEventType[];
-    /** Optional secret for payload signing */
-    secret?: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Webhook delivery payload */
-interface WebhookPayload {
-    /** Unique delivery ID */
-    id: string;
-    /** Event type */
-    event: WebhookEventType;
-    /** Timestamp of the event */
-    timestamp: string;
-    /** Event-specific data */
-    data: Record<string, unknown>;
-}
-/** Result of a webhook delivery attempt */
-interface WebhookDeliveryResult {
-    /** Webhook ID */
-    webhookId: string;
-    /** Delivery payload ID */
-    payloadId: string;
-    /** Whether delivery succeeded */
-    success: boolean;
-    /** HTTP status code (if applicable) */
-    statusCode: number | null;
-    /** Number of attempts made */
-    attempts: number;
-    /** Error message if failed */
-    error: string | null;
-    /** Timestamp of last attempt */
-    lastAttemptAt: string;
-}
-/** Retry configuration */
-interface WebhookRetryConfig {
-    /** Maximum number of retry attempts */
-    maxRetries: number;
-    /** Base delay in milliseconds for exponential backoff */
-    baseDelayMs: number;
-    /** Maximum delay in milliseconds */
-    maxDelayMs: number;
-}
-/**
- * WebhookManager handles registration and delivery of webhook notifications
- * for SDK events including anomaly detection, task confirmation, and trust
- * score changes.
- *
- * Features:
- * - Register multiple webhook URLs with event type filtering
- * - Automatic retry with exponential backoff on delivery failure
- * - Delivery result tracking
- * - Enable/disable individual webhooks
- *
- * @example
- * ```typescript
- * const manager = new WebhookManager();
- *
- * manager.register({
- *   url: 'https://example.com/webhooks/kontext',
- *   events: ['anomaly.detected', 'task.confirmed'],
- * });
- *
- * // Webhooks fire automatically when events occur
- * await manager.notifyAnomalyDetected(anomalyEvent);
- * ```
- */
-declare class WebhookManager {
-    private webhooks;
-    private deliveryResults;
-    private retryConfig;
-    private fetchFn;
-    constructor(retryConfig?: Partial<WebhookRetryConfig>, fetchFn?: typeof fetch);
-    /**
-     * Register a new webhook endpoint.
-     *
-     * @param input - Webhook configuration
-     * @returns The created WebhookConfig
-     */
-    register(input: RegisterWebhookInput): WebhookConfig;
-    /**
-     * Unregister a webhook by ID.
-     *
-     * @param webhookId - The webhook to remove
-     * @returns Whether the webhook was found and removed
-     */
-    unregister(webhookId: string): boolean;
-    /**
-     * Enable or disable a webhook.
-     *
-     * @param webhookId - The webhook to update
-     * @param active - Whether to enable or disable
-     * @returns The updated WebhookConfig, or undefined if not found
-     */
-    setActive(webhookId: string, active: boolean): WebhookConfig | undefined;
-    /**
-     * Get all registered webhooks.
-     * Secrets are redacted to prevent accidental exposure in logs or API responses.
-     */
-    getWebhooks(): WebhookConfig[];
-    /**
-     * Get a specific webhook by ID.
-     * The secret is redacted to prevent accidental exposure in logs or API responses.
-     */
-    getWebhook(webhookId: string): WebhookConfig | undefined;
-    /**
-     * Get delivery results for a specific webhook or all webhooks.
-     */
-    getDeliveryResults(webhookId?: string): WebhookDeliveryResult[];
-    /**
-     * Notify all subscribed webhooks of an anomaly detection event.
-     *
-     * @param anomaly - The detected anomaly event
-     * @returns Array of delivery results
-     */
-    notifyAnomalyDetected(anomaly: AnomalyEvent): Promise<WebhookDeliveryResult[]>;
-    /**
-     * Notify all subscribed webhooks of a task confirmation.
-     *
-     * @param task - The confirmed task
-     * @returns Array of delivery results
-     */
-    notifyTaskConfirmed(task: Task): Promise<WebhookDeliveryResult[]>;
-    /**
-     * Notify all subscribed webhooks of a task failure.
-     *
-     * @param task - The failed task
-     * @returns Array of delivery results
-     */
-    notifyTaskFailed(task: Task): Promise<WebhookDeliveryResult[]>;
-    /**
-     * Notify all subscribed webhooks of a trust score change.
-     *
-     * @param trustScore - The new trust score
-     * @param previousScore - The previous score value (if known)
-     * @returns Array of delivery results
-     */
-    notifyTrustScoreChanged(trustScore: TrustScore, previousScore?: number): Promise<WebhookDeliveryResult[]>;
-    /**
-     * Notify all subscribed webhooks that an approval is required.
-     *
-     * @param request - The approval request that was created
-     * @returns Array of delivery results
-     */
-    notifyApprovalRequired(request: ApprovalRequest): Promise<WebhookDeliveryResult[]>;
-    /**
-     * Notify all subscribed webhooks that an approval decision was made.
-     *
-     * @param request - The approval request with the decision
-     * @returns Array of delivery results
-     */
-    notifyApprovalDecided(request: ApprovalRequest): Promise<WebhookDeliveryResult[]>;
-    private deliver;
-    private deliverToWebhook;
-    private computeSignature;
-    private sleep;
-    /**
-     * Verify a webhook signature using constant-time comparison to prevent
-     * timing attacks. Use this in your webhook handler to validate incoming
-     * payloads from Kontext.
-     *
-     * @param payload - The raw JSON payload body (string)
-     * @param signature - The signature from the X-Kontext-Signature header
-     * @param secret - The webhook secret used during registration
-     * @returns Whether the signature is valid
-     *
-     * @example
-     * ```typescript
-     * const isValid = WebhookManager.verifySignature(
-     *   req.body, // raw JSON string
-     *   req.headers['x-kontext-signature'],
-     *   'my-webhook-secret',
-     * );
-     * if (!isValid) return res.status(401).send('Invalid signature');
-     * ```
-     */
-    static verifySignature(payload: string, signature: string, secret: string): boolean;
-}
-
-/** AI operation types recognized by the Vercel AI SDK middleware. */
-type AIOperationType = 'generate' | 'stream' | 'object' | 'embed' | 'embedMany';
-/**
- * Configuration options for the Kontext Vercel AI SDK middleware.
- *
- * Controls which operations are logged, how tool calls are handled,
- * and whether financial compliance checks are triggered.
- */
-interface KontextAIOptions {
-    /** Agent identifier for audit logs. Defaults to `'vercel-ai'`. */
-    agentId?: string;
-    /**
-     * Tool names that involve financial transactions.
-     * When a tool call matches one of these names, Kontext will automatically
-     * log a `LogTransactionInput` with the extracted amount, triggering
-     * compliance checks and anomaly detection.
-     */
-    financialTools?: string[];
-    /**
-     * Whether to include tool call arguments in the audit log.
-     * Defaults to `false` for privacy. Set to `true` for full traceability.
-     */
-    logToolArgs?: boolean;
-    /**
-     * Default currency for financial tool calls.
-     * Defaults to `'USDC'`.
-     */
-    defaultCurrency?: string;
-    /**
-     * Trust score threshold (0-100). If the agent's trust score is below
-     * this threshold, tool calls will be blocked and `onBlocked` will fire.
-     */
-    trustThreshold?: number;
-    /**
-     * Callback invoked when a tool call is blocked due to trust threshold
-     * or other compliance rules.
-     */
-    onBlocked?: (toolCall: BlockedToolCall, reason: string) => void;
-}
-/**
- * A tool call that was blocked by the Kontext middleware.
- */
-interface BlockedToolCall {
-    /** The name of the tool that was blocked. */
-    toolName: string;
-    /** The arguments that were passed to the tool. */
-    args: unknown;
-}
-/**
- * Input options for the one-line `createKontextAI` setup function.
- * Combines Kontext SDK configuration with AI middleware options.
- */
-interface CreateKontextAIInput {
-    /** Kontext project identifier. */
-    projectId: string;
-    /** Deployment environment. */
-    environment?: Environment;
-    /** Optional API key for cloud mode. */
-    apiKey?: string;
-    /** Enable debug logging. */
-    debug?: boolean;
-    /** Agent identifier for audit logs. */
-    agentId?: string;
-    /** Tool names that involve financial transactions. */
-    financialTools?: string[];
-    /** Whether to log tool arguments. */
-    logToolArgs?: boolean;
-    /** Default currency for financial tool calls. */
-    defaultCurrency?: string;
-    /** Trust score threshold for blocking tool calls. */
-    trustThreshold?: number;
-    /** Callback when a tool call is blocked. */
-    onBlocked?: (toolCall: BlockedToolCall, reason: string) => void;
-}
-/**
- * Return type from `createKontextAI`.
- */
-interface CreateKontextAIResult {
-    /** The wrapped language model with Kontext middleware applied. */
-    model: unknown;
-    /** The Kontext client instance for direct access to audit, trust, and compliance APIs. */
-    kontext: Kontext;
-}
-/**
- * Options for the `withKontext` Next.js route handler wrapper.
- */
-interface WithKontextOptions {
-    /** Kontext project identifier. */
-    projectId?: string;
-    /** Deployment environment. */
-    environment?: Environment;
-    /** Optional API key for cloud mode. */
-    apiKey?: string;
-    /** Agent identifier for audit logs. */
-    agentId?: string;
-    /** Enable debug logging. */
-    debug?: boolean;
-}
-/**
- * Context object passed to route handlers wrapped with `withKontext`.
- * Provides a pre-configured Kontext client and a helper to wrap AI models.
- */
-interface KontextAIContext {
-    /** The Kontext client instance. */
-    kontext: Kontext;
-    /**
-     * Wrap an AI model with Kontext middleware for automatic audit logging.
-     *
-     * @param model - A Vercel AI SDK language model
-     * @param options - Additional middleware options
-     * @returns The wrapped model
-     */
-    wrapModel: (model: unknown, options?: KontextAIOptions) => unknown;
-    /** Unique request identifier for correlating logs. */
-    requestId: string;
-}
-/**
- * Creates a Kontext middleware object for the Vercel AI SDK.
- *
- * This middleware intercepts every `generateText()`, `streamText()`, and
- * `generateObject()` call and automatically logs each operation, tool
- * invocation, and result into the Kontext tamper-evident digest chain.
- *
- * The middleware conforms to the Vercel AI SDK middleware interface:
- * - `transformParams` — Logs the AI request before execution
- * - `wrapGenerate` — Wraps synchronous generation to log tool calls and results
- * - `wrapStream` — Wraps streaming generation to log stream lifecycle events
- *
- * @param kontext - An initialized Kontext client instance
- * @param options - Middleware configuration options
- * @returns A Vercel AI SDK middleware object
- *
- * @example
- * ```typescript
- * import { Kontext } from 'kontext-sdk';
- * import { experimental_wrapLanguageModel as wrapLanguageModel } from 'ai';
- * import { openai } from '@ai-sdk/openai';
- *
- * const kontext = Kontext.init({ projectId: 'my-app', environment: 'production' });
- *
- * const model = wrapLanguageModel({
- *   model: openai('gpt-4o'),
- *   middleware: kontextMiddleware(kontext, {
- *     agentId: 'payment-agent',
- *     financialTools: ['transfer_usdc', 'send_payment'],
- *   }),
- * });
- *
- * // Every generateText / streamText call is now automatically audited.
- * ```
- */
-declare function kontextMiddleware(kontext: Kontext, options?: KontextAIOptions): {
-    transformParams: (ctx: {
-        params: Record<string, unknown>;
-        type: string;
-    }) => Promise<Record<string, unknown>>;
-    wrapGenerate: (ctx: {
-        doGenerate: () => Promise<Record<string, unknown>>;
-        params: Record<string, unknown>;
-    }) => Promise<Record<string, unknown>>;
-    wrapStream: (ctx: {
-        doStream: () => Promise<{
-            stream: ReadableStream;
-            [key: string]: unknown;
-        }>;
-        params: Record<string, unknown>;
-    }) => Promise<{
-        [key: string]: unknown;
-        stream: ReadableStream;
-    }>;
-};
-/**
- * Wraps a Vercel AI SDK language model with Kontext middleware for
- * automatic audit logging of all AI operations.
- *
- * This function applies the Kontext middleware using the Vercel AI SDK's
- * `experimental_wrapLanguageModel` pattern. The returned model can be
- * used directly with `generateText()`, `streamText()`, and `generateObject()`.
- *
- * @param model - A Vercel AI SDK language model (e.g., `openai('gpt-4o')`)
- * @param kontext - An initialized Kontext client instance
- * @param options - Middleware configuration options
- * @returns A wrapped language model with Kontext audit logging
- *
- * @example
- * ```typescript
- * import { openai } from '@ai-sdk/openai';
- * import { Kontext, kontextWrapModel } from 'kontext-sdk';
- * import { generateText } from 'ai';
- *
- * const kontext = Kontext.init({ projectId: 'my-app', environment: 'production' });
- * const model = kontextWrapModel(openai('gpt-4o'), kontext, {
- *   agentId: 'support-agent',
- *   financialTools: ['transfer_usdc'],
- * });
- *
- * const result = await generateText({ model, prompt: 'Send 100 USDC to Alice' });
- * // All operations automatically logged with SHA-256 digest chains
- * ```
- */
-declare function kontextWrapModel(model: unknown, kontext: Kontext, options?: KontextAIOptions): unknown;
-/**
- * One-line Kontext + Vercel AI SDK setup.
- *
- * Creates a Kontext client and wraps a Vercel AI SDK language model in a
- * single function call. The returned model automatically logs every AI
- * operation with tamper-evident SHA-256 digest chains.
- *
- * @param model - A Vercel AI SDK language model (e.g., `openai('gpt-4o')`)
- * @param input - Combined Kontext and AI middleware configuration
- * @returns An object containing the wrapped model and the Kontext client
- *
- * @example
- * ```typescript
- * import { openai } from '@ai-sdk/openai';
- * import { createKontextAI } from 'kontext-sdk';
- * import { generateText } from 'ai';
- *
- * const { model, kontext } = createKontextAI(openai('gpt-4o'), {
- *   projectId: 'payment-app',
- *   agentId: 'payment-agent',
- *   financialTools: ['transfer_usdc', 'send_payment'],
- * });
- *
- * const result = await generateText({ model, tools, prompt: 'Pay 50 USDC' });
- * // All tool calls are automatically logged with digest chains.
- *
- * // Access the audit trail
- * const chain = kontext.exportDigestChain();
- * console.log('Terminal digest:', kontext.getTerminalDigest());
- * ```
- */
-declare function createKontextAI(model: unknown, input: CreateKontextAIInput): CreateKontextAIResult;
-/**
- * Wraps a Next.js API route handler with Kontext audit logging.
- *
- * Every incoming request is logged with a unique request ID, and a
- * pre-configured `KontextAIContext` is passed to the handler. The context
- * provides a `wrapModel()` helper for wrapping AI models inside the handler.
- *
- * On completion, the request lifecycle (including duration and status code)
- * is logged to the digest chain.
- *
- * @param handler - The route handler function
- * @param options - Kontext configuration for the route
- * @returns A standard Next.js route handler function
- *
- * @example
- * ```typescript
- * // app/api/chat/route.ts
- * import { withKontext } from 'kontext-sdk';
- * import { openai } from '@ai-sdk/openai';
- * import { generateText } from 'ai';
- *
- * export const POST = withKontext(async (req, ctx) => {
- *   const { messages } = await req.json();
- *
- *   const model = ctx.wrapModel(openai('gpt-4o'), {
- *     financialTools: ['transfer_usdc'],
- *   });
- *
- *   const result = await generateText({ model, messages });
- *   return Response.json(result);
- * }, {
- *   projectId: 'my-app',
- *   environment: 'production',
- * });
- * ```
- */
-declare function withKontext(handler: (req: Request, ctx: KontextAIContext) => Promise<Response>, options?: WithKontextOptions): (req: Request) => Promise<Response>;
-/**
- * Extract a numeric amount from tool call arguments.
- *
- * Searches for common field names (`amount`, `value`, `total`, `payment`,
- * `transfer`) in the arguments object and returns the first valid number found.
- *
- * @param args - The tool call arguments (typically a JSON object)
- * @returns The extracted numeric amount, or `null` if no amount was found
- */
-declare function extractAmount(args: unknown): number | null;
-
-/** CFTC account classification for segregated funds */
-type CFTCAccountClass = 'futures' | 'cleared_swaps' | '30.7';
-/** Digital asset classification per CFTC Letter 26-05 */
-type DigitalAssetType = 'payment_stablecoin' | 'btc' | 'eth' | 'other_digital_asset';
-/** Collateral valuation record for a digital asset held as customer margin */
-interface CollateralValuation {
-    /** Unique valuation ID */
-    id: string;
-    /** ISO 8601 timestamp of the valuation */
-    timestamp: string;
-    /** CFTC account class (futures, cleared_swaps, 30.7) */
-    accountClass: CFTCAccountClass;
-    /** Type of digital asset */
-    assetType: DigitalAssetType;
-    /** Asset symbol (e.g., USDC, BTC, ETH) */
-    assetSymbol: string;
-    /** Quantity of asset held */
-    quantity: number;
-    /** Market value in USD */
-    marketValue: number;
-    /** Haircut percentage applied (0.0 - 1.0) */
-    haircutPercentage: number;
-    /** Absolute haircut value in USD */
-    haircutValue: number;
-    /** Net collateral value after haircut (marketValue - haircutValue) */
-    netValue: number;
-    /** DCO reference for the haircut schedule (optional) */
-    dcoReference?: string;
-    /** Valuation methodology */
-    valuationMethod: string;
-    /** Agent that performed the valuation */
-    agentId: string;
-    /** Additional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Daily segregation calculation per CFTC Reg 1.20 / 30.7 */
-interface SegregationCalculation {
-    /** Unique calculation ID */
-    id: string;
-    /** ISO 8601 timestamp of the calculation */
-    timestamp: string;
-    /** CFTC account class */
-    accountClass: CFTCAccountClass;
-    /** Total customer funds on deposit */
-    totalCustomerFunds: number;
-    /** Required segregated amount */
-    requiredAmount: number;
-    /** Excess (positive) or deficit (negative) */
-    excessDeficit: number;
-    /** Breakdown of digital assets in the segregation calculation */
-    digitalAssetBreakdown: Array<{
-        assetType: DigitalAssetType;
-        assetSymbol: string;
-        quantity: number;
-        marketValue: number;
-        haircutValue: number;
-        netValue: number;
-    }>;
-    /** Residual interest amount */
-    residualInterest: number;
-    /** Agent that performed the calculation */
-    agentId: string;
-    /** Additional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Weekly digital asset report aggregating collateral positions */
-interface DigitalAssetReport {
-    /** Unique report ID */
-    id: string;
-    /** Date the report was generated (ISO 8601 date string) */
-    reportDate: string;
-    /** Start of the reporting period (ISO 8601) */
-    reportPeriodStart: string;
-    /** End of the reporting period (ISO 8601) */
-    reportPeriodEnd: string;
-    /** CFTC account class */
-    accountClass: CFTCAccountClass;
-    /** Aggregated asset positions */
-    assets: Array<{
-        assetType: DigitalAssetType;
-        assetSymbol: string;
-        totalQuantity: number;
-        totalMarketValue: number;
-        totalHaircutValue: number;
-        totalNetValue: number;
-    }>;
-    /** Sum of all asset market values */
-    totalMarketValue: number;
-    /** Sum of all asset net values (after haircuts) */
-    totalNetValue: number;
-    /** ISO 8601 timestamp when the report was generated */
-    generatedAt: string;
-}
-/** Incident report for cybersecurity or operational events */
-interface IncidentReport {
-    /** Unique incident ID */
-    id: string;
-    /** ISO 8601 timestamp of the incident */
-    timestamp: string;
-    /** Severity level */
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    /** Type of incident */
-    incidentType: 'cybersecurity' | 'operational' | 'system_failure' | 'disruption';
-    /** Description of the incident */
-    description: string;
-    /** Systems affected by the incident */
-    affectedSystems: string[];
-    /** Number of customers affected (optional) */
-    affectedCustomerCount?: number;
-    /** Financial impact in USD (optional) */
-    financialImpact?: number;
-    /** Current resolution status */
-    resolutionStatus: 'open' | 'investigating' | 'resolved';
-    /** Agent that reported the incident */
-    agentId: string;
-    /** Additional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Configuration options for the CFTC compliance module */
-interface CFTCComplianceConfig {
-    /** Minimum haircut for non-BTC/ETH, non-stablecoin digital assets (default 0.20) */
-    minimumNonBtcEthHaircut?: number;
-    /** Whether to enforce haircut validation on collateral logging (default true) */
-    enableHaircutValidation?: boolean;
-    /** Whether to enable weekly reporting features */
-    enableWeeklyReporting?: boolean;
-    /** Date from which to start generating reports */
-    reportingStartDate?: Date;
-}
-/** Result of a haircut validation check */
-interface HaircutValidationResult {
-    /** Whether the haircut meets the minimum requirement */
-    valid: boolean;
-    /** The minimum required haircut for this asset type */
-    minimumRequired: number;
-    /** Human-readable explanation */
-    message: string;
-}
-/**
- * CFTC compliance module for FCM digital asset margin requirements.
- *
- * Implements the record-keeping and reporting requirements introduced by
- * CFTC Letter No. 26-05 (Feb 6, 2026), which permits FCMs to accept
- * stablecoins and digital assets as customer margin collateral.
- *
- * @example
- * ```typescript
- * const cftc = new CFTCCompliance();
- *
- * // Log a collateral valuation
- * const valuation = cftc.logCollateralValuation({
- *   accountClass: 'futures',
- *   assetType: 'payment_stablecoin',
- *   assetSymbol: 'USDC',
- *   quantity: 1_000_000,
- *   marketValue: 1_000_000,
- *   haircutPercentage: 0.02,
- *   haircutValue: 20_000,
- *   netValue: 980_000,
- *   valuationMethod: 'mark_to_market',
- *   agentId: 'margin-agent-1',
- * });
- *
- * // Generate a weekly report
- * const report = cftc.generateWeeklyDigitalAssetReport(
- *   'futures',
- *   new Date('2026-02-01'),
- *   new Date('2026-02-07'),
- * );
- * ```
- */
-declare class CFTCCompliance {
-    private readonly config;
-    private collateralValuations;
-    private segregationCalculations;
-    private incidents;
-    constructor(config?: CFTCComplianceConfig);
-    /**
-     * Log a collateral valuation for a digital asset held as customer margin.
-     *
-     * Validates the haircut percentage against CFTC requirements when
-     * `enableHaircutValidation` is true (default).
-     *
-     * @param input - Collateral valuation data (id and timestamp are auto-generated if omitted)
-     * @returns The stored CollateralValuation record
-     * @throws Error if haircut validation fails for the given asset type
-     */
-    logCollateralValuation(input: Omit<CollateralValuation, 'id' | 'timestamp'> & {
-        id?: string;
-        timestamp?: string;
-    }): CollateralValuation;
-    /**
-     * Log a daily segregation calculation for a given account class.
-     *
-     * @param input - Segregation calculation data (id and timestamp are auto-generated if omitted)
-     * @returns The stored SegregationCalculation record
-     */
-    logSegregationCalculation(input: Omit<SegregationCalculation, 'id' | 'timestamp'> & {
-        id?: string;
-        timestamp?: string;
-    }): SegregationCalculation;
-    /**
-     * Log an incident (cybersecurity, operational, system failure, or disruption).
-     *
-     * @param input - Incident data (id and timestamp are auto-generated if omitted)
-     * @returns The stored IncidentReport record
-     */
-    logIncident(input: Omit<IncidentReport, 'id' | 'timestamp'> & {
-        id?: string;
-        timestamp?: string;
-    }): IncidentReport;
-    /**
-     * Generate a weekly digital asset report aggregating collateral valuations
-     * for a given account class and date range.
-     *
-     * @param accountClass - The CFTC account class to report on
-     * @param periodStart - Start of the reporting period
-     * @param periodEnd - End of the reporting period
-     * @returns DigitalAssetReport with aggregated positions
-     */
-    generateWeeklyDigitalAssetReport(accountClass: CFTCAccountClass, periodStart: Date, periodEnd: Date): DigitalAssetReport;
-    /**
-     * Get the most recent segregation calculation for a given account class
-     * and date.
-     *
-     * @param accountClass - The CFTC account class
-     * @param date - The date to retrieve the calculation for
-     * @returns The most recent SegregationCalculation for that day, or undefined
-     */
-    generateDailySegregationReport(accountClass: CFTCAccountClass, date: Date): SegregationCalculation | undefined;
-    /**
-     * Query collateral valuations with optional filters.
-     *
-     * @param filters - Optional filter criteria
-     * @returns Array of matching CollateralValuation records
-     */
-    getCollateralValuations(filters?: {
-        accountClass?: CFTCAccountClass;
-        assetType?: DigitalAssetType;
-        startDate?: Date;
-        endDate?: Date;
-    }): CollateralValuation[];
-    /**
-     * Query incident reports with optional filters.
-     *
-     * @param filters - Optional filter criteria
-     * @returns Array of matching IncidentReport records
-     */
-    getIncidents(filters?: {
-        severity?: IncidentReport['severity'];
-        status?: IncidentReport['resolutionStatus'];
-        startDate?: Date;
-        endDate?: Date;
-    }): IncidentReport[];
-    /**
-     * Query segregation calculations with optional filters.
-     *
-     * @param filters - Optional filter criteria
-     * @returns Array of matching SegregationCalculation records
-     */
-    getSegregationCalculations(filters?: {
-        accountClass?: CFTCAccountClass;
-        startDate?: Date;
-        endDate?: Date;
-    }): SegregationCalculation[];
-    /**
-     * Validate a haircut percentage against CFTC Letter 26-05 requirements.
-     *
-     * Rules:
-     * - Payment stablecoins: no minimum haircut required
-     * - BTC / ETH: no minimum (deferred to DCO haircut schedule)
-     * - Other digital assets: minimum 20% haircut required
-     *
-     * @param assetType - The digital asset type
-     * @param haircutPercentage - The proposed haircut (0.0 - 1.0)
-     * @returns HaircutValidationResult with validity, minimum, and message
-     */
-    validateHaircut(assetType: DigitalAssetType, haircutPercentage: number): HaircutValidationResult;
-    /**
-     * Export CFTC compliance data in JSON or CSV format.
-     *
-     * @param options - Export options including format, report type, and filters
-     * @returns Formatted string (JSON or CSV)
-     */
-    exportCFTCReport(options: {
-        format: 'json' | 'csv';
-        reportType: 'weekly_digital_assets' | 'daily_segregation' | 'incidents';
-        accountClass?: CFTCAccountClass;
-        startDate?: Date;
-        endDate?: Date;
-    }): string;
-}
-
-/** Risk categories matching Circle Compliance Engine taxonomy */
-type RiskCategory = 'SANCTIONS' | 'TERRORIST_FINANCING' | 'CSAM' | 'ILLICIT_BEHAVIOR' | 'GAMBLING' | 'FROZEN' | 'CUSTOM_BLOCKLIST' | 'PEP' | 'DARKNET' | 'RANSOMWARE' | 'MIXER' | 'SCAM' | 'STOLEN_FUNDS' | 'UNKNOWN';
-/** Risk severity tiers (aligned with Circle's scoring) */
-type RiskSeverity = 'BLOCKLIST' | 'SEVERE' | 'HIGH' | 'MEDIUM' | 'LOW' | 'NONE';
-/** Actions a screening rule can trigger */
-type ScreeningAction = 'DENY' | 'REVIEW' | 'FREEZE_WALLET' | 'ALERT' | 'ALLOW';
-/** Direction of transaction flow */
-type TransactionDirection = 'INBOUND' | 'OUTBOUND' | 'BOTH';
-/** A single risk signal from a screening provider */
-interface RiskSignal {
-    /** The provider that generated this signal */
-    provider: string;
-    /** Risk category */
-    category: RiskCategory;
-    /** Risk severity */
-    severity: RiskSeverity;
-    /** Numeric risk score (0-100) */
-    riskScore: number;
-    /** Actions recommended by this signal */
-    actions: ScreeningAction[];
-    /** Human-readable description of the risk */
-    description: string;
-    /** Optional entity name associated with the risk */
-    entityName?: string;
-    /** Optional entity type */
-    entityType?: string;
-    /** Whether this signal applies to inbound, outbound, or both */
-    direction: TransactionDirection;
-    /** Additional metadata from the provider */
-    metadata?: Record<string, unknown>;
-}
-/** Result from a single screening provider */
-interface ProviderScreeningResult {
-    /** Provider name */
-    provider: string;
-    /** Whether the address was found in this provider's data */
-    matched: boolean;
-    /** Risk signals detected */
-    signals: RiskSignal[];
-    /** Whether the screening was successful (false if provider errored) */
-    success: boolean;
-    /** Error message if the provider failed */
-    error?: string;
-    /** Screening latency in milliseconds */
-    latencyMs: number;
-    /** Timestamp of the screening */
-    screenedAt: string;
-}
-/** Input for screening an address */
-interface ScreenAddressInput {
-    /** The blockchain address to screen */
-    address: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Optional transaction amount for contextual risk */
-    amount?: string;
-    /** Optional counterparty address */
-    counterparty?: string;
-    /** Transaction direction */
-    direction?: TransactionDirection;
-}
-/** Input for screening a transaction */
-interface ScreenTransactionProviderInput {
-    /** Sender address */
-    from: string;
-    /** Recipient address */
-    to: string;
-    /** Transfer amount */
-    amount: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Token being transferred */
-    token?: string;
-}
-/**
- * Interface that all screening providers must implement.
- *
- * Providers are responsible for checking addresses/transactions against
- * their data source and returning structured risk signals.
- */
-interface ScreeningProvider {
-    /** Unique provider name (e.g., 'chainalysis-free', 'opensanctions') */
-    readonly name: string;
-    /** Risk categories this provider can detect */
-    readonly supportedCategories: RiskCategory[];
-    /** Chains this provider supports (empty = all chains) */
-    readonly supportedChains: Chain[];
-    /**
-     * Screen a single address for risk.
-     * Returns provider-specific risk signals.
-     */
-    screenAddress(input: ScreenAddressInput): Promise<ProviderScreeningResult>;
-    /**
-     * Screen a transaction (both sender and recipient).
-     * Default implementation screens both addresses individually.
-     */
-    screenTransaction?(input: ScreenTransactionProviderInput): Promise<ProviderScreeningResult>;
-    /**
-     * Initialize the provider (e.g., fetch initial data, warm caches).
-     * Called once when added to the aggregator.
-     */
-    initialize?(): Promise<void>;
-    /**
-     * Check if the provider is healthy and able to screen.
-     */
-    isHealthy(): Promise<boolean>;
-}
-/** A blocklist or allowlist entry */
-interface ListEntry {
-    /** The blockchain address */
-    address: string;
-    /** Which chains this entry applies to (empty = all) */
-    chains: Chain[];
-    /** Reason for listing */
-    reason: string;
-    /** Who added this entry */
-    addedBy: string;
-    /** When the entry was added */
-    addedAt: string;
-    /** Optional expiration date */
-    expiresAt?: string;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-}
-/** Blocklist manager configuration */
-interface BlocklistConfig {
-    /** Path to persist blocklist data (optional) */
-    persistPath?: string;
-    /** Whether allowlist takes priority over blocklist */
-    allowlistPriority?: boolean;
-    /** Current plan tier — required for plan gate enforcement (Pro+) */
-    plan?: PlanTier;
-}
-/** Aggregated screening result combining all provider results */
-interface UnifiedScreeningResult {
-    /** The screened address */
-    address: string;
-    /** Blockchain network */
-    chain: Chain;
-    /** Final aggregated decision */
-    decision: 'APPROVE' | 'REVIEW' | 'BLOCK';
-    /** Recommended actions (union of all provider actions) */
-    actions: ScreeningAction[];
-    /** Highest risk severity across all providers */
-    highestSeverity: RiskSeverity;
-    /** Aggregated risk score (0-100, weighted average across providers) */
-    aggregateRiskScore: number;
-    /** All risk categories detected across providers */
-    categories: RiskCategory[];
-    /** Individual provider results */
-    providerResults: ProviderScreeningResult[];
-    /** All risk signals from all providers */
-    allSignals: RiskSignal[];
-    /** Number of providers that were consulted */
-    providersConsulted: number;
-    /** Number of providers that succeeded */
-    providersSucceeded: number;
-    /** Total screening latency in milliseconds */
-    totalLatencyMs: number;
-    /** Screening timestamp */
-    screenedAt: string;
-    /** Whether the address is on the user's allowlist (overrides block) */
-    allowlisted: boolean;
-    /** Whether the address is on the user's blocklist */
-    blocklisted: boolean;
-}
-/** Configuration for the screening aggregator */
-interface ScreeningAggregatorConfig {
-    /** Minimum providers that must succeed for a valid result (default: 1) */
-    minProviderSuccess?: number;
-    /** Timeout per provider in milliseconds (default: 5000) */
-    providerTimeoutMs?: number;
-    /** Whether to run providers in parallel (default: true) */
-    parallel?: boolean;
-    /** Risk score threshold for BLOCK decision (default: 80) */
-    blockThreshold?: number;
-    /** Risk score threshold for REVIEW decision (default: 40) */
-    reviewThreshold?: number;
-    /** Custom provider weights for aggregation (provider name -> weight 0-1) */
-    providerWeights?: Record<string, number>;
-    /** Blocklist configuration */
-    blocklist?: BlocklistConfig;
+/**
+ * In-memory data store for the Kontext SDK.
+ * Holds all action logs, transactions, tasks, and anomaly events.
+ *
+ * When a StorageAdapter is provided, call `flush()` to persist state
+ * and `restore()` to reload from storage.
+ */
+declare class KontextStore {
+    private actions;
+    private transactions;
+    private tasks;
+    private anomalies;
+    private storageAdapter;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    /**
+     * Attach a storage adapter for persistence.
+     *
+     * @param adapter - The storage backend to use
+     */
+    setStorageAdapter(adapter: StorageAdapter): void;
+    /**
+     * Get the currently attached storage adapter (if any).
+     */
+    getStorageAdapter(): StorageAdapter | null;
+    /**
+     * Persist all current in-memory state to the attached storage adapter.
+     * No-op if no adapter is attached.
+     */
+    flush(): Promise<void>;
+    /**
+     * Restore in-memory state from the attached storage adapter.
+     * Merges loaded data with any existing in-memory data.
+     * No-op if no adapter is attached.
+     */
+    restore(): Promise<void>;
+    /** Append an action log entry. Evicts oldest 10% when maxEntries is exceeded. */
+    addAction(action: ActionLog): void;
+    /** Retrieve all action log entries. */
+    getActions(): ActionLog[];
+    /** Retrieve actions filtered by a predicate. */
+    queryActions(predicate: (action: ActionLog) => boolean): ActionLog[];
+    /** Get actions for a specific agent. */
+    getActionsByAgent(agentId: string): ActionLog[];
+    /** Get actions for a specific session (across all agents). */
+    getActionsBySession(sessionId: string): ActionLog[];
+    /** Append a transaction record. Evicts oldest 10% when maxEntries is exceeded. */
+    addTransaction(tx: TransactionRecord): void;
+    /** Retrieve all transaction records. */
+    getTransactions(): TransactionRecord[];
+    /** Retrieve transactions filtered by a predicate. */
+    queryTransactions(predicate: (tx: TransactionRecord) => boolean): TransactionRecord[];
+    /** Get transactions for a specific agent. */
+    getTransactionsByAgent(agentId: string): TransactionRecord[];
+    /** Get the most recent N transactions for an agent. */
+    getRecentTransactions(agentId: string, limit: number): TransactionRecord[];
+    /** Store a task. */
+    addTask(task: Task): void;
+    /** Retrieve a task by ID. */
+    getTask(taskId: string): Task | undefined;
+    /** Update a task. */
+    updateTask(taskId: string, updates: Partial<Task>): Task | undefined;
+    /** Retrieve all tasks. */
+    getTasks(): Task[];
+    /** Retrieve tasks filtered by a predicate. */
+    queryTasks(predicate: (task: Task) => boolean): Task[];
+    /** Append an anomaly event. Evicts oldest 10% when maxEntries is exceeded. */
+    addAnomaly(anomaly: AnomalyEvent): void;
+    /** Retrieve all anomaly events. */
+    getAnomalies(): AnomalyEvent[];
+    /** Retrieve anomalies filtered by a predicate. */
+    queryAnomalies(predicate: (anomaly: AnomalyEvent) => boolean): AnomalyEvent[];
+    /** Get total record counts across all stores. */
+    getCounts(): {
+        actions: number;
+        transactions: number;
+        tasks: number;
+        anomalies: number;
+    };
+    /** Clear all stored data. Useful for testing. */
+    clear(): void;
 }
 
+/** Pre-fetched data for a single agent, passed to factor methods to avoid redundant store queries. */
+interface AgentData {
+    actions: ActionLog[];
+    transactions: TransactionRecord[];
+    tasks: Task[];
+    anomalies: AnomalyEvent[];
+}
 /**
- * Manages user-defined blocklist and allowlist addresses for compliance
- * screening. Maps to Circle Compliance Engine Rule #3 (Custom Blocklist).
+ * TrustScorer computes trust scores for agents and risk scores for transactions.
  *
- * Features:
- * - O(1) address lookup via Map with lowercase keys
- * - Per-chain filtering: entries can target specific chains or all chains
- * - Time-based expiration: entries with an `expiresAt` date are skipped
- *   (not removed) when expired
- * - Bulk import/export for list management
+ * This MVP implementation uses rule-based scoring across multiple factors:
+ * - **History depth**: More transaction history = higher trust.
+ * - **Task completion rate**: Higher completion rate = higher trust.
+ * - **Anomaly frequency**: Fewer anomalies = higher trust.
+ * - **Transaction consistency**: Consistent patterns = higher trust.
+ * - **Compliance adherence**: Following compliance rules = higher trust.
  *
- * @example
- * ```typescript
- * const manager = new BlocklistManager();
- *
- * manager.addToBlocklist({
- *   address: '0xBadActor...',
- *   chains: ['ethereum', 'base'],
- *   reason: 'Known phishing address',
- *   addedBy: 'compliance-team',
- *   addedAt: new Date().toISOString(),
- *   expiresAt: '2026-12-31T23:59:59Z',
- * });
+ * Scores range from 0-100 with levels: untrusted, low, medium, high, verified.
  *
- * if (manager.isBlocklisted('0xbadactor...', 'ethereum')) {
- *   // Block the transaction
- * }
- * ```
+ * In a production system, these rules would be augmented with ML-based scoring,
+ * graph analysis, and external reputation data.
  */
-declare class BlocklistManager {
-    /** Internal blocklist store — lowercase address -> ListEntry */
-    private readonly blocklist;
-    /** Internal allowlist store — lowercase address -> ListEntry */
-    private readonly allowlist;
-    /** Optional configuration */
+declare class TrustScorer {
     private readonly config;
-    constructor(config?: BlocklistConfig);
-    /**
-     * Add an address to the blocklist.
-     *
-     * If the address already exists, the entry is overwritten with the new one.
-     *
-     * @param entry - The list entry to add
-     */
-    addToBlocklist(entry: ListEntry): void;
-    /**
-     * Add an address to the allowlist.
-     *
-     * If the address already exists, the entry is overwritten with the new one.
-     *
-     * @param entry - The list entry to add
-     */
-    addToAllowlist(entry: ListEntry): void;
+    private readonly store;
+    constructor(config: KontextConfig, store: KontextStore);
     /**
-     * Remove an address from the blocklist.
+     * Compute the trust score for a given agent.
      *
-     * @param address - The blockchain address to remove (case-insensitive)
-     * @returns `true` if the address was found and removed, `false` otherwise
-     */
-    removeFromBlocklist(address: string): boolean;
-    /**
-     * Remove an address from the allowlist.
+     * @param agentId - The agent identifier
+     * @returns TrustScore with overall score, factor breakdown, and trust level
      *
-     * @param address - The blockchain address to remove (case-insensitive)
-     * @returns `true` if the address was found and removed, `false` otherwise
+     * @example
+     * ```typescript
+     * const score = await scorer.getTrustScore('payment-agent-1');
+     * console.log(`Trust: ${score.score}/100 (${score.level})`);
+     * ```
      */
-    removeFromAllowlist(address: string): boolean;
+    getTrustScore(agentId: string): Promise<TrustScore>;
     /**
-     * Check whether an address is on the blocklist.
+     * Evaluate the risk of a specific transaction.
      *
-     * Performs case-insensitive lookup and honors:
-     * - Chain filtering: if the entry specifies chains, the address is only
-     *   considered blocklisted if the given chain matches (or entry has no chains).
-     * - Expiration: if the entry has an `expiresAt` date in the past, it is
-     *   skipped (not removed from storage).
+     * @param tx - Transaction input to evaluate
+     * @returns TransactionEvaluation with risk score, factors, and recommendation
      *
-     * @param address - The blockchain address to check
-     * @param chain - Optional chain to filter against
-     * @returns `true` if the address is actively blocklisted
+     * @example
+     * ```typescript
+     * const eval = await scorer.evaluateTransaction({
+     *   txHash: '0x...',
+     *   chain: 'base',
+     *   amount: '50000',
+     *   token: 'USDC',
+     *   from: '0xSender',
+     *   to: '0xReceiver',
+     *   agentId: 'agent-1',
+     * });
+     * if (eval.flagged) console.log('Transaction flagged for review');
+     * ```
      */
-    isBlocklisted(address: string, chain?: Chain): boolean;
+    evaluateTransaction(tx: LogTransactionInput): Promise<TransactionEvaluation>;
+    private computeAgentFactors;
     /**
-     * Check whether an address is on the allowlist.
+     * History depth factor: more recorded actions = more data to assess trust.
      *
-     * Same matching semantics as {@link isBlocklisted}: case-insensitive,
-     * chain-aware, and expiration-aware.
-     *
-     * @param address - The blockchain address to check
-     * @param chain - Optional chain to filter against
-     * @returns `true` if the address is actively allowlisted
-     */
-    isAllowlisted(address: string, chain?: Chain): boolean;
-    /**
-     * Return all blocklist entries.
-     */
-    getBlocklist(): ListEntry[];
-    /**
-     * Return all allowlist entries.
+     * Scoring curve (step function, not linear) prevents gaming by spamming
+     * low-value actions — crossing each tier requires meaningfully more history:
+     * - 0 actions → 10 (minimal trust, new agent)
+     * - 1-4 → 30 (some activity but too little to draw conclusions)
+     * - 5-19 → 50 (neutral, moderate activity)
+     * - 20-49 → 70 (established agent with reasonable track record)
+     * - 50-99 → 85 (well-established agent)
+     * - 100+ → 95 (capped below 100 because history alone doesn't guarantee trust)
      */
-    getAllowlist(): ListEntry[];
+    private computeHistoryDepthFactor;
     /**
-     * Bulk-import entries into either the blocklist or allowlist.
+     * Task completion factor: agents that confirm tasks build trust, failures erode it.
      *
-     * @param entries - Array of list entries to import
-     * @param type - Target list: `'blocklist'` or `'allowlist'`
-     * @returns The number of entries that were imported
+     * Formula: score = (completionRate * 100) - (failureRate * 30)
+     * - The 30x failure penalty means each failure costs 3x more than a confirmation gains.
+     *   This asymmetry reflects real-world trust: it takes many good actions to build trust
+     *   but only a few failures to lose it.
+     * - Returns 50 (neutral) when no tasks exist, avoiding penalizing new agents.
      */
-    importList(entries: ListEntry[], type: 'blocklist' | 'allowlist'): number;
+    private computeTaskCompletionFactor;
     /**
-     * Export all entries from either the blocklist or allowlist.
+     * Anomaly frequency factor: fewer anomalies relative to total actions = higher trust.
      *
-     * @param type - Source list: `'blocklist'` or `'allowlist'`
-     * @returns Array of all list entries (including expired ones)
-     */
-    exportList(type: 'blocklist' | 'allowlist'): ListEntry[];
-    /**
-     * Check whether an address is present and active in a given list map.
-     * Expired entries are skipped but not removed from storage.
-     */
-    private isListed;
-}
-/**
- * Combines results from multiple {@link ScreeningProvider} instances into a
- * unified screening decision.
- *
- * The aggregator:
- * - Checks the optional {@link BlocklistManager} first (allowlist and blocklist)
- * - Runs all providers in parallel (configurable) with per-provider timeout
- * - Computes a weighted-average aggregate risk score
- * - Determines the final decision based on configurable thresholds
- * - Enforces minimum provider success requirements
- *
- * @example
- * ```typescript
- * const aggregator = new ScreeningAggregator(
- *   [ofacProvider, chainalysisProvider, openSanctionsProvider],
- *   {
- *     blockThreshold: 80,
- *     reviewThreshold: 40,
- *     providerTimeoutMs: 5000,
- *     minProviderSuccess: 2,
- *     providerWeights: {
- *       'ofac-list': 1.0,
- *       'chainalysis-free': 0.8,
- *       'opensanctions': 0.6,
- *     },
- *   },
- *   blocklistManager,
- * );
- *
- * const result = await aggregator.screenAddress({
- *   address: '0x...',
- *   chain: 'ethereum',
- * });
- *
- * switch (result.decision) {
- *   case 'BLOCK': // Deny transaction
- *   case 'REVIEW': // Flag for manual review
- *   case 'APPROVE': // Proceed
- * }
- * ```
- */
-declare class ScreeningAggregator {
-    private providers;
-    private readonly config;
-    private readonly blocklist;
-    /**
-     * Create a new ScreeningAggregator.
+     * Uses anomaly rate (anomalies / actions) with step-function scoring:
+     * - 0% → 100 (clean record)
+     * - <1% → 90 (near-perfect, occasional false positive acceptable)
+     * - <5% → 70 (some noise but generally clean)
+     * - <10% → 50 (neutral, warrants monitoring)
+     * - <25% → 30 (concerning pattern)
+     * - 25%+ → 10 (severe anomaly rate)
      *
-     * @param providers - Array of screening providers to aggregate
-     * @param config - Optional aggregator configuration
-     * @param blocklist - Optional blocklist manager for custom block/allow lists
+     * Critical anomalies incur a -15 point penalty each, high anomalies -8 each.
+     * This severity weighting ensures a single critical anomaly (e.g., sanctions hit)
+     * has outsized impact compared to multiple low-severity anomalies.
      */
-    constructor(providers: ScreeningProvider[], config?: ScreeningAggregatorConfig, blocklist?: BlocklistManager);
+    private computeAnomalyFrequencyFactor;
     /**
-     * Screen a single address through all providers and return a unified result.
+     * Transaction consistency factor: stable spending patterns indicate legitimate usage.
      *
-     * Execution order:
-     * 1. Check allowlist (if allowlisted AND `config.blocklist.allowlistPriority`, approve immediately)
-     * 2. Check blocklist (if blocklisted, block immediately with CUSTOM_BLOCKLIST category)
-     * 3. Run all providers (parallel or sequential) with per-provider timeout
-     * 4. Aggregate results into a unified decision
+     * Uses the coefficient of variation (CV = stdDev / mean) to measure amount regularity:
+     * - CV < 0.1 → 95 (extremely consistent, e.g., recurring payroll)
+     * - CV < 0.3 → 80 (fairly consistent with some variance)
+     * - CV < 0.5 → 65 (moderate variance, common for operational spending)
+     * - CV < 1.0 → 45 (high variance, warrants attention)
+     * - CV < 2.0 → 30 (very erratic, potential structuring)
+     * - CV 2.0+ → 15 (extreme variance, strong structuring indicator)
      *
-     * @param input - Address screening input
-     * @returns Unified screening result with aggregated decision
+     * Also penalizes -15 points when >80% of destinations are unique with >5 txs,
+     * which is a common money-laundering pattern (spray-and-pray distribution).
      */
-    screenAddress(input: ScreenAddressInput): Promise<UnifiedScreeningResult>;
+    private computeTransactionConsistencyFactor;
     /**
-     * Screen a transaction by screening both sender and recipient addresses.
+     * Compliance adherence factor: agents that follow the task-confirm-evidence workflow
+     * demonstrate higher operational integrity.
      *
-     * The combined decision is the worst (most restrictive) of the two
-     * individual decisions: BLOCK > REVIEW > APPROVE.
+     * Scoring:
+     * - Base score: 50 (neutral)
+     * - +30 max for evidence rate (confirmedTasksWithEvidence / confirmedTasks)
+     * - +20 max for coverage rate (tasks / transactions, capped at 1.0)
      *
-     * @param input - Transaction screening input
-     * @returns Sender result, recipient result, and combined decision
+     * The rationale: tasks with evidence prove the agent completed auditable work.
+     * Coverage rate measures what fraction of financial activity has corresponding
+     * task tracking — higher coverage means better compliance discipline.
      */
-    screenTransaction(input: ScreenTransactionProviderInput): Promise<{
-        sender: UnifiedScreeningResult;
-        recipient: UnifiedScreeningResult;
-        combinedDecision: 'APPROVE' | 'REVIEW' | 'BLOCK';
-    }>;
+    private computeComplianceAdherenceFactor;
+    private computeTransactionRiskFactors;
     /**
-     * Add a screening provider at runtime.
+     * Amount risk: higher transaction amounts carry inherently higher risk.
      *
-     * @param provider - The provider to add
-     */
-    addProvider(provider: ScreeningProvider): void;
-    /**
-     * Remove a screening provider by name.
+     * Tiers are aligned with common fintech thresholds:
+     * - <$100: near-zero risk (5), micro-transactions
+     * - <$1K: low risk (15), typical consumer spending
+     * - <$10K: moderate (30), approaches CTR reporting thresholds
+     * - <$50K: elevated (55), large business transactions
+     * - <$100K: high (75), requires enhanced due diligence
+     * - $100K+: very high (95), institutional-scale transfers
      *
-     * @param name - The provider name to remove
-     * @returns `true` if the provider was found and removed, `false` otherwise
+     * Additional +20 penalty when amount exceeds 5x the agent's historical average,
+     * detecting sudden spending spikes that could indicate account compromise.
      */
-    removeProvider(name: string): boolean;
+    private computeAmountRisk;
+    private computeNewDestinationRisk;
+    private computeFrequencyRisk;
+    private computeAgentRisk;
     /**
-     * List the names of all registered providers.
+     * Round amount risk: round numbers are a structuring indicator in AML heuristics.
      *
-     * @returns Array of provider name strings
-     */
-    getProviders(): string[];
-    /**
-     * Check the health of all registered providers.
+     * Money launderers often transact in round amounts (e.g., $10,000 exactly) or
+     * just under regulatory thresholds (e.g., $9,500 to avoid $10K CTR filing).
      *
-     * @returns A record mapping provider name to its health status
-     */
-    healthCheck(): Promise<Record<string, boolean>>;
-    /**
-     * Execute all providers against the given input, respecting the parallel
-     * configuration and per-provider timeout.
-     */
-    private runProviders;
-    /**
-     * Run all providers in parallel using Promise.allSettled, with per-provider
-     * timeout enforcement.
-     */
-    private runProvidersParallel;
-    /**
-     * Run all providers sequentially (one at a time), with per-provider
-     * timeout enforcement.
-     */
-    private runProvidersSequential;
-    /**
-     * Aggregate individual provider results into a unified screening result.
-     */
-    private aggregateResults;
-    /**
-     * Compute the weighted average risk score across successful provider results.
+     * Scoring:
+     * - Non-round amounts: 5 (baseline, most legitimate transactions)
+     * - Multiples of $1,000: 15 (mildly suspicious)
+     * - Multiples of $10,000: 25 (more suspicious)
+     * - Amounts $9,000-$10,000: +20 penalty (classic structuring band)
      *
-     * Uses `config.providerWeights` when set; otherwise treats all providers
-     * with equal weight. Only providers that succeeded are included in the
-     * computation. If no providers succeeded, returns 0.
-     */
-    private computeWeightedRiskScore;
-    /**
-     * Build an immediate APPROVE result for an allowlisted address.
-     */
-    private buildAllowlistedResult;
-    /**
-     * Build an immediate BLOCK result for a blocklisted address.
+     * This factor alone rarely triggers flagging — it contributes to the composite
+     * risk score alongside amount, frequency, and destination analysis.
      */
-    private buildBlocklistedResult;
+    private computeRoundAmountRisk;
+    private scoreToLevel;
+    private riskScoreToLevel;
 }
-/**
- * Convenience factory for creating a {@link ScreeningAggregator} with optional
- * blocklist support.
- *
- * @param providers - Array of screening providers to aggregate
- * @param config - Optional aggregator configuration
- * @param blocklist - Optional blocklist manager
- * @returns A configured ScreeningAggregator instance
- *
- * @example
- * ```typescript
- * const aggregator = createScreeningAggregator(
- *   [ofacProvider, chainalysisProvider],
- *   { blockThreshold: 75 },
- *   myBlocklistManager,
- * );
- * ```
- */
-declare function createScreeningAggregator(providers: ScreeningProvider[], config?: ScreeningAggregatorConfig, blocklist?: BlocklistManager): ScreeningAggregator;
 
-/** Configuration for the OFACListProvider */
-interface OFACListProviderConfig {
-    /**
-     * How often to re-fetch the address list from GitHub, in milliseconds.
-     * @default 86400000 (24 hours)
-     */
-    updateIntervalMs?: number;
-    /**
-     * GitHub branch containing the auto-generated list files.
-     * @default 'lists'
-     */
-    githubBranch?: string;
-    /**
-     * If true, fall back to the built-in `ofacScreener` from `./ofac-sanctions.js`
-     * when the GitHub fetch fails during initialization.
-     * @default false
-     */
-    fallbackToBuiltin?: boolean;
-}
 /**
- * OFAC sanctions screening provider backed by the 0xB10C GitHub repository.
- *
- * The repository's `lists` branch contains nightly-updated plain text files
- * with one sanctioned digital currency address per line, sourced from the
- * official U.S. Treasury OFAC SDN list. This provider fetches the ETH
- * address file, parses it into a `Set<string>` for O(1) lookups, and
- * periodically re-fetches to stay current.
- *
- * Because Ethereum-format addresses are valid across all EVM-compatible
- * chains, this provider supports screening on any EVM chain.
- *
- * @example
- * ```typescript
- * const provider = new OFACListProvider({ fallbackToBuiltin: true });
- * await provider.initialize();
- *
- * const result = await provider.screenAddress({
- *   address: '0x098B716B8Aaf21512996dC57EB0615e2383E2f96',
- *   chain: 'ethereum',
- * });
- *
- * if (result.matched) {
- *   console.log('OFAC sanctioned address detected');
- * }
- *
- * // Cleanup when done
- * provider.dispose();
- * ```
+ * AnomalyDetector monitors agent actions and transactions for suspicious patterns.
+ *
+ * Supported detection rules:
+ * - **unusualAmount**: Flags transactions above a configured threshold or
+ *   significantly above the agent's historical average.
+ * - **frequencySpike**: Flags when an agent's transaction rate exceeds
+ *   the configured maximum per hour.
+ * - **newDestination**: Flags transactions to previously unseen addresses.
+ * - **offHoursActivity**: Flags activity during configured off-hours (UTC).
+ * - **rapidSuccession**: Flags transactions that occur within a very short
+ *   time interval of each other.
+ * - **roundAmount**: Flags round-number amounts that may indicate structuring.
+ *
+ * Severity levels: low, medium, high, critical.
  */
-declare class OFACListProvider implements ScreeningProvider {
-    readonly name = "ofac-list-auto";
-    readonly supportedCategories: RiskCategory[];
-    readonly supportedChains: Chain[];
-    /** Lowercased sanctioned addresses for O(1) lookup */
-    private sanctionedAddresses;
-    /** ISO timestamp of the last successful address list update */
-    private lastUpdatedAt;
-    /** Handle for the periodic re-fetch interval */
-    private refreshInterval;
-    /** Resolved configuration with defaults applied */
+declare class AnomalyDetector {
     private readonly config;
-    constructor(config?: OFACListProviderConfig);
-    /**
-     * Fetch the initial address list from GitHub and schedule periodic refreshes.
-     *
-     * If the fetch fails and `fallbackToBuiltin` is enabled, the provider will
-     * populate its address set from the built-in `ofacScreener` instead of
-     * throwing. This ensures screening can proceed even if GitHub is unreachable.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Screen a single address against the OFAC sanctioned addresses set.
-     *
-     * @param input - The address and chain to screen
-     * @returns A ProviderScreeningResult with match information and risk signals
-     */
-    screenAddress(input: ScreenAddressInput): Promise<ProviderScreeningResult>;
-    /**
-     * Returns true if the address set has been successfully populated.
-     * A healthy provider has at least one address loaded.
-     */
-    isHealthy(): Promise<boolean>;
+    private readonly store;
+    private detectionConfig;
+    private thresholds;
+    private callbacks;
+    private enabled;
+    constructor(config: KontextConfig, store: KontextStore);
     /**
-     * Return provider statistics for observability and monitoring.
+     * Enable anomaly detection with the specified configuration.
      *
-     * @returns Object containing the current address count and last update timestamp
-     */
-    getStats(): {
-        addressCount: number;
-        lastUpdatedAt: string | null;
-    };
-    /**
-     * Clear the periodic refresh interval and release resources.
-     * Call this when the provider is no longer needed to prevent memory leaks.
-     */
-    dispose(): void;
-    /**
-     * Fetch the sanctioned ETH address list from GitHub and parse it into
-     * the internal Set. Falls back to the built-in screener if configured.
-     */
-    private fetchAddressList;
-    /**
-     * Parse a plain text address list into a Set of lowercased addresses.
-     * Handles:
-     * - Empty lines
-     * - Lines with leading/trailing whitespace
-     * - Comment lines starting with '#'
-     * - Carriage return / line feed differences
-     */
-    private parseAddressList;
-}
-/** Configuration for the ChainalysisOracleProvider */
-interface ChainalysisOracleProviderConfig {
-    /**
-     * Mapping of chain names to JSON-RPC endpoint URLs.
-     * Only chains with an entry here will be screenable.
+     * @param detectionConfig - Rules and thresholds for detection
      *
      * @example
      * ```typescript
-     * {
-     *   ethereum: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
-     *   polygon: 'https://polygon-mainnet.g.alchemy.com/v2/YOUR_KEY',
-     * }
+     * detector.enableAnomalyDetection({
+     *   rules: ['unusualAmount', 'frequencySpike', 'newDestination'],
+     *   thresholds: { maxAmount: '10000', maxFrequency: 50 },
+     * });
      * ```
      */
-    rpcUrls: Record<string, string>;
-    /**
-     * How long to cache oracle results per address+chain pair, in milliseconds.
-     * @default 300000 (5 minutes)
-     */
-    cacheTimeMs?: number;
-}
-/**
- * Chainalysis on-chain sanctions oracle screening provider.
- *
- * The Chainalysis sanctions oracle is a free, permissionless smart contract
- * deployed at `0x40C57923924B5c5c5455c48D93317139ADDaC8fb` on multiple EVM
- * chains. It exposes a single `isSanctioned(address)` view function that
- * returns true if the address appears on the Chainalysis sanctions list.
- *
- * This provider makes raw `eth_call` JSON-RPC requests to the oracle --
- * no ethers.js or web3.js dependency required. Results are cached per
- * address+chain pair to reduce RPC call volume.
- *
- * Supported chains: Ethereum, Polygon, Arbitrum, Optimism, Base, Avalanche.
- *
- * @see https://go.chainalysis.com/chainalysis-oracle-docs.html
- *
- * @example
- * ```typescript
- * const provider = new ChainalysisOracleProvider({
- *   rpcUrls: {
- *     ethereum: 'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY',
- *     polygon: 'https://polygon-mainnet.g.alchemy.com/v2/YOUR_KEY',
- *   },
- *   cacheTimeMs: 60_000, // 1 minute cache
- * });
- *
- * const result = await provider.screenAddress({
- *   address: '0x098B716B8Aaf21512996dC57EB0615e2383E2f96',
- *   chain: 'ethereum',
- * });
- *
- * if (result.matched) {
- *   console.log('Address flagged by Chainalysis oracle');
- * }
- * ```
- */
-declare class ChainalysisOracleProvider implements ScreeningProvider {
-    readonly name = "chainalysis-oracle";
-    readonly supportedCategories: RiskCategory[];
-    readonly supportedChains: Chain[];
-    /** RPC URL mapping: chain name -> JSON-RPC endpoint */
-    private readonly rpcUrls;
-    /** Cache TTL in milliseconds */
-    private readonly cacheTimeMs;
-    /** In-memory cache keyed by `${chain}:${lowercasedAddress}` */
-    private readonly cache;
-    constructor(config: ChainalysisOracleProviderConfig);
-    /**
-     * Screen a single address using the Chainalysis on-chain sanctions oracle.
-     *
-     * Makes an `eth_call` to the oracle contract on the specified chain. If no
-     * RPC URL is configured for the chain, returns a failed result with an error.
-     *
-     * @param input - The address and chain to screen
-     * @returns A ProviderScreeningResult with oracle verdict and risk signals
-     */
-    screenAddress(input: ScreenAddressInput): Promise<ProviderScreeningResult>;
-    /**
-     * Verify RPC connectivity by calling the oracle with the zero address.
-     *
-     * The zero address (`0x0000...0000`) should not be sanctioned, so the oracle
-     * should return `false`. Any successful response (true or false) indicates
-     * the RPC and oracle contract are reachable.
-     */
-    isHealthy(): Promise<boolean>;
-    /**
-     * Make a raw `eth_call` to the Chainalysis oracle's `isSanctioned(address)` function.
-     *
-     * @param rpcUrl - JSON-RPC endpoint URL
-     * @param address - Lowercased Ethereum address to check (with or without 0x prefix)
-     * @returns true if the oracle reports the address as sanctioned
-     */
-    private callOracle;
-    /**
-     * Decode an ABI-encoded boolean return value from an eth_call.
-     *
-     * The return data is a 32-byte (64 hex char) value. Any non-zero value
-     * is treated as `true` per Solidity's bool encoding.
-     *
-     * @param hexData - The hex-encoded return data (with 0x prefix)
-     * @returns The decoded boolean value
-     */
-    private decodeBoolResult;
-    /**
-     * Look up a cached oracle result. Returns null if no valid cache entry exists.
-     *
-     * @param cacheKey - The cache key (`chain:address`)
-     * @returns The cached sanctioned boolean, or null if not cached / expired
-     */
-    private getCachedResult;
-    /**
-     * Store an oracle result in the cache.
-     *
-     * @param cacheKey - The cache key (`chain:address`)
-     * @param sanctioned - Whether the address is sanctioned
-     */
-    private setCachedResult;
-}
-
-/** Configuration for the Chainalysis free-tier API provider */
-interface ChainalysisFreeAPIConfig {
-    /** API key obtained from Chainalysis registration */
-    apiKey: string;
-    /** Base URL override (defaults to public Chainalysis endpoint) */
-    baseUrl?: string;
-    /** Cache TTL in milliseconds (default: 15 minutes) */
-    cacheTimeMs?: number;
-}
-/**
- * Screening provider that integrates with the Chainalysis free-tier
- * sanctions screening REST API.
- *
- * The free tier provides sanctions-only screening and is chain-agnostic
- * for address lookups. Results are cached in memory to reduce API calls.
- *
- * @see https://www.chainalysis.com/free-cryptocurrency-sanctions-screening-tools/
- *
- * @example
- * ```typescript
- * const provider = new ChainalysisFreeAPIProvider({
- *   apiKey: process.env.CHAINALYSIS_API_KEY!,
- * });
- *
- * await provider.initialize();
- *
- * const result = await provider.screenAddress({
- *   address: '0x...',
- *   chain: 'ethereum',
- * });
- *
- * if (result.matched) {
- *   console.log('Sanctions match:', result.signals);
- * }
- * ```
- */
-declare class ChainalysisFreeAPIProvider implements ScreeningProvider {
-    readonly name = "chainalysis-free-api";
-    readonly supportedCategories: RiskCategory[];
-    readonly supportedChains: Chain[];
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly cache;
-    private lastCallAt;
-    private lastCallSuccess;
-    private apiKeyValid;
-    constructor(config: ChainalysisFreeAPIConfig);
-    /**
-     * Verify API key validity by making a test call against the zero address.
-     * Throws if the API key is invalid or the service is unreachable.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Screen an address against the Chainalysis sanctions database.
-     *
-     * Checks the in-memory cache first. On a cache miss, calls the Chainalysis
-     * free API and maps each identification to a SEVERE-level RiskSignal.
-     *
-     * @param input - Address screening input
-     * @returns Screening result with any detected sanctions signals
-     */
-    screenAddress(input: ScreenAddressInput): Promise<ProviderScreeningResult>;
-    /**
-     * Returns true if the last API call succeeded within the last 5 minutes.
-     */
-    isHealthy(): Promise<boolean>;
-    /**
-     * Return operational statistics for monitoring and debugging.
-     */
-    getStats(): {
-        cachedEntries: number;
-        lastCallAt: string | null;
-        apiKeyValid: boolean;
-    };
-}
-/** Configuration for the OpenSanctions API provider */
-interface OpenSanctionsConfig {
-    /** API key for OpenSanctions */
-    apiKey: string;
-    /** Base URL override (defaults to https://api.opensanctions.org) */
-    baseUrl?: string;
-    /** Minimum match score threshold (0-1, default: 0.7) */
-    minMatchScore?: number;
-    /** Cache TTL in milliseconds (default: 30 minutes) */
-    cacheTimeMs?: number;
-}
-/**
- * Screening provider that integrates with the OpenSanctions API for
- * comprehensive entity screening across 325+ global data sources.
- *
- * Covers sanctions lists (OFAC, EU, UN), PEP databases, crime-related
- * entities, and persons of interest. Uses the CryptoWallet schema for
- * address-based matching and supports entity name search.
- *
- * @see https://www.opensanctions.org/docs/api/
- *
- * @example
- * ```typescript
- * const provider = new OpenSanctionsProvider({
- *   apiKey: process.env.OPENSANCTIONS_API_KEY!,
- *   minMatchScore: 0.8,
- * });
- *
- * await provider.initialize();
- *
- * const result = await provider.screenAddress({
- *   address: '0x...',
- *   chain: 'ethereum',
- * });
- *
- * // Entity name search
- * const entities = await provider.searchEntity('Lazarus Group');
- * ```
- */
-declare class OpenSanctionsProvider implements ScreeningProvider {
-    readonly name = "opensanctions";
-    readonly supportedCategories: RiskCategory[];
-    readonly supportedChains: Chain[];
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly minMatchScore;
-    private readonly cache;
-    private lastCallAt;
-    private lastCallSuccess;
-    constructor(config: OpenSanctionsConfig);
+    enableAnomalyDetection(detectionConfig: AnomalyDetectionConfig): void;
     /**
-     * Test API connectivity by making a lightweight search request.
-     * Throws if the API key is invalid or the service is unreachable.
+     * Disable anomaly detection.
      */
-    initialize(): Promise<void>;
+    disableAnomalyDetection(): void;
     /**
-     * Screen an address against the OpenSanctions database using the
-     * CryptoWallet entity match endpoint.
+     * Register a callback for anomaly events.
      *
-     * Results with a score below `minMatchScore` are filtered out. Each
-     * qualifying result is mapped to a RiskSignal with category derived
-     * from the entity's `topics` property.
+     * @param callback - Function to call when an anomaly is detected
+     * @returns Unsubscribe function
      *
-     * @param input - Address screening input
-     * @returns Screening result with detected risk signals
+     * @example
+     * ```typescript
+     * const unsub = detector.onAnomaly((anomaly) => {
+     *   console.log(`Anomaly: ${anomaly.type} [${anomaly.severity}]`);
+     * });
+     * // Later: unsub();
+     * ```
      */
-    screenAddress(input: ScreenAddressInput): Promise<ProviderScreeningResult>;
+    onAnomaly(callback: AnomalyCallback): () => void;
     /**
-     * Search for entities by name using the OpenSanctions search endpoint.
-     *
-     * This is an additional method beyond the ScreeningProvider interface,
-     * useful for entity-level due diligence and KYC workflows.
+     * Evaluate a transaction against all enabled detection rules.
+     * Called automatically when transactions are logged (via the client).
      *
-     * @param name - Entity name to search for
-     * @returns Array of matching entities with scores and metadata
-     */
-    searchEntity(name: string): Promise<Array<{
-        id: string;
-        caption: string;
-        score: number;
-        datasets: string[];
-        topics: string[];
-    }>>;
-    /**
-     * Returns true if the API was reachable on the last call.
+     * @param tx - The transaction record to evaluate
+     * @returns Array of detected anomalies (empty if none)
      */
-    isHealthy(): Promise<boolean>;
+    evaluateTransaction(tx: TransactionRecord): AnomalyEvent[];
     /**
-     * Return operational statistics for monitoring and debugging.
-     */
-    getStats(): {
-        cachedEntries: number;
-        lastCallAt: string | null;
-    };
-    /**
-     * Resolve the risk category from an OpenSanctions entity's topics.
+     * Evaluate a generic action against all enabled detection rules.
      *
-     * Topic mapping:
-     *   - "sanction"  -> SANCTIONS
-     *   - "pep"       -> PEP
-     *   - "poi"       -> ILLICIT_BEHAVIOR (person of interest)
-     *   - "crime"     -> ILLICIT_BEHAVIOR
-     *   - (default)   -> SANCTIONS (conservative fallback)
+     * @param action - The action log to evaluate
+     * @returns Array of detected anomalies (empty if none)
      */
-    private resolveCategory;
+    evaluateAction(action: ActionLog): AnomalyEvent[];
     /**
-     * Resolve risk severity from the match confidence score.
-     *
-     *   - >= 0.95 -> SEVERE
-     *   - >= 0.80 -> HIGH
-     *   - >= 0.70 -> MEDIUM
+     * Check whether anomaly detection is currently enabled.
      */
-    private resolveSeverity;
+    isEnabled(): boolean;
     /**
-     * Resolve recommended actions based on the risk severity.
+     * Get the current detection configuration.
      */
-    private resolveActions;
+    getConfig(): AnomalyDetectionConfig | null;
+    private runRule;
+    private runActionRule;
+    private checkUnusualAmount;
+    private checkFrequencySpike;
+    private checkNewDestination;
+    private checkOffHours;
+    private checkRapidSuccession;
+    private checkRoundAmount;
+    private checkOffHoursAction;
+    private checkActionFrequencySpike;
+    private createAnomaly;
+    private notifyCallbacks;
 }
 
-export { type AIOperationType, type ActionLog, type AddressScreenResult, type AnomalyCallback, type AnomalyDetectionConfig, type AnomalyEvent, type AnomalyRuleType, type AnomalySeverity, type AnomalyThresholds, type ApprovalDecision, type ApprovalEvaluation, ApprovalManager, type ApprovalPolicy, type ApprovalPolicyType, type ApprovalRequest, type ApprovalStatus, type BlockedToolCall, type BlocklistConfig, BlocklistManager, type CCTPAttestationInput, type CCTPHook, type CCTPHookResult, type CCTPMessageStatus, CCTPTransferManager, type CCTPValidationCheck, type CCTPValidationResult, type CCTPVersion, type CFTCAccountClass, CFTCCompliance, type CFTCComplianceConfig, type CTRReport, type Chain, ChainalysisFreeAPIProvider, ChainalysisOracleProvider, type CircleApiAdapter, type CircleComplianceAdapter, CircleComplianceEngine, type CircleWallet, CircleWalletManager, type CircleWalletOptions, type CollateralValuation, type ComplianceCertificate, type ComplianceCheckResult, type ComplianceCheckSummary, type ComplianceReport, type CompliantTransferInput, type CompliantTransferResult, type ComprehensiveRiskFactor, type ComprehensiveRiskResult, type ComprehensiveSanctionsResult, type ConfirmCCTPTransferInput, type ConfirmTaskInput, ConsoleExporter, type CreateKontextAIInput, type CreateKontextAIResult, type CreateTaskInput, type CreateWalletOptions, type CrossChainAuditEntry, type CrossChainTransfer, type DateRange, DigestChain, type DigestLink, type DigestVerification, type DigitalAssetReport, type DigitalAssetType, type DualScreenResult, type EntityNameEntry, type Environment, type EvaluateApprovalInput, type EventExporter, type ExportFormat, type ExportOptions, type ExportResult, type ExporterResult, type FastTransferValidation, type FeatureFlag, type FeatureFlagConfig, FeatureFlagManager, FileStorage, type FlagPlanTargeting, type FlagScope, type FlagTargeting, type GasEligibility, type GasEstimate, type GasEstimateInput, type GasSponsorshipLog, type GasStationAdapter, GasStationManager, type GatedFeature, type GenerateComplianceCertificateInput, HttpExporter, type IncidentReport, type InitiateCCTPTransferInput, type InitiateFastTransferInput, JsonFileExporter, type JurisdictionFlag, Kontext, type KontextAIContext, type KontextAIOptions, KontextCloudExporter, type KontextConfig, KontextError, KontextErrorCode, type KontextMode, type LimitEvent, type ListEntry, type LogActionInput, type LogLevel, type LogReasoningInput, type LogTransactionInput, MemoryStorage, type MetadataValidator, MultiExporter, NoopExporter, OFACListProvider, OFACSanctionsScreener, OpenSanctionsProvider, type OwnershipFlag, PLAN_LIMITS, type PatternFlag, type PlanConfig, PlanManager, type PlanTier, type PlanUsage, type PrecisionTimestamp, type ProviderScreeningResult, type ReasoningEntry, type RegisterWebhookInput, type ReportOptions, type ReportSubject, type ReportType, type RiskAssessmentInput, type RiskCategory, type RiskFactor, type RiskSeverity, type RiskSignal, type SARReport, type SanctionedAddressEntry, type SanctionedEntityType, type SanctionedJurisdiction, type SanctionsCheckResult, type SanctionsList, type SanctionsListMetadata, type SanctionsMatch, type SanctionsRiskLevel, type ScreenAddressInput, type ScreenTransactionInput, type ScreenTransactionProviderInput, type ScreeningAction, ScreeningAggregator, type ScreeningAggregatorConfig, type ScreeningProvider, type SegregationCalculation, type StorageAdapter, type SubmitDecisionInput, type Task, type TaskEvidence, type TaskStatus, type Token, type TransactionDirection, type TransactionEvaluation, type TransactionForAnalysis, type TransactionRecord, type TrustFactor, type TrustScore, type UnifiedScreeningResult, UsdcCompliance, type UsdcComplianceCheck, type WalletBalance, type WalletSet, type WebhookConfig, type WebhookDeliveryResult, type WebhookEventType, WebhookManager, type WebhookPayload, type WebhookRetryConfig, type WithKontextOptions, createKontextAI, createScreeningAggregator, extractAmount, isFeatureAvailable, kontextMiddleware, kontextWrapModel, ofacScreener, requirePlan, verifyExportedChain, withKontext };
+export { type ActionLog, type AgentData, type AnomalyCallback, type AnomalyDetectionConfig, AnomalyDetector, type AnomalyEvent, type AnomalyRuleType, type AnomalySeverity, type AnomalyThresholds, type Chain, type ComplianceCertificate, type ComplianceCheckResult, type ComplianceReport, type ConfirmTaskInput, ConsoleExporter, type CreateTaskInput, type DateRange, DigestChain, type DigestLink, type DigestVerification, type Environment, type EventExporter, type ExportFormat, type ExportOptions, type ExportResult, type ExporterResult, type FeatureFlag, type FeatureFlagConfig, FeatureFlagManager, FileStorage, FirestoreStorageAdapter, type FirestoreStorageConfig, type FlagPlanTargeting, type FlagScope, type FlagTargeting, type GatedFeature, type GenerateComplianceCertificateInput, JsonFileExporter, Kontext, type KontextConfig, KontextError, KontextErrorCode, type KontextMode, type LimitEvent, type LogActionInput, type LogLevel, type LogReasoningInput, type LogTransactionInput, MemoryStorage, type MetadataValidator, NoopExporter, PLAN_LIMITS, type PlanConfig, PlanManager, type PlanTier, type PlanUsage, type PrecisionTimestamp, type ReasoningEntry, type ReportOptions, type ReportType, type RiskFactor, type SanctionsCheckResult, type StorageAdapter, type Task, type TaskEvidence, type TaskStatus, type Token, type TransactionEvaluation, type TransactionRecord, type TrustFactor, type TrustScore, TrustScorer, UsdcCompliance, type UsdcComplianceCheck, type VerifyInput, type VerifyResult, isFeatureAvailable, requirePlan, verifyExportedChain };