@highway1/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,920 @@
+import { Libp2p } from 'libp2p';
+import { PrivateKey } from '@libp2p/interface';
+import { Level } from 'level';
+
+interface KeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+/**
+ * Generate a new Ed25519 key pair
+ */
+declare function generateKeyPair(): Promise<KeyPair>;
+/**
+ * Sign a message with a private key
+ */
+declare function sign(message: Uint8Array, privateKey: Uint8Array): Promise<Uint8Array>;
+/**
+ * Verify a signature
+ */
+declare function verify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): Promise<boolean>;
+/**
+ * Export key pair to JSON format
+ */
+declare function exportKeyPair(keyPair: KeyPair): {
+    publicKey: string;
+    privateKey: string;
+};
+/**
+ * Import key pair from JSON format
+ */
+declare function importKeyPair(exported: {
+    publicKey: string;
+    privateKey: string;
+}): KeyPair;
+
+/**
+ * Derive a did:clawiverse DID from a public key
+ * Format: did:clawiverse:<base58btc-encoded-pubkey>
+ */
+declare function deriveDID(publicKey: Uint8Array): string;
+/**
+ * Extract public key from a did:clawiverse DID
+ */
+declare function extractPublicKey(did: string): Uint8Array;
+/**
+ * Validate a did:clawiverse DID format
+ */
+declare function validateDID(did: string): boolean;
+
+interface SignedMessage {
+    payload: Uint8Array;
+    signature: Uint8Array;
+    signer: string;
+}
+/**
+ * Sign a message and return a signed message object
+ */
+declare function signMessage(payload: Uint8Array, privateKey: Uint8Array, publicKey: Uint8Array): Promise<SignedMessage>;
+/**
+ * Verify a signed message
+ */
+declare function verifyMessage(signedMessage: SignedMessage, expectedPublicKey: Uint8Array): Promise<boolean>;
+
+interface TransportConfig {
+    keyPair?: KeyPair;
+    listenAddresses?: string[];
+    bootstrapPeers?: string[];
+    enableDHT?: boolean;
+    /** Allow private/local addresses in DHT routing (required for local testing) */
+    allowPrivateAddresses?: boolean;
+    /** Run as a relay server so NAT'd agents can receive messages through this node */
+    enableRelay?: boolean;
+    /** libp2p PrivateKey for persistent PeerID (from @libp2p/crypto) */
+    privateKey?: PrivateKey;
+}
+interface ClawiverseNode {
+    libp2p: Libp2p;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    getMultiaddrs: () => string[];
+    getPeerId: () => string;
+}
+/**
+ * Create a Clawiverse transport node with libp2p
+ */
+declare function createNode(config: TransportConfig): Promise<ClawiverseNode>;
+
+/**
+ * Trust Score System
+ *
+ * Tracks agent reputation based on interactions, endorsements,
+ * and network behavior.
+ */
+/**
+ * Trust Score Metrics
+ */
+interface TrustScore {
+    interactionScore: number;
+    endorsements: number;
+    completionRate: number;
+    responseTime: number;
+    uptime: number;
+    lastUpdated: number;
+}
+/**
+ * Interaction Record
+ */
+interface Interaction {
+    agentDid: string;
+    timestamp: number;
+    type: 'message' | 'task' | 'query';
+    success: boolean;
+    responseTime: number;
+    rating?: number;
+    feedback?: string;
+}
+/**
+ * Interaction Statistics
+ */
+interface InteractionStats {
+    totalInteractions: number;
+    successRate: number;
+    avgResponseTime: number;
+    lastInteraction: number;
+}
+/**
+ * Trust Metrics Calculator
+ */
+declare class TrustMetrics {
+    /**
+     * Calculate trust score from interaction history
+     */
+    calculateScore(stats: InteractionStats, endorsements: number, uptime: number): TrustScore;
+    /**
+     * Calculate overall trust level (0-1)
+     */
+    calculateOverallTrust(score: TrustScore): number;
+    /**
+     * Get trust level category
+     */
+    getTrustLevel(score: TrustScore): 'new' | 'low' | 'medium' | 'high' | 'trusted';
+    /**
+     * Check if agent should be rate limited
+     */
+    shouldRateLimit(score: TrustScore, agentAge: number): boolean;
+}
+/**
+ * Default trust score for new agents
+ */
+declare function createDefaultTrustScore(): TrustScore;
+
+/**
+ * Enhanced Agent Card Types for Phase 2
+ *
+ * Adds structured capabilities, JSON-LD support, and trust metrics
+ */
+
+/**
+ * Capability Parameter Definition
+ */
+interface CapabilityParameter {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    required: boolean;
+    description?: string;
+    enum?: string[];
+    default?: unknown;
+}
+/**
+ * Structured Capability Definition
+ */
+interface Capability {
+    '@type'?: string;
+    id: string;
+    name: string;
+    description: string;
+    parameters?: CapabilityParameter[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Enhanced Agent Card with JSON-LD support
+ */
+interface AgentCard {
+    '@context'?: string[];
+    did: string;
+    name: string;
+    description: string;
+    version: string;
+    capabilities: Capability[];
+    endpoints: string[];
+    peerId?: string;
+    trust?: TrustScore;
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+    signature: string;
+}
+/**
+ * Legacy Agent Card (Phase 1 compatibility)
+ */
+interface LegacyAgentCard {
+    did: string;
+    name: string;
+    description: string;
+    version: string;
+    capabilities: string[];
+    endpoints: string[];
+    peerId?: string;
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+    signature: string;
+}
+/**
+ * Check if card is legacy format
+ */
+declare function isLegacyCard(card: AgentCard | LegacyAgentCard): card is LegacyAgentCard;
+/**
+ * Convert legacy card to new format
+ */
+declare function upgradeLegacyCard(legacy: LegacyAgentCard): AgentCard;
+/**
+ * Convert new card to legacy format (for backward compatibility)
+ */
+declare function downgradeToLegacyCard(card: AgentCard): LegacyAgentCard;
+
+/**
+ * Create a new Agent Card (Phase 2 format with structured capabilities)
+ */
+declare function createAgentCard(did: string, name: string, description: string, capabilities: Capability[], endpoints?: string[], peerId?: string, metadata?: Record<string, unknown>): Omit<AgentCard, 'signature'>;
+/**
+ * Create a legacy Agent Card (Phase 1 format with string capabilities)
+ * For backward compatibility
+ */
+declare function createLegacyAgentCard(did: string, name: string, description: string, capabilities: string[], endpoints?: string[], peerId?: string, metadata?: Record<string, unknown>): Omit<LegacyAgentCard, 'signature'>;
+/**
+ * Validate an Agent Card structure (supports both Phase 1 and Phase 2 formats)
+ */
+declare function validateAgentCard(card: unknown): card is AgentCard | LegacyAgentCard;
+/**
+ * Sign an Agent Card
+ */
+declare function signAgentCard(card: Omit<AgentCard, 'signature'>, signFn: (data: Uint8Array) => Promise<Uint8Array>): Promise<AgentCard>;
+/**
+ * Verify an Agent Card signature
+ */
+declare function verifyAgentCard(card: AgentCard, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>): Promise<boolean>;
+/**
+ * Check if an Agent Card matches a capability query
+ * Supports both Phase 1 (string[]) and Phase 2 (Capability[]) formats
+ */
+declare function matchesCapability(card: AgentCard | LegacyAgentCard, capability: string): boolean;
+
+/**
+ * JSON-LD Schema Definitions for Agent Cards
+ *
+ * Defines the Clawiverse vocabulary and integrates with Schema.org
+ * for semantic interoperability.
+ */
+declare const CLAWIVERSE_CONTEXT = "https://clawiverse.org/context/v1";
+declare const SCHEMA_ORG_CONTEXT = "https://schema.org";
+/**
+ * Clawiverse JSON-LD Context
+ * Defines the vocabulary for Agent Cards and Capabilities
+ */
+declare const clawiverseContext: {
+    '@context': {
+        '@vocab': string;
+        schema: string;
+        AgentCard: string;
+        Capability: string;
+        did: string;
+        name: string;
+        description: string;
+        version: string;
+        capabilities: {
+            '@id': string;
+            '@type': string;
+            '@container': string;
+        };
+        endpoints: {
+            '@id': string;
+            '@container': string;
+        };
+        peerId: string;
+        trust: string;
+        metadata: string;
+        timestamp: string;
+        signature: string;
+        parameters: {
+            '@id': string;
+            '@container': string;
+        };
+    };
+};
+/**
+ * Capability Type Definitions
+ * Common capability types with semantic meaning
+ */
+declare const CapabilityTypes: {
+    readonly TRANSLATION: "TranslationService";
+    readonly CODE_REVIEW: "CodeReviewService";
+    readonly DATA_ANALYSIS: "DataAnalysisService";
+    readonly TEXT_GENERATION: "TextGenerationService";
+    readonly IMAGE_GENERATION: "ImageGenerationService";
+    readonly SEARCH: "SearchService";
+    readonly COMPUTATION: "ComputationService";
+    readonly STORAGE: "StorageService";
+    readonly MESSAGING: "MessagingService";
+    readonly AUTHENTICATION: "AuthenticationService";
+};
+/**
+ * Parameter Type Definitions
+ */
+declare const ParameterTypes: {
+    readonly STRING: "string";
+    readonly NUMBER: "number";
+    readonly BOOLEAN: "boolean";
+    readonly OBJECT: "object";
+    readonly ARRAY: "array";
+};
+/**
+ * Get JSON-LD context for Agent Card
+ */
+declare function getAgentCardContext(): string[];
+/**
+ * Validate JSON-LD context
+ */
+declare function isValidContext(context: unknown): boolean;
+
+/**
+ * Agent Card Encoder - Dual Encoding Support
+ *
+ * Provides bidirectional conversion between:
+ * - CBOR (compact binary) for DHT storage
+ * - JSON-LD (semantic) for Web publishing
+ */
+
+/**
+ * Encode Agent Card as CBOR for DHT storage
+ */
+declare function encodeForDHT(card: AgentCard): Uint8Array;
+/**
+ * Encode Agent Card as JSON-LD for Web publishing
+ */
+declare function encodeForWeb(card: AgentCard): string;
+/**
+ * Decode Agent Card from CBOR
+ */
+declare function decodeFromCBOR(data: Uint8Array): AgentCard;
+/**
+ * Decode Agent Card from JSON-LD
+ */
+declare function decodeFromJSON(json: string): AgentCard;
+/**
+ * Auto-detect format and decode
+ */
+declare function decodeAgentCard(data: Uint8Array | string): AgentCard;
+/**
+ * Calculate encoded size for comparison
+ */
+declare function getEncodedSize(card: AgentCard): {
+    cbor: number;
+    json: number;
+};
+
+/**
+ * Search Index for Agent Discovery
+ *
+ * Maintains a local index of discovered agents for fast semantic search
+ */
+
+/**
+ * Semantic Query Interface
+ */
+interface SemanticQuery {
+    text?: string;
+    capability?: string;
+    filters?: {
+        language?: string;
+        minTrustScore?: number;
+        maxCost?: number;
+        tags?: string[];
+    };
+    limit?: number;
+}
+/**
+ * Search Result with Score
+ */
+interface SearchResult {
+    card: AgentCard;
+    score: number;
+}
+/**
+ * Search Index Implementation
+ */
+declare class SearchIndex {
+    private cards;
+    private lunrIndex?;
+    private fuse?;
+    private needsRebuild;
+    /**
+     * Add or update an Agent Card in the index
+     */
+    indexAgentCard(card: AgentCard): void;
+    /**
+     * Remove an Agent Card from the index
+     */
+    removeAgentCard(did: string): void;
+    /**
+     * Search for agents matching a query
+     */
+    search(query: SemanticQuery): SearchResult[];
+    /**
+     * Get all indexed cards
+     */
+    getAllCards(): AgentCard[];
+    /**
+     * Clear the index
+     */
+    clear(): void;
+    /**
+     * Get index size
+     */
+    size(): number;
+    /**
+     * Rebuild search indexes
+     */
+    private rebuild;
+    /**
+     * Search by text using Lunr
+     */
+    private searchByText;
+    /**
+     * Search by capability using Fuse
+     */
+    private searchByCapability;
+    /**
+     * Apply filters to search results
+     */
+    private applyFilters;
+}
+
+interface ResolvedDID {
+    peerId: string;
+    multiaddrs: string[];
+}
+interface DHTOperations {
+    publishAgentCard: (card: AgentCard) => Promise<void>;
+    queryAgentCard: (did: string) => Promise<AgentCard | null>;
+    queryByCapability: (capability: string) => Promise<AgentCard[]>;
+    searchSemantic: (query: SemanticQuery) => Promise<AgentCard[]>;
+    resolveDID: (did: string) => Promise<ResolvedDID | null>;
+}
+/**
+ * Create DHT operations for a libp2p node
+ */
+declare function createDHTOperations(libp2p: Libp2p): DHTOperations;
+
+/**
+ * Capability Matcher
+ *
+ * Matches semantic queries against agent capabilities
+ */
+
+/**
+ * Capability Matcher
+ */
+declare class CapabilityMatcher {
+    /**
+     * Match a query against a capability
+     * Returns a score between 0 and 1
+     */
+    match(query: SemanticQuery, capability: Capability): number;
+    /**
+     * Extract keywords from natural language text
+     */
+    extractKeywords(text: string): string[];
+    /**
+     * Match keywords against capability
+     */
+    matchKeywords(keywords: string[], capability: Capability): number;
+    /**
+     * Check if query matches capability type hierarchy
+     */
+    matchesType(query: string, type: string): boolean;
+    /**
+     * Fuzzy string matching using Levenshtein distance
+     */
+    private fuzzyMatch;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private levenshteinDistance;
+}
+
+/**
+ * Semantic Search Engine
+ *
+ * Provides intelligent agent discovery through semantic search
+ * with local-first strategy and network fallback
+ */
+
+/**
+ * Semantic Search Engine
+ */
+declare class SemanticSearchEngine {
+    private dht?;
+    private index;
+    private matcher;
+    constructor(dht?: DHTOperations | undefined);
+    /**
+     * Main search interface
+     * Local-first with network fallback
+     */
+    search(query: SemanticQuery): Promise<AgentCard[]>;
+    /**
+     * Index an Agent Card for local search
+     */
+    indexAgentCard(card: AgentCard): void;
+    /**
+     * Remove an Agent Card from local index
+     */
+    removeAgentCard(did: string): void;
+    /**
+     * Get all indexed cards
+     */
+    getAllIndexedCards(): AgentCard[];
+    /**
+     * Clear local index
+     */
+    clearIndex(): void;
+    /**
+     * Get index size
+     */
+    getIndexSize(): number;
+    /**
+     * Search network via DHT
+     */
+    private searchNetwork;
+    /**
+     * Merge local and network results, removing duplicates
+     */
+    private mergeResults;
+    /**
+     * Score a card against a query
+     */
+    private scoreCard;
+    /**
+     * Extract primary capability from natural language text
+     */
+    private extractPrimaryCapability;
+}
+/**
+ * Create a semantic search engine
+ */
+declare function createSemanticSearch(dht?: DHTOperations): SemanticSearchEngine;
+
+interface MessageEnvelope {
+    id: string;
+    from: string;
+    to: string;
+    type: 'request' | 'response' | 'notification';
+    protocol: string;
+    payload: unknown;
+    timestamp: number;
+    signature: string;
+    replyTo?: string;
+}
+/**
+ * Create a message envelope
+ */
+declare function createEnvelope(from: string, to: string, type: 'request' | 'response' | 'notification', protocol: string, payload: unknown, replyTo?: string): Omit<MessageEnvelope, 'signature'>;
+/**
+ * Sign a message envelope
+ */
+declare function signEnvelope(envelope: Omit<MessageEnvelope, 'signature'>, signFn: (data: Uint8Array) => Promise<Uint8Array>): Promise<MessageEnvelope>;
+/**
+ * Verify a message envelope signature
+ */
+declare function verifyEnvelope(envelope: MessageEnvelope, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>): Promise<boolean>;
+/**
+ * Validate message envelope structure
+ */
+declare function validateEnvelope(msg: unknown): msg is MessageEnvelope;
+
+/**
+ * Encode a message envelope to CBOR
+ */
+declare function encodeMessage(envelope: MessageEnvelope): Uint8Array;
+/**
+ * Decode a CBOR message to envelope
+ */
+declare function decodeMessage(data: Uint8Array): MessageEnvelope;
+/**
+ * Encode message to JSON (for debugging/logging)
+ */
+declare function encodeMessageJSON(envelope: MessageEnvelope): string;
+/**
+ * Decode JSON message to envelope
+ */
+declare function decodeMessageJSON(json: string): MessageEnvelope;
+
+type MessageHandler = (envelope: MessageEnvelope) => Promise<MessageEnvelope | void>;
+interface PeerHint {
+    peerId: string;
+    multiaddrs: string[];
+}
+interface MessageRouter {
+    registerHandler: (protocol: string, handler: MessageHandler) => void;
+    unregisterHandler: (protocol: string) => void;
+    sendMessage: (envelope: MessageEnvelope, peerHint?: PeerHint) => Promise<MessageEnvelope | void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+}
+/**
+ * Create a message router for a libp2p node.
+ * When dht is provided, sendMessage can resolve DIDs to peer addresses via DHT lookup.
+ */
+declare function createMessageRouter(libp2p: Libp2p, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>, dht?: DHTOperations): MessageRouter;
+
+/**
+ * Sybil Defense Mechanisms
+ *
+ * Protects the network from Sybil attacks through:
+ * - Entry cost (Hashcash challenges)
+ * - Progressive trust (rate limiting for new agents)
+ * - DHT region protection (prefer established peers)
+ */
+/**
+ * Hashcash Challenge
+ */
+interface Challenge {
+    did: string;
+    difficulty: number;
+    nonce: string;
+    timestamp: number;
+}
+/**
+ * Challenge Solution
+ */
+interface ChallengeSolution {
+    challenge: Challenge;
+    solution: string;
+}
+/**
+ * Peer Trust Level
+ */
+type PeerTrustLevel = 'new' | 'established' | 'trusted';
+/**
+ * Sybil Defense Manager
+ */
+declare class SybilDefense {
+    private rateLimits;
+    private peerFirstSeen;
+    private readonly NEW_AGENT_WINDOW;
+    private readonly RATE_LIMIT_WINDOW;
+    private readonly MAX_REQUESTS_NEW;
+    private readonly ESTABLISHED_THRESHOLD;
+    /**
+     * Generate a Hashcash challenge for a new DID
+     */
+    generateChallenge(did: string, difficulty?: number): Challenge;
+    /**
+     * Verify a Hashcash challenge solution
+     */
+    verifyChallenge(solution: ChallengeSolution): boolean;
+    /**
+     * Check if an agent should be rate limited
+     */
+    isRateLimited(did: string): boolean;
+    /**
+     * Record a request from an agent
+     */
+    recordRequest(did: string): void;
+    /**
+     * Get peer trust level based on age
+     */
+    getPeerTrustLevel(peerId: string): PeerTrustLevel;
+    /**
+     * Record first seen time for a peer
+     */
+    recordPeerSeen(peerId: string): void;
+    /**
+     * Clean up old records
+     */
+    cleanup(): void;
+    /**
+     * Generate a random nonce
+     */
+    private generateNonce;
+    /**
+     * Count leading zero bits in a hash
+     */
+    private countLeadingZeroBits;
+}
+
+/**
+ * Interaction History Tracker
+ *
+ * Records and queries agent interaction history for trust scoring
+ */
+
+/**
+ * Interaction History Manager
+ */
+declare class InteractionHistory {
+    private db;
+    constructor(dbPath: string);
+    /**
+     * Open database connection
+     */
+    open(): Promise<void>;
+    /**
+     * Close database connection
+     */
+    close(): Promise<void>;
+    /**
+     * Record an interaction
+     */
+    record(interaction: Interaction): Promise<void>;
+    /**
+     * Get interaction history for an agent
+     */
+    getHistory(agentDid: string, limit?: number): Promise<Interaction[]>;
+    /**
+     * Get interaction statistics for an agent
+     */
+    getStats(agentDid: string): Promise<InteractionStats>;
+    /**
+     * Get all agents with interaction history
+     */
+    getAllAgents(): Promise<string[]>;
+    /**
+     * Delete all interactions for an agent
+     */
+    deleteAgent(agentDid: string): Promise<void>;
+    /**
+     * Clean up old interactions (older than 90 days)
+     */
+    cleanup(maxAge?: number): Promise<number>;
+}
+
+/**
+ * Endorsement System
+ *
+ * Allows agents to endorse each other, building a web of trust
+ */
+
+/**
+ * Endorsement Record
+ */
+interface Endorsement {
+    from: string;
+    to: string;
+    score: number;
+    reason: string;
+    timestamp: number;
+    signature: string;
+}
+/**
+ * Sign function type
+ */
+type SignFunction = (data: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Verify function type
+ */
+type VerifyFunction = (signature: Uint8Array, data: Uint8Array, publicKey: Uint8Array) => Promise<boolean>;
+/**
+ * Endorsement Manager
+ */
+declare class EndorsementManager {
+    private db;
+    private getPublicKey;
+    constructor(db: Level<string, Endorsement>, getPublicKey: (did: string) => Promise<Uint8Array>);
+    /**
+     * Create an endorsement
+     */
+    endorse(fromDid: string, toDid: string, score: number, reason: string, signFn: SignFunction): Promise<Endorsement>;
+    /**
+     * Verify endorsement signature
+     */
+    verify(endorsement: Endorsement, verifyFn: VerifyFunction): Promise<boolean>;
+    /**
+     * Publish endorsement to local database
+     */
+    publish(endorsement: Endorsement): Promise<void>;
+    /**
+     * Get all endorsements for an agent
+     */
+    getEndorsements(agentDid: string): Promise<Endorsement[]>;
+    /**
+     * Get endorsements given by an agent
+     */
+    getEndorsementsBy(fromDid: string): Promise<Endorsement[]>;
+    /**
+     * Calculate average endorsement score
+     */
+    getAverageScore(agentDid: string): Promise<number>;
+    /**
+     * Delete an endorsement
+     */
+    deleteEndorsement(fromDid: string, toDid: string): Promise<void>;
+}
+
+/**
+ * Trust System Configuration
+ */
+interface TrustSystemConfig {
+    dbPath: string;
+    getPublicKey: (did: string) => Promise<Uint8Array>;
+}
+/**
+ * Unified Trust System
+ */
+declare class TrustSystem {
+    private metrics;
+    private history;
+    private endorsements;
+    private sybilDefense;
+    private trustCache;
+    private readonly CACHE_TTL;
+    constructor(config: TrustSystemConfig);
+    /**
+     * Initialize the trust system
+     */
+    start(): Promise<void>;
+    /**
+     * Shutdown the trust system
+     */
+    stop(): Promise<void>;
+    /**
+     * Record an interaction
+     */
+    recordInteraction(interaction: Interaction): Promise<void>;
+    /**
+     * Get trust score for an agent
+     */
+    getTrustScore(agentDid: string): Promise<TrustScore>;
+    /**
+     * Create an endorsement
+     */
+    endorse(fromDid: string, toDid: string, score: number, reason: string, signFn: SignFunction): Promise<Endorsement>;
+    /**
+     * Get endorsements for an agent
+     */
+    getEndorsements(agentDid: string): Promise<Endorsement[]>;
+    /**
+     * Verify an endorsement
+     */
+    verifyEndorsement(endorsement: Endorsement, verifyFn: VerifyFunction): Promise<boolean>;
+    /**
+     * Check if agent should be rate limited
+     */
+    isRateLimited(agentDid: string): boolean;
+    /**
+     * Generate Sybil defense challenge
+     */
+    generateChallenge(did: string, difficulty?: number): Challenge;
+    /**
+     * Verify Sybil defense challenge
+     */
+    verifyChallenge(solution: any): boolean;
+    /**
+     * Get peer trust level
+     */
+    getPeerTrustLevel(peerId: string): PeerTrustLevel;
+    /**
+     * Record peer seen
+     */
+    recordPeerSeen(peerId: string): void;
+    /**
+     * Get interaction history
+     */
+    getHistory(agentDid: string, limit?: number): Promise<Interaction[]>;
+    /**
+     * Clean up old data
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Create a trust system instance
+ */
+declare function createTrustSystem(config: TrustSystemConfig): TrustSystem;
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+declare class Logger {
+    private level;
+    private prefix;
+    constructor(prefix: string, level?: LogLevel);
+    setLevel(level: LogLevel): void;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+declare const createLogger: (prefix: string, level?: LogLevel) => Logger;
+
+declare class ClawiverseError extends Error {
+    code: string;
+    details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+declare class IdentityError extends ClawiverseError {
+    constructor(message: string, details?: unknown);
+}
+declare class TransportError extends ClawiverseError {
+    constructor(message: string, details?: unknown);
+}
+declare class DiscoveryError extends ClawiverseError {
+    constructor(message: string, details?: unknown);
+}
+declare class MessagingError extends ClawiverseError {
+    constructor(message: string, details?: unknown);
+}
+
+export { type AgentCard, CLAWIVERSE_CONTEXT, type Capability, CapabilityMatcher, type CapabilityParameter, CapabilityTypes, type Challenge, type ChallengeSolution, ClawiverseError, type ClawiverseNode, type DHTOperations, DiscoveryError, type Endorsement, EndorsementManager, IdentityError, type Interaction, InteractionHistory, type InteractionStats, type KeyPair, type LegacyAgentCard, LogLevel, Logger, type MessageEnvelope, type MessageHandler, type MessageRouter, MessagingError, ParameterTypes, type PeerHint, type PeerTrustLevel, type ResolvedDID, SCHEMA_ORG_CONTEXT, SearchIndex, type SearchResult, type SemanticQuery, SemanticSearchEngine, type SignFunction, type SignedMessage, SybilDefense, type TransportConfig, TransportError, TrustMetrics, type TrustScore, TrustSystem, type TrustSystemConfig, type VerifyFunction, clawiverseContext, createAgentCard, createDHTOperations, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createNode, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };